Merge R2-11 TagConfig consolidation (arch-review round 2) [PR #434]

Findings 01/C-1, 01/P-1 (single TagConfigIntent.Parse in Commons, 4 copies
delegate, parse-once) + 05 CONV-2/UNDER-1/UNDER-6 (shared strict TagConfigJson
readers, per-driver Inspect() + writable key, FOCAS capability pre-flight,
Modbus probe timeoutMs, deploy-gate Warn|Error). Phase C runtime-strict flip
deferred. T22/T24 deferred. Auto-merged AddressSpaceApplier.cs + DriverHostActor.cs
with R2-04/R2-10; verified OpcUaServer.Tests 286/286 + Runtime.Tests 396/396.
Build clean.

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/Drivers/DeploymentArtifact.cs

@@ -458,8 +458,10 @@ public static class DeploymentArtifact
             // ordinary equipment tags now (GalaxyMxGateway is a standard Equipment-kind driver).
             if (!equipmentNamespaces.Contains(nsId)) continue;
 
-            var (isHistorized, historianTagname) = ExtractTagHistorize(tagConfig);
-            var (isArray, arrayLength) = ExtractTagArray(tagConfig);
+            // Parse the schemaless TagConfig blob ONCE per tag via the shared byte-parity authority
+            // (01/C-1) — the SAME TagConfigIntent.Parse the live-compose seam (AddressSpaceComposer)
+            // consumes, so the artifact-decode plan stays byte-equal with the composer's.
+            var intent = TagConfigIntent.Parse(tagConfig);
             result.Add(new EquipmentTagPlan(
                 TagId: tagId!,
                 EquipmentId: equipmentId!,
@@ -467,13 +469,13 @@ public static class DeploymentArtifact
                 FolderPath: folder ?? string.Empty,
                 Name: name!,
                 DataType: dataType ?? "BaseDataType",
-                FullName: ExtractTagFullName(tagConfig),
+                FullName: intent.FullName,
                 Writable: writable,
-                Alarm: ExtractTagAlarm(tagConfig),
-                IsHistorized: isHistorized,
-                HistorianTagname: historianTagname,
-                IsArray: isArray,
-                ArrayLength: arrayLength));
+                Alarm: intent.Alarm is { } a ? new EquipmentTagAlarmInfo(a.AlarmType, a.Severity, a.HistorizeToAveva) : null,
+                IsHistorized: intent.IsHistorized,
+                HistorianTagname: intent.HistorianTagname,
+                IsArray: intent.IsArray,
+                ArrayLength: intent.ArrayLength));
         }
 
         result.Sort((a, b) =>
@@ -665,113 +667,6 @@ public static class DeploymentArtifact
         return result;
     }
 
