Merge b626-mtconnect (batch #626+)

Claude-Session: https://claude.ai/code/session_01Ef2ozxS7QPanGT8uoATbTe

src/Core/ZB.MOM.WW.OtOpcUa.Configuration/Validation/DraftValidator.cs

@@ -41,6 +41,7 @@ public static class DraftValidator
         ValidateEquipReferenceResolution(draft, errors);
         ValidateCalculationTags(draft, errors);
         ValidateSqlConnectionStringNotPersisted(draft, errors);
+        ValidateMTConnectSingleDevice(draft, errors);
         ValidateNodeAclScopes(draft, errors);
         return errors;
     }
@@ -343,6 +344,42 @@ public static class DraftValidator
         }
     }
 
+    /// <summary>Error code for an MTConnect driver instance that has more than one <c>/raw</c> Device (#628).</summary>
+    public const string MTConnectMultipleDevicesCode = "MTConnectMultipleDevices";
+
+    /// <summary>
+    ///     The one message both the deploy gate and the authoring-time guard (<c>RawTreeService.CreateDeviceAsync</c>)
+    ///     use, so the two can never describe different rules.
+    /// </summary>
+    /// <param name="driverLabel">The driver instance id or name to cite.</param>
+    public static string MTConnectMultipleDevicesMessage(string driverLabel) =>
+        $"MTConnect driver '{driverLabel}' has more than one Device. MTConnect binds all tags through one agent " +
+        "client per driver instance and does not route by /raw Device, and with several Devices the Device's " +
+        "DeviceConfig (agent URI / device name) is no longer merged into the driver config, so which Device would " +
+        "supply the endpoint is ambiguous. Author one MTConnect driver per agent device, each with a single Device.";
+
+    /// <summary>
+    ///     #628 (decision (b)): an MTConnect driver instance owns exactly one agent client, so a second <c>/raw</c>
+    ///     Device under it is a genuine ambiguity — the driver ignores <c>RawTagEntry.DeviceName</c>, and
+    ///     <c>DriverDeviceConfigMerger</c> only merges a Device's <c>DeviceConfig</c> up to the driver config when
+    ///     there is exactly ONE Device. The normal single-Device layout (every driver gets a default
+    ///     <c>Device1</c>) stays valid.
+    /// </summary>
+    private static void ValidateMTConnectSingleDevice(DraftSnapshot draft, List<ValidationError> errors)
+    {
+        foreach (var driver in draft.DriverInstances)
+        {
+            if (!string.Equals(driver.DriverType, Core.Abstractions.DriverTypeNames.MTConnect, StringComparison.Ordinal))
+                continue;
+            var count = draft.Devices.Count(d =>
+                string.Equals(d.DriverInstanceId, driver.DriverInstanceId, StringComparison.Ordinal));
+            if (count <= 1) continue;
+            errors.Add(new(MTConnectMultipleDevicesCode,
+                MTConnectMultipleDevicesMessage(driver.Name) + $" ({count} Devices found.)",
+                driver.DriverInstanceId));
+        }
+    }
+
     /// <summary>WP7 Calculation-driver deploy gates. For every tag bound to a <c>Calculation</c> driver:
     /// <list type="number">
     ///   <item><b>scriptId existence</b> — the tag's <c>TagConfig.scriptId</c> must be present and resolve to

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.MTConnect/MTConnectDtos.cs

