Recovery: Build #1868 FAT baseline first; scroll patch quarantined

Services/Iec61850DataSetSignalInventoryService.cs

@@ -26,11 +26,11 @@ public static Iec61850DataSetSignalInventoryMergeResult EnsureMandatorySignals(
     {
         ArgumentNullException.ThrowIfNull(device);
 
-        // Signal Selection is also opened directly from an offline CID/SCD workspace.
-        // In that workflow LiveDiscoveryModel is intentionally null; the SCL design model
-        // is the authoritative inventory and must not be ignored. Prefer the live model
-        // only after a real association/discovery has produced one.
-        var authoritativeModel = device.LiveDiscoveryModel ?? device.SclWorkspace?.DesignModel;
+        // When an SCL workspace is open, its configured DataSet membership remains the
+        // engineering authority across cached/fast reconnects. A partial live discovery
+        // model must not erase FCDA/FCD rows that were proven by the opened CID/SCD. For an
+        // online-only IED with no SCL workspace, live discovery remains the authority.
+        var authoritativeModel = device.SclWorkspace?.DesignModel ?? device.LiveDiscoveryModel;
         if (authoritativeModel is null)
             return EmptyResult();
 

Services/Iec61850StaticDataSetAuthoritySelection.cs

@@ -6,76 +6,126 @@ namespace ArIED61850Tester.Services;
 /// <summary>
 /// Builds the exact Static DataSet selection used by the report-only workflow.
 ///
-/// A DataSetReference on a browsed/runtime alias is not sufficient authority: several
+/// Static report-only mode is RCB-backed by definition. A static DataSet that is not
+/// referenced by an authoritative configured BRCB/URCB is valid engineering inventory,
+/// but it is not a live acquisition source and therefore must not inflate the monitor with
+/// permanently unavailable rows. When an SCL workspace is open, its ReportControl bindings
+/// are the configuration authority; live discovery is verification only. For online-only
+/// operation with no SCL workspace, live discovery becomes the configuration authority.
+///
+/// A DataSetReference on a browsed/runtime alias is also not sufficient authority: several
 /// aliases can point at the same static FCDA/FCD member (for example cVal/instCVal or
-/// structured measurement descendants). Static mode must select one presentation row
-/// for each engine-authoritative DataSet membership, preserving the literal member
-/// identity that appears in SCL/ARIEC.
+/// structured measurement descendants). Static mode selects one presentation row for each
+/// engine-authoritative membership, preserving the literal member identity from SCL/ARIEC.
 /// </summary>
 public static class Iec61850StaticDataSetAuthoritySelection
 {
     public static IReadOnlySet<SignalDefinition> Build(Iec61850MonitorDevice device)
     {
         ArgumentNullException.ThrowIfNull(device);
 
-        var model = device.LiveDiscoveryModel ?? device.SclWorkspace?.DesignModel;
-        if (model is null)
+        // Opened SCL is the engineering authority. A partial or richer live model may verify
+        // the configuration later, but it must not introduce extra static memberships that
+        // were never configured in the opened CID/SCD. Online-only mode falls back to live.
+        var authorityModel = device.SclWorkspace?.DesignModel ?? device.LiveDiscoveryModel;
+        if (authorityModel is null)
             return new HashSet<SignalDefinition>(ReferenceEqualityComparer.Instance);
 
-        var mandatory = Iec61850DataSetSignalInventoryProjection.GetMandatorySignals(model);
+        var reportBackedDataSets = BuildReportBackedDataSetReferences(device);
+        if (reportBackedDataSets.Count == 0)
+            return new HashSet<SignalDefinition>(ReferenceEqualityComparer.Instance);
+
+        var mandatory = Iec61850DataSetSignalInventoryProjection.GetMandatorySignals(authorityModel);
         var selected = new HashSet<SignalDefinition>(ReferenceEqualityComparer.Instance);
         var signals = device.Signals.ToArray();
 
         foreach (var descriptor in mandatory)
         {
-            var membership = descriptor.DataSetMemberships
+            // A descriptor may carry more than one membership. Do not arbitrarily take the
+            // first DataSet: choose only literal memberships that are backed by authoritative
+            // report-control configuration.
+            var memberships = descriptor.DataSetMemberships
+                .Where(item => reportBackedDataSets.Contains(NormalizeLiteral(item.DataSetReference)))
                 .OrderBy(item => item.DataSetReference, StringComparer.OrdinalIgnoreCase)
                 .ThenBy(item => item.MemberIndex)
-                .FirstOrDefault();
-            if (membership is null)
-                continue;
-
-            var memberReference = FirstNonEmpty(
-                membership.CanonicalMemberReference,
-                membership.OriginalMemberReference,
-                descriptor.DesignReference,
-                descriptor.ObservedReference,
-                descriptor.PrimaryValueReference);
-            if (string.IsNullOrWhiteSpace(memberReference) ||
-                string.IsNullOrWhiteSpace(membership.DataSetReference))
-                continue;
-
-            var candidates = signals
-                .Where(signal => !signal.IsControlSignal && signal.CanPublishToRuntime)
-                .Where(signal => LiteralEquals(signal.DataSetReference, membership.DataSetReference))
-                .Where(signal => LiteralEquals(signal.DisplayReference, memberReference))
                 .ToArray();
-            if (candidates.Length == 0)
-                continue;
-
-            // Prefer the runtime row already bound to ARIEC's resolved primary value.
-            // For an unresolved structured member, the inventory-created exact static row
-            // wins over a generic browsed alias. Never choose by fuzzy/prefix matching.
-            var chosen = candidates
-                .OrderByDescending(signal =>
-                    !string.IsNullOrWhiteSpace(descriptor.PrimaryValueReference) &&
-                    LiteralEquals(signal.ObjectReference, descriptor.PrimaryValueReference))
-                .ThenByDescending(signal =>
-                    (signal.Source ?? string.Empty).Contains(
-                        "mandatory static DataSet member",
-                        StringComparison.OrdinalIgnoreCase))
-                .ThenByDescending(signal =>
-                    string.Equals(signal.Category, "DataSet", StringComparison.OrdinalIgnoreCase))
-                .ThenByDescending(signal =>
-                    string.Equals(signal.Confidence, "High", StringComparison.OrdinalIgnoreCase))
-                .First();
-
-            selected.Add(chosen);
+
+            foreach (var membership in memberships)
+            {
+                var memberReference = FirstNonEmpty(
+                    membership.CanonicalMemberReference,
+                    membership.OriginalMemberReference,
+                    descriptor.DesignReference,
+                    descriptor.ObservedReference,
+                    descriptor.PrimaryValueReference);
+                if (string.IsNullOrWhiteSpace(memberReference) ||
+                    string.IsNullOrWhiteSpace(membership.DataSetReference))
+                {
+                    continue;
+                }
+
+                var candidates = signals
+                    .Where(signal => !signal.IsControlSignal && signal.CanPublishToRuntime)
+                    .Where(signal => LiteralEquals(signal.DataSetReference, membership.DataSetReference))
+                    .Where(signal => LiteralEquals(signal.DisplayReference, memberReference))
+                    .ToArray();
+                if (candidates.Length == 0)
+                    continue;
+
+                // Prefer the runtime row already bound to ARIEC's resolved primary value.
+                // For an unresolved structured member, the inventory-created exact static row
+                // wins over a generic browsed alias. Never choose by fuzzy/prefix matching.
+                var chosen = candidates
+                    .OrderByDescending(signal =>
+                        !string.IsNullOrWhiteSpace(descriptor.PrimaryValueReference) &&
+                        LiteralEquals(signal.ObjectReference, descriptor.PrimaryValueReference))
+                    .ThenByDescending(signal =>
+                        (signal.Source ?? string.Empty).Contains(
+                            "mandatory static DataSet member",
+                            StringComparison.OrdinalIgnoreCase))
+                    .ThenByDescending(signal =>
+                        string.Equals(signal.Category, "DataSet", StringComparison.OrdinalIgnoreCase))
+                    .ThenByDescending(signal =>
+                        string.Equals(signal.Confidence, "High", StringComparison.OrdinalIgnoreCase))
+                    .First();
+
+                selected.Add(chosen);
+            }
         }
 
         return selected;
     }
 
+    /// <summary>
+    /// Returns the literal DataSet references that have authoritative ReportControl backing.
+    /// Opened SCL configuration wins absolutely over extra live ReportControls. Live discovery
+    /// is used as configuration authority only when no SCL design model is open.
+    /// </summary>
+    public static IReadOnlySet<string> BuildReportBackedDataSetReferences(Iec61850MonitorDevice device)
+    {
+        ArgumentNullException.ThrowIfNull(device);
+
+        var result = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        var configurationModel = device.SclWorkspace?.DesignModel ?? device.LiveDiscoveryModel;
+        AddReportBackedDataSets(configurationModel, result);
+        return result;
+    }
+
+    private static void AddReportBackedDataSets(
+        LiveIedModelDiscoveryDocument? model,
+        HashSet<string> target)
+    {
+        if (model is null)
+            return;
+
+        foreach (var report in model.ReportControls)
+        {
+            var dataSetReference = NormalizeLiteral(report.DataSetReference);
+            if (!string.IsNullOrWhiteSpace(dataSetReference))
+                target.Add(dataSetReference);
+        }
+    }
+
     private static bool LiteralEquals(string? left, string? right)
         => string.Equals(NormalizeLiteral(left), NormalizeLiteral(right), StringComparison.OrdinalIgnoreCase);
 

Services/Iec61850StaticRcbReferenceMatcher.cs

@@ -0,0 +1,74 @@
+namespace ArIED61850Tester.Services;
+
+/// <summary>
+/// Matches one configured SCL ReportControl declaration to the concrete RCB object exposed
+/// by the live MMS server.
+///
+/// IEC 61850 SCL may describe one indexed ReportControl family while the server exposes
+/// concrete instances such as Buffer01 / Buffer02. Exact identity always wins. The only
+/// accepted fallback is a decimal indexed instance of the same literal RCB family; arbitrary
+/// same-DataSet RCBs are never treated as substitutes.
+/// </summary>
+public static class Iec61850StaticRcbReferenceMatcher
+{
+    public static bool IsExact(string? configuredReference, string? liveReference)
+        => string.Equals(
+            Normalize(configuredReference),
+            Normalize(liveReference),
+            StringComparison.OrdinalIgnoreCase);
+
+    public static bool IsConfiguredOrIndexedInstance(string? configuredReference, string? liveReference)
+    {
+        var configured = Normalize(configuredReference);
+        var live = Normalize(liveReference);
+        if (string.IsNullOrWhiteSpace(configured) || string.IsNullOrWhiteSpace(live))
+            return false;
+        if (string.Equals(configured, live, StringComparison.OrdinalIgnoreCase))
+            return true;
+
+        SplitLeaf(configured, out var configuredParent, out var configuredLeaf);
+        SplitLeaf(live, out var liveParent, out var liveLeaf);
+        if (!string.Equals(configuredParent, liveParent, StringComparison.OrdinalIgnoreCase) ||
+            string.IsNullOrWhiteSpace(configuredLeaf) ||
+            string.IsNullOrWhiteSpace(liveLeaf))
+        {
+            return false;
+        }
+
+        // If the configured declaration already ends in a digit, treat it as a concrete
+        // object and require exact identity. This avoids accidental prefix matches such as
+        // Buffer0 -> Buffer01.
+        if (char.IsDigit(configuredLeaf[^1]) ||
+            !liveLeaf.StartsWith(configuredLeaf, StringComparison.OrdinalIgnoreCase))
+        {
+            return false;
+        }
+
+        var suffix = liveLeaf[configuredLeaf.Length..];
+        return suffix.Length > 0 && suffix.All(char.IsDigit);
+    }
+
+    public static int MatchRank(string? configuredReference, string? liveReference)
+    {
+        if (IsExact(configuredReference, liveReference))
+            return 0;
+        return IsConfiguredOrIndexedInstance(configuredReference, liveReference) ? 1 : int.MaxValue;
+    }
+
+    public static string Normalize(string? reference)
+        => (reference ?? string.Empty).Trim().Replace('$', '.');
+
+    private static void SplitLeaf(string reference, out string parent, out string leaf)
+    {
+        var separator = reference.LastIndexOf('.');
+        if (separator < 0)
+        {
+            parent = string.Empty;
+            leaf = reference;
+            return;
+        }
+
+        parent = reference[..separator];
+        leaf = reference[(separator + 1)..];
+    }
+}