-    /// <summary>
-    ///     Extract the driver-side full reference from a tag's TagConfig JSON (top-level "FullName"
-    ///     field). The artifact-decode mirror of <c>AddressSpaceComposer.ExtractTagFullName</c> /
-    ///     <c>EquipmentNodeWalker.ExtractFullName</c> — replicated because Runtime does not reference
-    ///     the Core driver assembly. Falls back to the raw blob when absent or non-JSON.
-    /// </summary>
-    private static string ExtractTagFullName(string? tagConfig)
-    {
-        if (string.IsNullOrWhiteSpace(tagConfig)) return tagConfig ?? string.Empty;
-        try
-        {
-            using var doc = JsonDocument.Parse(tagConfig);
-            if (doc.RootElement.ValueKind == JsonValueKind.Object
-                && doc.RootElement.TryGetProperty("FullName", out var fullName)
-                && fullName.ValueKind == JsonValueKind.String)
-            {
-                return fullName.GetString() ?? tagConfig;
-            }
-        }
-        catch (JsonException) { /* fall through to raw blob */ }
-        return tagConfig;
-    }
-
-    /// <summary>Parses the optional <c>alarm</c> object from a tag's <c>TagConfig</c> JSON. Returns null
-    /// when absent, non-object, or non-JSON (the tag is then a plain variable). Never throws. The
-    /// live-edit side (<c>AddressSpaceComposer.ExtractTagAlarm</c>) MUST parse identically (byte-parity).</summary>
-    private static EquipmentTagAlarmInfo? ExtractTagAlarm(string? tagConfig)
-    {
-        if (string.IsNullOrWhiteSpace(tagConfig)) return null;
-        try
-        {
-            using var doc = JsonDocument.Parse(tagConfig);
-            if (doc.RootElement.ValueKind != JsonValueKind.Object) return null;
-            if (!doc.RootElement.TryGetProperty("alarm", out var a) || a.ValueKind != JsonValueKind.Object) return null;
-            var type = a.TryGetProperty("alarmType", out var tEl) && tEl.ValueKind == JsonValueKind.String
-                ? (tEl.GetString() ?? "AlarmCondition") : "AlarmCondition";
-            var sev = a.TryGetProperty("severity", out var sEl) && sEl.ValueKind == JsonValueKind.Number
-                && sEl.TryGetInt32(out var sv) ? sv : 500;
-            // historizeToAveva (bool?, absent ⇒ null ⇒ historize): byte-parity with
-            // AddressSpaceComposer.ExtractTagAlarm — only an explicit false suppresses the durable AVEVA write.
-            bool? historize = a.TryGetProperty("historizeToAveva", out var hEl)
-                    && hEl.ValueKind is JsonValueKind.True or JsonValueKind.False
-                ? hEl.GetBoolean()
-                : null;
-            return new EquipmentTagAlarmInfo(type, sev, historize);
-        }
-        catch (JsonException) { return null; }
-    }
-
-    /// <summary>Parses the optional server-side HistoryRead intent from a tag's <c>TagConfig</c> JSON:
-    /// the <c>isHistorized</c> bool (absent / not a bool / non-object root / blank / malformed ⇒
-    /// <c>false</c>) and the optional <c>historianTagname</c> string override (absent / not a string /
-    /// whitespace-or-empty ⇒ <c>null</c>, meaning the historian tagname defaults to the tag's FullName,
-    /// resolved later). The raw string value is used — not trimmed — matching <c>ExtractTagFullName</c> /
-    /// <c>ExtractTagAlarm</c>. Never throws. The live-edit composer side
-    /// (<c>AddressSpaceComposer.ExtractTagHistorize</c>) MUST parse identically (byte-parity).</summary>
-    private static (bool IsHistorized, string? HistorianTagname) ExtractTagHistorize(string? tagConfig)
-    {
-        if (string.IsNullOrWhiteSpace(tagConfig)) return (false, null);
-        try
-        {
-            using var doc = JsonDocument.Parse(tagConfig);
-            if (doc.RootElement.ValueKind != JsonValueKind.Object) return (false, null);
-            var isHistorized = doc.RootElement.TryGetProperty("isHistorized", out var hEl)
-                && (hEl.ValueKind == JsonValueKind.True || hEl.ValueKind == JsonValueKind.False)
-                && hEl.GetBoolean();
-            string? tagname = null;
-            if (doc.RootElement.TryGetProperty("historianTagname", out var nEl)
-                && nEl.ValueKind == JsonValueKind.String)
-            {
-                var raw = nEl.GetString();
-                if (!string.IsNullOrWhiteSpace(raw)) tagname = raw;
-            }
-            return (isHistorized, tagname);
-        }
-        catch (JsonException) { return (false, null); }
-    }
-
-    /// <summary>Parses the optional array intent from a tag's <c>TagConfig</c> JSON: the <c>isArray</c>
-    /// bool (absent / not a bool / non-object root / blank / malformed ⇒ <c>false</c>) and the optional
-    /// <c>arrayLength</c> uint (honoured ONLY when <c>isArray</c> is true AND the prop is a JSON number
-    /// that fits <c>uint</c>; else <c>null</c>). Mirrors <see cref="ExtractTagHistorize"/> in structure +
-    /// null/blank/non-object/malformed-JSON tolerance. Never throws. The live-edit composer side
-    /// (<c>AddressSpaceComposer.ExtractTagArray</c>) MUST parse identically (byte-parity).</summary>
-    private static (bool IsArray, uint? ArrayLength) ExtractTagArray(string? tagConfig)
-    {
-        if (string.IsNullOrWhiteSpace(tagConfig)) return (false, null);
-        try
-        {
-            using var doc = JsonDocument.Parse(tagConfig);
-            if (doc.RootElement.ValueKind != JsonValueKind.Object) return (false, null);
-            var isArray = doc.RootElement.TryGetProperty("isArray", out var aEl)
-                && (aEl.ValueKind == JsonValueKind.True || aEl.ValueKind == JsonValueKind.False)
-                && aEl.GetBoolean();
-            uint? arrayLength = null;
-            if (isArray
-                && doc.RootElement.TryGetProperty("arrayLength", out var lEl)
-                && lEl.ValueKind == JsonValueKind.Number
-                && lEl.TryGetUInt32(out var len))
-            {
-                arrayLength = len;
-            }
-            return (isArray, arrayLength);
-        }
-        catch (JsonException) { return (false, null); }
-    }
-
     private static IReadOnlyList<T> ReadArray<T>(JsonElement root, string propertyName, Func<JsonElement, T?> reader)
         where T : class
     {
@@ -819,7 +714,7 @@ public static class DeploymentArtifact
 
     /// <summary>Build the <c>DeviceId</c> → connection-host map from the artifact's <c>Devices</c> array
     /// (each row carries a <c>DeviceId</c> + schemaless <c>DeviceConfig</c> JSON). The host is resolved via
-    /// the shared <see cref="AddressSpaceComposer.TryExtractDeviceHost"/> so the artifact-decode side
+    /// the shared <see cref="DeviceConfigIntent.TryExtractHost"/> so the artifact-decode side
     /// normalizes byte-identically to the live-edit composer. Ordinal comparer + last-wins on a duplicate
     /// DeviceId. A missing/empty/non-array <c>Devices</c> property yields an empty map (no device hosts).</summary>
     /// <param name="root">The artifact root element.</param>
@@ -834,7 +729,7 @@ public static class DeploymentArtifact
             if (el.ValueKind != JsonValueKind.Object) continue;
             var deviceId = ReadString(el, "DeviceId");
             if (string.IsNullOrWhiteSpace(deviceId)) continue;
-            map[deviceId!] = AddressSpaceComposer.TryExtractDeviceHost(ReadString(el, "DeviceConfig"));
+            map[deviceId!] = DeviceConfigIntent.TryExtractHost(ReadString(el, "DeviceConfig"));
         }
         return map;
     }

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/Drivers/DriverHostActor.cs