@@ -158,11 +158,22 @@ public sealed record MTConnectStreamsResult(
 ///         <c>false</c>, the shape of every ordinary scalar observation.
 ///     </para>
 /// </param>
+/// <param name="SampleCount">
+///     The observation's own <c>sampleCount</c> attribute — the number of values a <c>TIME_SERIES</c>
+///     vector claims to carry (#627). The index checks the parsed vector against it. <c>null</c> when absent.
+/// </param>
+/// <param name="SampleRate">
+///     The observation's own <c>sampleRate</c> attribute (samples per second) on a <c>TIME_SERIES</c>
+///     observation. Carried for the parser contract; not yet surfaced on the served node (see
+///     docs/drivers/MTConnect.md). <c>null</c> when absent.
+/// </param>
 public sealed record MTConnectObservation(
     string DataItemId,
     string Value,
     DateTime TimestampUtc,
-    bool IsStructured = false);
+    bool IsStructured = false,
+    int? SampleCount = null,
+    double? SampleRate = null);
 
 /// <summary>
 ///     Recursive helpers over the <see cref="IMTConnectComponentContainer"/> device/component tree.

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.MTConnect/MTConnectObservationIndex.cs

@@ -49,8 +49,8 @@ namespace ZB.MOM.WW.OtOpcUa.Driver.MTConnect;
 ///     </para>
 ///     <para>
 ///         <b>Shapes this build does not represent</b> are coded <c>BadNotSupported</c> with a null
-///         value rather than approximated: a <c>TIME_SERIES</c> vector (array materialization is
-///         deferred to P1.5) and a <c>DATA_SET</c> / <c>TABLE</c> observation. The latter carries its
+///         value rather than approximated: a non-Float64 array tag and a <c>DATA_SET</c> / <c>TABLE</c>
+///         observation (a Float64 <c>TIME_SERIES</c> vector is served as <c>double[]</c>, #627). The latter carries its
 ///         real content in <c>&lt;Entry key=…&gt;</c> child elements, which reach a text-valued
 ///         observation concatenated with the keys discarded — a two-entry set reads as the single
 ///         token <c>"12"</c> — and because the type inference correctly demotes those
@@ -85,9 +85,12 @@ internal sealed class MTConnectObservationIndex
     /// <summary>The Agent reported a number the authored type cannot represent.</summary>
     private const uint BadOutOfRange = 0x803C0000u;
 
-    /// <summary>The observation's shape is real data this build cannot represent (TIME_SERIES vectors).</summary>
+    /// <summary>The observation's shape is real data this build cannot represent (a DATA_SET/TABLE, or a non-Float64 array tag).</summary>
     private const uint BadNotSupported = 0x803D0000u;
 
+    /// <summary>A TIME_SERIES vector whose element count disagrees with its declared <c>sampleCount</c>.</summary>
+    private const uint BadDecodingError = 0x80070000u;
+
     /// <summary>The Agent reported text that is not a value of the authored type at all.</summary>
     private const uint BadTypeMismatch = 0x80740000u;
 
@@ -268,13 +271,11 @@ internal sealed class MTConnectObservationIndex
 
         _tags.TryGetValue(observation.DataItemId, out var tag);
 
-        // TIME_SERIES vectors arrive as one space-separated string. P1 does not materialize OPC UA
-        // arrays (deferred to P1.5), and the honest answer is "real data I cannot represent" — not a
-        // type mismatch, and emphatically not the first element parsed out and served as Good.
-        // Checked AFTER the sentinel so an unavailable array tag still reports the truthful no-comms.
+        // TIME_SERIES vectors arrive as one whitespace-separated string (#627). Checked AFTER the
+        // sentinel so an unavailable array tag still reports the truthful no-comms.
         if (tag is { IsArray: true })
         {
-            return new DataValueSnapshot(null, BadNotSupported, sourceTimestamp, serverTimestamp);
+            return BuildArraySnapshot(observation, tag, sourceTimestamp, serverTimestamp);
         }
 
         // An unauthored observation has no declared target type; String is the only coercion that
@@ -286,6 +287,40 @@ internal sealed class MTConnectObservationIndex
             : new DataValueSnapshot(null, status, sourceTimestamp, serverTimestamp);
     }
 
+    /// <summary>
+    ///     Parses a <c>TIME_SERIES</c> vector into a <c>double[]</c>. Only <see cref="DriverDataType.Float64"/>
+    ///     arrays are served (the MTConnect TIME_SERIES element type is a floating-point sample); any other
+    ///     authored array type is <c>BadNotSupported</c> rather than an approximation. All-or-nothing: one
+    ///     unparseable or non-finite token, or a count that disagrees with the observation's own
+    ///     <c>sampleCount</c> (or the tag's fixed <c>ArrayDim</c>), makes the whole vector Bad — a partial
+    ///     vector served as Good would be a silently wrong waveform.
+    /// </summary>
+    private static DataValueSnapshot BuildArraySnapshot(
+        MTConnectObservation observation, MTConnectTagDefinition tag, DateTime sourceTimestamp, DateTime serverTimestamp)
+    {
+        DataValueSnapshot Bad(uint status) => new(null, status, sourceTimestamp, serverTimestamp);
+
+        if (tag.DriverDataType != DriverDataType.Float64) return Bad(BadNotSupported);
+
+        var tokens = observation.Value.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries);
+        var values = new double[tokens.Length];
+        for (var i = 0; i < tokens.Length; i++)
+        {
+            if (string.Equals(tokens[i], UnavailableSentinel, StringComparison.Ordinal)) return Bad(BadNoCommunication);
+
+            if (!double.TryParse(tokens[i], NumberStyles.Float, CultureInfo.InvariantCulture, out values[i]) ||
+                !double.IsFinite(values[i]))
+            {
+                return Bad(BadTypeMismatch);
+            }
+        }
+
+        if (observation.SampleCount is { } declared && declared != values.Length) return Bad(BadDecodingError);
+        if (tag.ArrayDim > 0 && tag.ArrayDim != values.Length) return Bad(BadDecodingError);
+
+        return new DataValueSnapshot(values, Good, sourceTimestamp, serverTimestamp);
+    }
+
     /// <summary>
     ///     Converts the Agent's text to the tag's authored type. Every parse is
     ///     <see cref="CultureInfo.InvariantCulture"/>: MTConnect is an invariant-format wire, and a

src/Drivers/ZB.MOM.WW.OtOpcUa.Driver.MTConnect/MTConnectStreamsParser.cs

@@ -377,6 +377,8 @@ internal static class MTConnectStreamsParser
         string? dataItemId = null;
         var timestampUtc = default(DateTime);
         string? conditionState = null;
+        int? sampleCount = null;
+        double? sampleRate = null;
 
         if (isObservation)
         {
@@ -385,6 +387,24 @@ internal static class MTConnectStreamsParser
             timestampUtc = ReadTimestampUtc(reader, dataItemId);
             conditionState = isCondition ? ConditionState(name) : null;
 
+            // TIME_SERIES metadata rides the observation element itself. Read here, before the subtree
+            // walk moves the reader off this element's attributes. Lenient: a vendor's unparseable
+            // attribute is dropped rather than failing the whole document (the vector is checked
+            // against the declared sampleCount only when one parses).
+            if (!isCondition)
+            {
+                sampleCount = int.TryParse(
+                    MTConnectXml.OptionalAttribute(reader, "sampleCount"),
+                    NumberStyles.Integer,
+                    CultureInfo.InvariantCulture,
+                    out var count) && count >= 0 ? count : null;
+                sampleRate = double.TryParse(
+                    MTConnectXml.OptionalAttribute(reader, "sampleRate"),
+                    NumberStyles.Float,
+                    CultureInfo.InvariantCulture,
+                    out var rate) && double.IsFinite(rate) ? rate : null;
+            }
+
             // The slot is reserved BEFORE the subtree is read, and filled after: an observation is
             // only complete once its text and its child-element flag are known, but appending it
             // then would report a nested observation ahead of the one enclosing it. The tree walk
@@ -430,7 +450,9 @@ internal static class MTConnectStreamsParser
             // MTConnectObservation.IsStructured. Never true for a CONDITION: its value comes from
             // the element NAME, so child content cannot corrupt it, and flagging one would throw
             // away a perfectly well-determined state.
-            IsStructured: !isCondition && hasElements);
+            IsStructured: !isCondition && hasElements,
+            SampleCount: sampleCount,
+            SampleRate: sampleRate);
     }
 
     /// <summary>

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/RawTreeService.cs