@@ -728,7 +728,7 @@ public sealed class DriverHostActor : ReceiveActor, IWithTimers
     ///         host folder) is warn-skipped — its nodes are NOT mis-grafted; the matched partitions still graft.</item>
     ///     </list>
     ///     The device-host folder segment AND the stored DeviceHost are both run through the SAME
-    ///     <see cref="AddressSpaceComposer.NormalizeDeviceHost"/> (single source of truth), so they compare equal
+    ///     <see cref="DeviceConfigIntent.NormalizeHost"/> (single source of truth), so they compare equal
     ///     regardless of case/whitespace.
     ///     <para><b>Warn-spam taming.</b> The unmatched/ambiguous/degenerate condition is warned ONCE then
     ///     Debug-logged on the repeated re-discovery passes (see <see cref="ShouldWarnPartition"/>).</para>
@@ -755,7 +755,7 @@ public sealed class DriverHostActor : ReceiveActor, IWithTimers
             if (!candidateSet.Contains(node.EquipmentId) || node.DeviceHost is null) continue;
             // DeviceHost is already normalized at compose/decode time; re-normalize through the shared helper so
             // the comparison is the single source of truth (idempotent — harmless if it was already normalized).
-            var host = AddressSpaceComposer.NormalizeDeviceHost(node.DeviceHost);
+            var host = DeviceConfigIntent.NormalizeHost(node.DeviceHost);
             if (ambiguousHosts.Contains(host)) continue;
             if (hostToEquipment.TryGetValue(host, out var existing))
             {
@@ -789,7 +789,7 @@ public sealed class DriverHostActor : ReceiveActor, IWithTimers
         foreach (var n in msg.Nodes)
         {
             var key = n.FolderPathSegments.Count >= 2
-                ? AddressSpaceComposer.NormalizeDeviceHost(n.FolderPathSegments[1])
+                ? DeviceConfigIntent.NormalizeHost(n.FolderPathSegments[1])
                 : null;
             if (key is not null && hostToEquipment.ContainsKey(key))
             {