@@ -5,6 +5,7 @@ using ZB.MOM.WW.OtOpcUa.AdminUI.Uns.TagEditors;
 using ZB.MOM.WW.OtOpcUa.Commons.Types;
 using ZB.MOM.WW.OtOpcUa.Configuration;
 using ZB.MOM.WW.OtOpcUa.Configuration.Entities;
+using ZB.MOM.WW.OtOpcUa.Configuration.Validation;
 using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
 
 namespace ZB.MOM.WW.OtOpcUa.AdminUI.Uns;
@@ -615,9 +616,16 @@ public sealed class RawTreeService(IDbContextFactory<OtOpcUaConfigDbContext> dbF
 
         await using var db = await dbFactory.CreateDbContextAsync(ct);
 
-        if (!await db.DriverInstances.AnyAsync(d => d.DriverInstanceId == driverInstanceId, ct))
+        var owner = await db.DriverInstances.FirstOrDefaultAsync(d => d.DriverInstanceId == driverInstanceId, ct);
+        if (owner is null)
             return new UnsMutationResult(false, $"Driver '{driverInstanceId}' not found.");
 
+        // #628: MTConnect owns one agent client per driver — mirror the deploy gate
+        // (DraftValidator.ValidateMTConnectSingleDevice) so the second Device is refused where it is authored.
+        if (string.Equals(owner.DriverType, DriverTypeNames.MTConnect, StringComparison.Ordinal)
+            && await db.Devices.AnyAsync(dev => dev.DriverInstanceId == driverInstanceId, ct))
+            return new UnsMutationResult(false, DraftValidator.MTConnectMultipleDevicesMessage(owner.Name));
+
         if (await db.Devices.AnyAsync(dev => dev.DriverInstanceId == driverInstanceId && dev.Name == name, ct))
             return new UnsMutationResult(false, $"A device named '{name}' already exists on this driver.");
 

src/Server/ZB.MOM.WW.OtOpcUa.AdminUI/Uns/TagEditors/MTConnectTagConfigModel.cs

@@ -229,10 +229,25 @@ public sealed class MTConnectTagConfigModel
     ///     passed as null; it can only DEMOTE an item to String (DATA_SET/TABLE), which cannot create a false
     ///     warning because a numeric declaration on a String-inferred item is warned either way, and a SAMPLE
     ///     inferred Float64 is only warned about for a non-numeric, non-String declaration or an integer one.
-    ///     TIME_SERIES arrays are not detectable without it and are not covered.
+    ///     TIME_SERIES arrays are covered separately by the isArray rule in <see cref="Warnings"/>.
     /// </remarks>
     /// <returns>Zero or more human-readable warnings.</returns>
     public IReadOnlyList<string> Warnings()
+    {
+        // #627: an array (TIME_SERIES) tag is served as double[] only. Independent of the probe metadata —
+        // the array flag is authored on the tag, and any other declared element type reads BadNotSupported.
+        var arrayWarning = _bag.TryGetPropertyValue("isArray", out var arr)
+                           && arr is JsonValue av && av.TryGetValue<bool>(out var isArray) && isArray
+                           && DataType != DriverDataType.Float64
+            ? $"Data type {DataType} on an array tag: MTConnect TIME_SERIES arrays are served as Float64 (double[]) only; "
+              + "declare Float64 or the tag reads BadNotSupported. Saving is still allowed."
+            : null;
+
+        var scalar = ScalarWarnings();
+        return arrayWarning is null ? scalar : [arrayWarning, .. scalar];
+    }
+
+    private IReadOnlyList<string> ScalarWarnings()
     {
         if (string.IsNullOrWhiteSpace(MtCategory)) { return []; }