From e0d2d3e8b1ad8cc8666b615dae8fc22d36d655eb Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Wed, 15 Jul 2026 21:32:41 +0700
Subject: [PATCH 01/39] Add SCL expected configuration factory

---
 .../SvExpectedStreamConfigurationFactory.cs   | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvExpectedStreamConfigurationFactory.cs

diff --git a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvExpectedStreamConfigurationFactory.cs b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvExpectedStreamConfigurationFactory.cs
new file mode 100644
index 0000000..8a799a3
--- /dev/null
+++ b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvExpectedStreamConfigurationFactory.cs
@@ -0,0 +1,54 @@
+using AR.Iec61850.SampledValues;
+using AR.Iec61850.Scl;
+
+namespace AR.Iec61850.SampledValues.Profiles;
+
+public static class SvExpectedStreamConfigurationFactory
+{
+    public static SvExpectedStreamConfiguration Create(SampledValuesPublisherProfile profile)
+    {
+        ArgumentNullException.ThrowIfNull(profile);
+
+        return new SvExpectedStreamConfiguration
+        {
+            EtherType = 0x88BA,
+            AppId = profile.AppId,
+            DestinationMac = profile.Destination.ToString(),
+            VlanId = profile.Vlan?.VlanId,
+            VlanPriority = profile.Vlan?.PriorityCodePoint,
+            SvId = profile.Stream.SvId,
+            DataSetReference = profile.Stream.DataSetReference,
+            ConfigurationRevision = profile.Stream.ConfigurationRevision,
+            AsduPerFrame = profile.AsduPerFrame,
+            PayloadBytesPerAsdu = profile.PayloadLayout.PayloadByteLength,
+            DeclaredSampleRate = profile.Stream.SampleRate == 0
+                ? null
+                : profile.Stream.SampleRate,
+            DeclaredSampleMode = MapSampleMode(profile.Stream.SampleMode),
+            DataSetSignature = profile.Entries.Select(ToSignature).ToArray()
+        };
+    }
+
+    private static ushort? MapSampleMode(string sampleMode)
+    {
+        if (string.IsNullOrWhiteSpace(sampleMode))
+            return null;
+
+        return sampleMode.Trim() switch
+        {
+            "SmpPerPeriod" => 0,
+            "SmpPerSec" => 1,
+            "SecPerSmp" => 2,
+            _ => null
+        };
+    }
+
+    private static SvDatasetElementSignature ToSignature(SclDataSetEntry entry)
+        => new()
+        {
+            BType = entry.BType,
+            Cdc = entry.Cdc,
+            IsQuality = entry.IsQuality,
+            IsTimestamp = entry.IsTimestamp
+        };
+}

From afb364755f01209e33b074f7425d66c0764cbe92 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Wed, 15 Jul 2026 21:33:28 +0700
Subject: [PATCH 02/39] Add configuration comparison summaries

---
 .../Profiles/SvConfigurationComparer.cs        | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvConfigurationComparer.cs b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvConfigurationComparer.cs
index 27872d1..f0bf364 100644
--- a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvConfigurationComparer.cs
+++ b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvConfigurationComparer.cs
@@ -46,9 +46,27 @@ public sealed record SvConfigurationComparisonResult
         = Array.Empty<SvConfigurationFinding>();
 
     public bool HasBlockingErrors => Findings.Any(item => item.Severity == SvConfigurationFindingSeverity.Error);
+    public int InfoCount => Findings.Count(item => item.Severity == SvConfigurationFindingSeverity.Info);
     public int ErrorCount => Findings.Count(item => item.Severity == SvConfigurationFindingSeverity.Error);
     public int WarningCount => Findings.Count(item => item.Severity == SvConfigurationFindingSeverity.Warning);
     public bool IsExactMatch => Findings.Count == 0;
+
+    public string Summary
+    {
+        get
+        {
+            if (IsExactMatch)
+                return "Exact";
+            if (ErrorCount > 0)
+                return CountText(ErrorCount, "error");
+            if (WarningCount > 0)
+                return CountText(WarningCount, "warning");
+            return CountText(InfoCount, "info");
+        }
+    }
+
+    private static string CountText(int count, string label)
+        => $"{count} {label}{(count == 1 ? string.Empty : "s")}";
 }
 
 public sealed class SvConfigurationComparer

From 8392588d301d31346dc76f537ca8992a263e2ccb Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Wed, 15 Jul 2026 21:34:15 +0700
Subject: [PATCH 03/39] Integrate SCL configuration comparison into SV
 observations

---
 .../Profiles/SvStreamObservationManager.cs    | 55 +++++++++++++++++--
 1 file changed, 50 insertions(+), 5 deletions(-)

diff --git a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
index 96b8b3b..39ebbc3 100644
--- a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
+++ b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
@@ -55,6 +55,9 @@ public sealed record SvStreamObservationSnapshot
     public SvObservationInputKind LastInputKind { get; init; }
     public bool IsBoundToScl { get; init; }
     public string ControlBlockReference { get; init; } = string.Empty;
+    public SvExpectedStreamConfiguration? ExpectedConfiguration { get; init; }
+    public SvConfigurationComparisonResult? ConfigurationComparison { get; init; }
+    public string ConfigurationMatchSummary => ConfigurationComparison?.Summary ?? "Not configured";
     public IReadOnlyList<string> Diagnostics { get; init; } = Array.Empty<string>();
 }
 
@@ -150,7 +153,8 @@ public bool TryObserve(
         SvObservationInputKind inputKind,
         SampledValuesPublisherProfile? profile,
         out SvStreamObservationSnapshot snapshot,
-        double? nominalFrequencyHz = null)
+        double? nominalFrequencyHz = null,
+        SvComparisonMode comparisonMode = SvComparisonMode.Compatible)
     {
         ArgumentNullException.ThrowIfNull(frame);
         snapshot = new SvStreamObservationSnapshot();
@@ -161,8 +165,9 @@ public bool TryObserve(
             return false;
 
         var key = SvObservedStreamKey.FromFrame(frame);
-        var diagnostics = ValidateFrameConsistency(asdus);
-        var signature = profile?.Entries.Select(ToSignature).ToArray()
+        var diagnostics = ValidateFrameConsistency(asdus).ToList();
+        var boundProfile = ValidateProfileBinding(frame, profile, diagnostics);
+        var signature = boundProfile?.Entries.Select(ToSignature).ToArray()
             ?? Array.Empty<SvDatasetElementSignature>();
         var payloadLengths = asdus.Select(item => item.SamplePayload.Length).Distinct().ToArray();
         var payloadLength = payloadLengths.Length == 1 ? payloadLengths[0] : first.SamplePayload.Length;
@@ -189,8 +194,25 @@ public bool TryObserve(
         var state = _streams.GetOrAdd(
             key,
             _ => new StreamState(_maximumObservations, _maximumAge));
-        state.Add(observation, inputKind, profile, diagnostics);
-        snapshot = state.Snapshot(key);
+        state.Add(observation, inputKind, boundProfile, diagnostics);
+
+        var observedSnapshot = state.Snapshot(key);
+        if (boundProfile is null)
+        {
+            snapshot = observedSnapshot;
+            return true;
+        }
+
+        var expected = SvExpectedStreamConfigurationFactory.Create(boundProfile);
+        var comparison = new SvConfigurationComparer().Compare(
+            expected,
+            observedSnapshot.Facts,
+            comparisonMode);
+        snapshot = observedSnapshot with
+        {
+            ExpectedConfiguration = expected,
+            ConfigurationComparison = comparison
+        };
         return true;
     }
 
@@ -216,6 +238,29 @@ public IReadOnlyList<SvStreamObservationSnapshot> SnapshotAll()
 
     public void Clear() => _streams.Clear();
 
+    private static SampledValuesPublisherProfile? ValidateProfileBinding(
+        SampledValuesFrame frame,
+        SampledValuesPublisherProfile? profile,
+        ICollection<string> diagnostics)
+    {
+        if (profile is null)
+            return null;
+
+        var appIdMatches = profile.AppId == frame.AppId;
+        var destinationMatches = string.Equals(
+            profile.Destination.ToString(),
+            frame.Destination.ToString(),
+            StringComparison.OrdinalIgnoreCase);
+        var vlanMatches = profile.Vlan?.VlanId == frame.Vlan?.VlanId;
+        if (appIdMatches && destinationMatches && vlanMatches)
+            return profile;
+
+        diagnostics.Add(
+            $"Rejected SCL candidate {profile.Stream.ControlBlockReference}: " +
+            "APPID, destination MAC, and VLAN must identify the same configured stream before comparison.");
+        return null;
+    }
+
     private static IReadOnlyList<string> ValidateFrameConsistency(IReadOnlyList<SampledValueAsdu> asdus)
     {
         var diagnostics = new List<string>();

From 09c03c9f00fd2e12dc4a5056b34a0a3bb5e95828 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Wed, 15 Jul 2026 21:35:20 +0700
Subject: [PATCH 04/39] Persist SV configuration comparison in observation
 snapshots

---
 .../Profiles/SvStreamObservationManager.cs    | 38 +++++++++----------
 1 file changed, 18 insertions(+), 20 deletions(-)

diff --git a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
index 39ebbc3..826a9b3 100644
--- a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
+++ b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
@@ -68,6 +68,8 @@ private sealed class StreamState
         private readonly object _gate = new();
         private readonly HashSet<SvObservationInputKind> _inputKinds = [];
         private readonly Queue<string> _diagnostics = new();
+        private SvExpectedStreamConfiguration? _expectedConfiguration;
+        private SvComparisonMode _comparisonMode = SvComparisonMode.Compatible;
 
         public StreamState(int maximumObservations, TimeSpan maximumAge)
         {
@@ -83,6 +85,7 @@ public void Add(
             SvFrameObservation observation,
             SvObservationInputKind inputKind,
             SampledValuesPublisherProfile? profile,
+            SvComparisonMode comparisonMode,
             IEnumerable<string> diagnostics)
         {
             Accumulator.Add(observation);
@@ -94,6 +97,8 @@ public void Add(
                 {
                     IsBoundToScl = true;
                     ControlBlockReference = profile.Stream.ControlBlockReference;
+                    _expectedConfiguration = SvExpectedStreamConfigurationFactory.Create(profile);
+                    _comparisonMode = comparisonMode;
                 }
 
                 foreach (var diagnostic in diagnostics.Where(item => !string.IsNullOrWhiteSpace(item)))
@@ -113,6 +118,13 @@ public SvStreamObservationSnapshot Snapshot(SvObservedStreamKey key)
             var facts = Accumulator.BuildFacts();
             lock (_gate)
             {
+                var comparison = _expectedConfiguration is null
+                    ? null
+                    : new SvConfigurationComparer().Compare(
+                        _expectedConfiguration,
+                        facts,
+                        _comparisonMode);
+
                 return new SvStreamObservationSnapshot
                 {
                     Key = key,
@@ -121,6 +133,8 @@ public SvStreamObservationSnapshot Snapshot(SvObservedStreamKey key)
                     LastInputKind = LastInputKind,
                     IsBoundToScl = IsBoundToScl,
                     ControlBlockReference = ControlBlockReference,
+                    ExpectedConfiguration = _expectedConfiguration,
+                    ConfigurationComparison = comparison,
                     Diagnostics = facts.Diagnostics.Concat(_diagnostics).Distinct(StringComparer.Ordinal).ToArray()
                 };
             }
@@ -194,25 +208,8 @@ public bool TryObserve(
         var state = _streams.GetOrAdd(
             key,
             _ => new StreamState(_maximumObservations, _maximumAge));
-        state.Add(observation, inputKind, boundProfile, diagnostics);
-
-        var observedSnapshot = state.Snapshot(key);
-        if (boundProfile is null)
-        {
-            snapshot = observedSnapshot;
-            return true;
-        }
-
-        var expected = SvExpectedStreamConfigurationFactory.Create(boundProfile);
-        var comparison = new SvConfigurationComparer().Compare(
-            expected,
-            observedSnapshot.Facts,
-            comparisonMode);
-        snapshot = observedSnapshot with
-        {
-            ExpectedConfiguration = expected,
-            ConfigurationComparison = comparison
-        };
+        state.Add(observation, inputKind, boundProfile, comparisonMode, diagnostics);
+        snapshot = state.Snapshot(key);
         return true;
     }
 
@@ -270,7 +267,8 @@ private static IReadOnlyList<string> ValidateFrameConsistency(IReadOnlyList<Samp
             diagnostics.Add("ASDUs inside one Ethernet frame expose different svID values.");
         if (asdus.Any(item => !string.Equals(item.DataSetReference, first.DataSetReference, StringComparison.Ordinal)))
             diagnostics.Add("ASDUs inside one Ethernet frame expose different dataset references.");
-        if (asdus.Any(item => item.ConfigurationRevision != first.ConfigurationRevision))
+        if (asdus.Any(item => item.ConfigurationRevision != first.ConfigurationRevision)
+            )
             diagnostics.Add("ASDUs inside one Ethernet frame expose different confRev values.");
         if (asdus.Select(item => item.SamplePayload.Length).Distinct().Count() > 1)
             diagnostics.Add("ASDUs inside one Ethernet frame expose different payload lengths.");

From 3537431ac6f07267cb46d62af829d5a9670598e6 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Wed, 15 Jul 2026 21:35:53 +0700
Subject: [PATCH 05/39] Add deterministic P3C configuration comparison tests

---
 ...SvExpectedConfigurationIntegrationTests.cs | 180 ++++++++++++++++++
 1 file changed, 180 insertions(+)
 create mode 100644 tests/ARSVIN.Tests/SampledValues/Profiles/SvExpectedConfigurationIntegrationTests.cs

diff --git a/tests/ARSVIN.Tests/SampledValues/Profiles/SvExpectedConfigurationIntegrationTests.cs b/tests/ARSVIN.Tests/SampledValues/Profiles/SvExpectedConfigurationIntegrationTests.cs
new file mode 100644
index 0000000..b577e52
--- /dev/null
+++ b/tests/ARSVIN.Tests/SampledValues/Profiles/SvExpectedConfigurationIntegrationTests.cs
@@ -0,0 +1,180 @@
+using AR.Iec61850.Ethernet;
+using AR.Iec61850.SampledValues;
+using AR.Iec61850.SampledValues.Profiles;
+using AR.Iec61850.Scl;
+using Xunit;
+
+namespace ARSVIN.Tests.SampledValues.Profiles;
+
+public sealed class SvExpectedConfigurationIntegrationTests
+{
+    [Fact]
+    public void FactoryConvertsSclProfileIntoExpectedConfiguration()
+    {
+        var expected = SvExpectedStreamConfigurationFactory.Create(CreateProfile());
+
+        Assert.Equal((ushort)0x88BA, expected.EtherType);
+        Assert.Equal((ushort)0x4001, expected.AppId);
+        Assert.Equal("01:0C:CD:04:00:01", expected.DestinationMac);
+        Assert.Equal((ushort)100, expected.VlanId);
+        Assert.Equal((byte)4, expected.VlanPriority);
+        Assert.Equal("MU01SV01", expected.SvId);
+        Assert.Equal("MU01MUnn/LLN0$PhsMeas", expected.DataSetReference);
+        Assert.Equal((uint)7, expected.ConfigurationRevision);
+        Assert.Equal(1, expected.AsduPerFrame);
+        Assert.Equal(8, expected.PayloadBytesPerAsdu);
+        Assert.Equal((ushort)80, expected.DeclaredSampleRate);
+        Assert.Equal((ushort)0, expected.DeclaredSampleMode);
+        Assert.Equal(2, expected.DataSetSignature.Count);
+    }
+
+    [Fact]
+    public void CompatibleComparisonIsDefaultAndReportsWarnings()
+    {
+        var manager = new SvStreamObservationManager();
+
+        Assert.True(manager.TryObserve(
+            DateTimeOffset.UnixEpoch,
+            CreateFrame(configurationRevision: 8),
+            SvObservationInputKind.LiveCapture,
+            CreateProfile(),
+            out var snapshot));
+
+        var comparison = Assert.IsType<SvConfigurationComparisonResult>(snapshot.ConfigurationComparison);
+        Assert.Equal(SvComparisonMode.Compatible, comparison.Mode);
+        Assert.False(comparison.HasBlockingErrors);
+        Assert.Equal(1, comparison.WarningCount);
+        Assert.Equal("1 warning", snapshot.ConfigurationMatchSummary);
+        Assert.Equal("SV_CONFREV_MISMATCH", Assert.Single(comparison.Findings).Code);
+    }
+
+    [Fact]
+    public void StrictComparisonReportsBlockingErrors()
+    {
+        var manager = new SvStreamObservationManager();
+
+        Assert.True(manager.TryObserve(
+            DateTimeOffset.UnixEpoch,
+            CreateFrame(configurationRevision: 8),
+            SvObservationInputKind.PcapReplay,
+            CreateProfile(),
+            out var snapshot,
+            comparisonMode: SvComparisonMode.Strict));
+
+        var comparison = Assert.IsType<SvConfigurationComparisonResult>(snapshot.ConfigurationComparison);
+        Assert.Equal(SvComparisonMode.Strict, comparison.Mode);
+        Assert.True(comparison.HasBlockingErrors);
+        Assert.Equal(1, comparison.ErrorCount);
+        Assert.Equal("1 error", snapshot.ConfigurationMatchSummary);
+    }
+
+    [Fact]
+    public void ExactComparisonPersistsInManagerSnapshots()
+    {
+        var manager = new SvStreamObservationManager();
+
+        Assert.True(manager.TryObserve(
+            DateTimeOffset.UnixEpoch,
+            CreateFrame(configurationRevision: 7),
+            SvObservationInputKind.LiveCapture,
+            CreateProfile(),
+            out var observed));
+
+        Assert.Equal("Exact", observed.ConfigurationMatchSummary);
+        var persisted = Assert.Single(manager.SnapshotAll());
+        Assert.Equal("Exact", persisted.ConfigurationMatchSummary);
+        Assert.True(persisted.ConfigurationComparison?.IsExactMatch);
+    }
+
+    [Fact]
+    public void AddressMismatchRejectsUnsafeSclCandidate()
+    {
+        var manager = new SvStreamObservationManager();
+        var frame = CreateFrame(configurationRevision: 7) with
+        {
+            Destination = MacAddress.Parse("01:0C:CD:04:00:02")
+        };
+
+        Assert.True(manager.TryObserve(
+            DateTimeOffset.UnixEpoch,
+            frame,
+            SvObservationInputKind.LiveCapture,
+            CreateProfile(),
+            out var snapshot));
+
+        Assert.False(snapshot.IsBoundToScl);
+        Assert.Null(snapshot.ExpectedConfiguration);
+        Assert.Null(snapshot.ConfigurationComparison);
+        Assert.Equal("Not configured", snapshot.ConfigurationMatchSummary);
+        Assert.Contains(snapshot.Diagnostics, item => item.Contains("Rejected SCL candidate", StringComparison.Ordinal));
+    }
+
+    private static SampledValuesFrame CreateFrame(uint configurationRevision)
+        => new()
+        {
+            Source = MacAddress.Parse("02:00:00:00:00:01"),
+            Destination = MacAddress.Parse("01:0C:CD:04:00:01"),
+            Vlan = new VlanTag(4, 100),
+            AppId = 0x4001,
+            Pdu = new SampledValuesPdu
+            {
+                Asdus =
+                [
+                    new SampledValueAsdu
+                    {
+                        SvId = "MU01SV01",
+                        DataSetReference = "MU01MUnn/LLN0$PhsMeas",
+                        SampleCount = 1,
+                        ConfigurationRevision = configurationRevision,
+                        SampleRate = 80,
+                        SampleMode = 0,
+                        SamplePayload = new byte[8]
+                    }
+                ]
+            }
+        };
+
+    private static SampledValuesPublisherProfile CreateProfile()
+        => SampledValuesPublisherProfile.Create(new SclSampledValuesStream
+        {
+            Kind = "SV",
+            IedName = "MU01",
+            LdInst = "MUnn",
+            ControlName = "MSVCB01",
+            ControlBlockReference = "MU01MUnn/LLN0$SV$MSVCB01",
+            SvId = "MU01SV01",
+            DataSetName = "PhsMeas",
+            DataSetReference = "MU01MUnn/LLN0$PhsMeas",
+            ConfigurationRevision = 7,
+            SampleRate = 80,
+            SampleMode = "SmpPerPeriod",
+            NoAsdu = 1,
+            Address = new SclStreamAddress
+            {
+                AppIdText = "0x4001",
+                AppId = 0x4001,
+                DestinationMacText = "01:0C:CD:04:00:01",
+                DestinationMac = MacAddress.Parse("01:0C:CD:04:00:01"),
+                VlanId = 100,
+                VlanPriority = 4
+            },
+            Entries =
+            [
+                new SclDataSetEntry
+                {
+                    Index = 1,
+                    SignalReference = "TCTR1.Amp.instMag.i",
+                    BType = "INT32",
+                    Cdc = "SAV"
+                },
+                new SclDataSetEntry
+                {
+                    Index = 2,
+                    SignalReference = "TCTR1.Amp.q",
+                    BType = "Quality",
+                    Cdc = "SAV",
+                    IsQuality = true
+                }
+            ]
+        });
+}

From 9a90c91e2f946a0650ab0dcd2d6e443e3da1d24b Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Wed, 15 Jul 2026 21:37:38 +0700
Subject: [PATCH 06/39] Fix P3C integration test frame construction

---
 .../SvExpectedConfigurationIntegrationTests.cs   | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/tests/ARSVIN.Tests/SampledValues/Profiles/SvExpectedConfigurationIntegrationTests.cs b/tests/ARSVIN.Tests/SampledValues/Profiles/SvExpectedConfigurationIntegrationTests.cs
index b577e52..6ec00fd 100644
--- a/tests/ARSVIN.Tests/SampledValues/Profiles/SvExpectedConfigurationIntegrationTests.cs
+++ b/tests/ARSVIN.Tests/SampledValues/Profiles/SvExpectedConfigurationIntegrationTests.cs
@@ -83,17 +83,17 @@ public void ExactComparisonPersistsInManagerSnapshots()
         Assert.Equal("Exact", observed.ConfigurationMatchSummary);
         var persisted = Assert.Single(manager.SnapshotAll());
         Assert.Equal("Exact", persisted.ConfigurationMatchSummary);
-        Assert.True(persisted.ConfigurationComparison?.IsExactMatch);
+        var comparison = Assert.IsType<SvConfigurationComparisonResult>(persisted.ConfigurationComparison);
+        Assert.True(comparison.IsExactMatch);
     }
 
     [Fact]
     public void AddressMismatchRejectsUnsafeSclCandidate()
     {
         var manager = new SvStreamObservationManager();
-        var frame = CreateFrame(configurationRevision: 7) with
-        {
-            Destination = MacAddress.Parse("01:0C:CD:04:00:02")
-        };
+        var frame = CreateFrame(
+            configurationRevision: 7,
+            destinationMac: "01:0C:CD:04:00:02");
 
         Assert.True(manager.TryObserve(
             DateTimeOffset.UnixEpoch,
@@ -109,11 +109,13 @@ public void AddressMismatchRejectsUnsafeSclCandidate()
         Assert.Contains(snapshot.Diagnostics, item => item.Contains("Rejected SCL candidate", StringComparison.Ordinal));
     }
 
-    private static SampledValuesFrame CreateFrame(uint configurationRevision)
+    private static SampledValuesFrame CreateFrame(
+        uint configurationRevision,
+        string destinationMac = "01:0C:CD:04:00:01")
         => new()
         {
             Source = MacAddress.Parse("02:00:00:00:00:01"),
-            Destination = MacAddress.Parse("01:0C:CD:04:00:01"),
+            Destination = MacAddress.Parse(destinationMac),
             Vlan = new VlanTag(4, 100),
             AppId = 0x4001,
             Pdu = new SampledValuesPdu

From f85c9a688a987b45e7ae61afa8bfc1e47af0788a Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Wed, 15 Jul 2026 21:38:13 +0700
Subject: [PATCH 07/39] Document completed SCL configuration integration

---
 docs/sv-profile-infrastructure.md | 32 +++++++++++++++++++++----------
 1 file changed, 22 insertions(+), 10 deletions(-)

diff --git a/docs/sv-profile-infrastructure.md b/docs/sv-profile-infrastructure.md
index d0d8ff5..2ec52c8 100644
--- a/docs/sv-profile-infrastructure.md
+++ b/docs/sv-profile-infrastructure.md
@@ -15,7 +15,7 @@ Imported PCAP ────┘          ↓
                          └── SvConfigurationComparer
 ```
 
-The profile infrastructure is part of the shared `ARSVIN.Engine` assembly and has no dependency on WPF or Npcap. Subscriber live capture and PCAP replay now use the same manager and stable stream identity, so both paths produce the same facts and diagnostics contract.
+The profile infrastructure is part of the shared `ARSVIN.Engine` assembly and has no dependency on WPF or Npcap. Subscriber live capture and PCAP replay use the same manager and stable stream identity, so both paths produce the same facts and diagnostics contract.
 
 ## Observed facts
 
@@ -75,15 +75,25 @@ A high score is an engineering classification result, not a conformance certific
 
 ## Configuration-versus-wire comparison
 
-`SvConfigurationComparer` compares configured expectations with observed facts for addressing, identifiers, dataset, revision, packing, payload, and declared sampling fields.
+`SvExpectedStreamConfigurationFactory` converts the SCL-bound `SampledValuesPublisherProfile` into a transport-neutral `SvExpectedStreamConfiguration`. The expected configuration includes addressing, identifiers, revision, packing, payload length, declared sampling fields, and ordered dataset signature.
+
+`SvStreamObservationManager` compares that expected configuration with the rolling `SvObservedStreamFacts` for every bound live or PCAP stream. The resulting immutable snapshot carries:
+
+- the expected configuration,
+- field-level findings,
+- comparison mode,
+- exact/warning/error counts,
+- a compact summary such as `Exact`, `2 warnings`, or `1 error`.
 
 Two modes are available:
 
-- **Strict** — mismatches become errors suitable for validation and live-transmission preflight.
-- **Compatible** — mismatches become warnings suitable for troubleshooting and unfamiliar devices.
+- **Compatible** — the Subscriber default; mismatches become warnings suitable for troubleshooting and unfamiliar devices.
+- **Strict** — explicit opt-in for validation, preflight, and formal test cases; mismatches become errors.
 
 Neither mode stops receive-side capture or decoding. Unknown and conflicting streams remain visible.
 
+Before accepting an SCL candidate, the observation manager requires APPID, destination MAC, and VLAN to identify the same configured stream. A candidate that fails this address gate is rejected instead of contaminating observed facts with the wrong dataset layout.
+
 ## Current integration boundary
 
 `SvStreamObservationManager` now:
@@ -92,13 +102,15 @@ Neither mode stops receive-side capture or decoding. Unknown and conflicting str
 - groups frames by source, destination, VLAN, APPID, `svID`, and dataset reference;
 - deliberately keeps `confRev` outside the key so revision changes remain observable;
 - retains input provenance (`LiveCapture` or `PcapReplay`);
+- validates the SCL candidate against the observed address tuple;
+- converts a bound SCL stream into `SvExpectedStreamConfiguration`;
+- runs Compatible comparison by default, with Strict available per observation call;
 - adds SCL-derived dataset signatures when a stream is bound; and
-- exposes immutable rolling facts to the Subscriber runtime snapshot.
+- exposes immutable rolling facts plus persistent configuration comparison results to Subscriber runtime snapshots.
 
 ## Next integration
 
-1. Convert selected SCL stream bindings into `SvExpectedStreamConfiguration`.
-2. Run strict or compatible configuration comparison per observed stream.
-3. Present one compact profile/confidence and SCL-match state per selected stream.
-4. Show evidence and mismatch details on demand rather than adding permanent visual noise.
-5. Add profile-specific definitions only after source review and deterministic evidence.
+1. Present one compact profile/confidence and SCL-match state per selected stream.
+2. Show evidence and mismatch details on demand rather than adding permanent visual noise.
+3. Add profile-specific definitions only after source review and deterministic evidence.
+4. Serialize profile, configuration, provenance, and source evidence into Subscriber reports.

From 755990b5faa025a95db2081ad65b77c1f14f6333 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Wed, 15 Jul 2026 21:40:44 +0700
Subject: [PATCH 08/39] Clean SV observation consistency check

---
 .../SampledValues/Profiles/SvStreamObservationManager.cs       | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
index 826a9b3..e61e82e 100644
--- a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
+++ b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
@@ -267,8 +267,7 @@ private static IReadOnlyList<string> ValidateFrameConsistency(IReadOnlyList<Samp
             diagnostics.Add("ASDUs inside one Ethernet frame expose different svID values.");
         if (asdus.Any(item => !string.Equals(item.DataSetReference, first.DataSetReference, StringComparison.Ordinal)))
             diagnostics.Add("ASDUs inside one Ethernet frame expose different dataset references.");
-        if (asdus.Any(item => item.ConfigurationRevision != first.ConfigurationRevision)
-            )
+        if (asdus.Any(item => item.ConfigurationRevision != first.ConfigurationRevision))
             diagnostics.Add("ASDUs inside one Ethernet frame expose different confRev values.");
         if (asdus.Select(item => item.SamplePayload.Length).Distinct().Count() > 1)
             diagnostics.Add("ASDUs inside one Ethernet frame expose different payload lengths.");

From 433d1eb277fa10e74d1f29bcab36b612c2d9d384 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:00:56 +0700
Subject: [PATCH 09/39] Add profile detection to SV observation snapshots

---
 .../SampledValues/Profiles/SvStreamObservationManager.cs     | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
index e61e82e..2bc358e 100644
--- a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
+++ b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
@@ -57,6 +57,7 @@ public sealed record SvStreamObservationSnapshot
     public string ControlBlockReference { get; init; } = string.Empty;
     public SvExpectedStreamConfiguration? ExpectedConfiguration { get; init; }
     public SvConfigurationComparisonResult? ConfigurationComparison { get; init; }
+    public SvProfileDetectionResult? ProfileDetection { get; init; }
     public string ConfigurationMatchSummary => ConfigurationComparison?.Summary ?? "Not configured";
     public IReadOnlyList<string> Diagnostics { get; init; } = Array.Empty<string>();
 }
@@ -124,6 +125,9 @@ public SvStreamObservationSnapshot Snapshot(SvObservedStreamKey key)
                         _expectedConfiguration,
                         facts,
                         _comparisonMode);
+                var profileDetection = new SvProfileDetector().DetectBest(
+                    facts,
+                    SvProfileCatalog.BuiltIn);
 
                 return new SvStreamObservationSnapshot
                 {
@@ -135,6 +139,7 @@ public SvStreamObservationSnapshot Snapshot(SvObservedStreamKey key)
                     ControlBlockReference = ControlBlockReference,
                     ExpectedConfiguration = _expectedConfiguration,
                     ConfigurationComparison = comparison,
+                    ProfileDetection = profileDetection,
                     Diagnostics = facts.Diagnostics.Concat(_diagnostics).Distinct(StringComparer.Ordinal).ToArray()
                 };
             }

From 83e954ab85ba5104ef671fb9ddc64c1b1d5f7086 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:01:04 +0700
Subject: [PATCH 10/39] Add single-reset collection updates for Subscriber
 visuals

---
 .../ViewModels/BulkObservableCollection.cs    | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 src/ARSVIN.Subscriber/ViewModels/BulkObservableCollection.cs

diff --git a/src/ARSVIN.Subscriber/ViewModels/BulkObservableCollection.cs b/src/ARSVIN.Subscriber/ViewModels/BulkObservableCollection.cs
new file mode 100644
index 0000000..d550e31
--- /dev/null
+++ b/src/ARSVIN.Subscriber/ViewModels/BulkObservableCollection.cs
@@ -0,0 +1,25 @@
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+
+namespace ARSVIN.Subscriber.ViewModels;
+
+public sealed class BulkObservableCollection<T> : ObservableCollection<T>
+{
+    public void ReplaceAll(IEnumerable<T> items)
+    {
+        ArgumentNullException.ThrowIfNull(items);
+
+        var replacement = items.ToArray();
+        if (Items.SequenceEqual(replacement))
+            return;
+
+        Items.Clear();
+        foreach (var item in replacement)
+            Items.Add(item);
+
+        OnPropertyChanged(new PropertyChangedEventArgs(nameof(Count)));
+        OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
+        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+    }
+}

From 959fd553f1f654c034eb66a6c5089fb12e8cb6a2 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:01:17 +0700
Subject: [PATCH 11/39] Expose compact Subscriber analysis state

---
 src/ARSVIN.Subscriber/Models/SvStreamSnapshot.cs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/ARSVIN.Subscriber/Models/SvStreamSnapshot.cs b/src/ARSVIN.Subscriber/Models/SvStreamSnapshot.cs
index 76a95a7..475ac24 100644
--- a/src/ARSVIN.Subscriber/Models/SvStreamSnapshot.cs
+++ b/src/ARSVIN.Subscriber/Models/SvStreamSnapshot.cs
@@ -43,11 +43,15 @@ public sealed class SvStreamSnapshot
     public IReadOnlyList<SvObservationInputKind> ObservationInputKinds { get; init; }
         = Array.Empty<SvObservationInputKind>();
     public int ObservationWindowFrames { get; init; }
+    public int ObservationWindowSamples { get; init; }
+    public double ObservationWindowDurationSeconds { get; init; }
     public double? ObservedFramesPerSecond { get; init; }
     public double? ObservedSamplesPerSecond { get; init; }
     public int? ObservedCounterWrap { get; init; }
+    public bool IsWaveformWindowReady { get; init; }
+    public SvProfileDetectionResult? ProfileDetection { get; init; }
+    public SvConfigurationComparisonResult? ConfigurationComparison { get; init; }
     public IReadOnlyList<string> ObservationDiagnostics { get; init; } = Array.Empty<string>();
     public IReadOnlyDictionary<string, SvFactSource> FactProvenance { get; init; }
         = new Dictionary<string, SvFactSource>(StringComparer.Ordinal);
 }
-

From bc6a16892ecfce9000414e9c4ea3c49b4a18a5a0 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:03:15 +0700
Subject: [PATCH 12/39] Add compact profile and evidence state to Subscriber
 streams

---
 .../ViewModels/SvStreamViewModel.cs           | 171 ++++++++++++++++--
 1 file changed, 152 insertions(+), 19 deletions(-)

diff --git a/src/ARSVIN.Subscriber/ViewModels/SvStreamViewModel.cs b/src/ARSVIN.Subscriber/ViewModels/SvStreamViewModel.cs
index 09f9f9e..31b8fd6 100644
--- a/src/ARSVIN.Subscriber/ViewModels/SvStreamViewModel.cs
+++ b/src/ARSVIN.Subscriber/ViewModels/SvStreamViewModel.cs
@@ -1,4 +1,4 @@
-using System.Collections.ObjectModel;
+using AR.Iec61850.SampledValues.Profiles;
 using ARSVIN.Subscriber.Models;
 
 namespace ARSVIN.Subscriber.ViewModels;
@@ -29,10 +29,17 @@ public sealed class SvStreamViewModel : ObservableObject
     private string _sourceDestination = string.Empty;
     private string _cursorSummary = string.Empty;
     private string _qualitySummary = string.Empty;
+    private string _profile = "Unknown";
+    private string _confidence = "Unknown · insufficient evidence";
+    private string _sclMatch = "Not configured";
+    private string _window = "0.0 s · 0 samples";
+    private string _comparisonMode = "Compatible";
+    private string _waveformState = "Waiting for complete two-cycle window";
 
-    public ObservableCollection<DecodedValueRow> Values { get; } = new();
-    public ObservableCollection<WaveformPoint> WaveformPoints { get; } = new();
-    public ObservableCollection<PhasorVector> Phasors { get; } = new();
+    public BulkObservableCollection<DecodedValueRow> Values { get; } = new();
+    public BulkObservableCollection<WaveformPoint> WaveformPoints { get; } = new();
+    public BulkObservableCollection<PhasorVector> Phasors { get; } = new();
+    public BulkObservableCollection<string> EvidenceDetails { get; } = new();
 
     public string Key { get => _key; set => SetProperty(ref _key, value); }
     public string Health { get => _health; set => SetProperty(ref _health, value); }
@@ -58,12 +65,16 @@ public sealed class SvStreamViewModel : ObservableObject
     public string SourceDestination { get => _sourceDestination; set => SetProperty(ref _sourceDestination, value); }
     public string CursorSummary { get => _cursorSummary; set => SetProperty(ref _cursorSummary, value); }
     public string QualitySummary { get => _qualitySummary; set => SetProperty(ref _qualitySummary, value); }
+    public string Profile { get => _profile; set => SetProperty(ref _profile, value); }
+    public string Confidence { get => _confidence; set => SetProperty(ref _confidence, value); }
+    public string SclMatch { get => _sclMatch; set => SetProperty(ref _sclMatch, value); }
+    public string Window { get => _window; set => SetProperty(ref _window, value); }
+    public string ComparisonMode { get => _comparisonMode; set => SetProperty(ref _comparisonMode, value); }
+    public string WaveformState { get => _waveformState; set => SetProperty(ref _waveformState, value); }
 
-    public void Apply(SvStreamSnapshot snapshot)
+    public void Apply(SvStreamSnapshot snapshot, SvStreamObservationSnapshot? observation)
     {
         Key = snapshot.Key;
-        Health = snapshot.Health;
-        HealthDetail = snapshot.HealthDetail;
         AppId = $"0x{snapshot.AppId:X4}";
         SvId = string.IsNullOrWhiteSpace(snapshot.SvId) ? "-" : snapshot.SvId;
         Source = snapshot.Source;
@@ -81,25 +92,147 @@ public void Apply(SvStreamSnapshot snapshot)
         DataSet = string.IsNullOrWhiteSpace(snapshot.DataSet) ? "-" : snapshot.DataSet;
         CursorSummary = snapshot.CursorSummary;
         QualitySummary = snapshot.QualitySummary;
-        var issueTotal = snapshot.SequenceGapCount + snapshot.DuplicateCount + snapshot.OutOfOrderCount + snapshot.PayloadIssueCount + snapshot.SclMismatchCount;
+
+        var comparison = observation?.ConfigurationComparison;
+        var configurationIssues = comparison?.Findings.Count ?? 0;
+        var issueTotal = snapshot.SequenceGapCount + snapshot.DuplicateCount + snapshot.OutOfOrderCount + snapshot.PayloadIssueCount + configurationIssues;
         Issues = issueTotal == 0
             ? "0"
-            : $"{issueTotal} (gap {snapshot.SequenceGapCount}, dup {snapshot.DuplicateCount}, order {snapshot.OutOfOrderCount}, payload {snapshot.PayloadIssueCount}, SCL {snapshot.SclMismatchCount})";
-        Bound = snapshot.IsBoundToScl
-            ? $"SCL: {snapshot.ControlBlockReference}"
+            : $"{issueTotal} (gap {snapshot.SequenceGapCount}, dup {snapshot.DuplicateCount}, order {snapshot.OutOfOrderCount}, payload {snapshot.PayloadIssueCount}, SCL {configurationIssues})";
+
+        var hasBlockingConfigurationError = comparison?.HasBlockingErrors == true;
+        var hasConfigurationWarning = comparison?.WarningCount > 0;
+        var hasRuntimeError = snapshot.PayloadIssueCount > 0 || snapshot.OutOfOrderCount > 0;
+        var hasRuntimeWarning = snapshot.SequenceGapCount > 0 || snapshot.DuplicateCount > 0;
+        var isConfigured = observation?.IsBoundToScl == true;
+        Health = hasRuntimeError || hasBlockingConfigurationError
+            ? "BAD"
+            : hasRuntimeWarning || hasConfigurationWarning || !isConfigured
+                ? "WARN"
+                : "GOOD";
+        HealthDetail = ResolveHealthDetail(snapshot, observation, Health);
+
+        Bound = isConfigured
+            ? $"SCL: {observation!.ControlBlockReference}"
             : string.IsNullOrWhiteSpace(snapshot.LayoutBinding) ? "Unbound" : snapshot.LayoutBinding;
         LastSeen = snapshot.LastSeen;
-        Summary = string.Join("  •  ", snapshot.Diagnostics.Take(3));
+        Summary = string.Join("  •  ", observation?.Diagnostics.Take(3) ?? snapshot.Diagnostics.Take(3));
+
+        var detection = observation?.ProfileDetection;
+        Profile = detection?.Profile.Family ?? "Unknown profile";
+        Confidence = detection is null
+            ? "Unknown · insufficient evidence"
+            : $"{detection.Confidence} · {ConfidenceReason(detection)}";
+        SclMatch = observation?.ConfigurationMatchSummary ?? "Not configured";
+        ComparisonMode = comparison?.Mode.ToString() ?? "Compatible";
+
+        var duration = ResolveObservationDuration(observation?.Facts);
+        var samples = ResolveObservationSamples(observation?.Facts);
+        Window = $"{duration:0.0} s · {samples:N0} samples";
+
+        Values.ReplaceAll(snapshot.Values.Take(64));
+        UpdateStableVisuals(snapshot);
+        EvidenceDetails.ReplaceAll(BuildEvidenceDetails(observation));
+    }
+
+    private void UpdateStableVisuals(SvStreamSnapshot snapshot)
+    {
+        var expectedPoints = ResolveTwoCyclePointCount(snapshot.SampleRate);
+        var fullWindow = snapshot.WaveformPoints.Count >= expectedPoints;
+        if (fullWindow)
+        {
+            WaveformPoints.ReplaceAll(snapshot.WaveformPoints.TakeLast(expectedPoints));
+            Phasors.ReplaceAll(snapshot.Phasors);
+            WaveformState = $"2 cycles locked · {expectedPoints:N0} points";
+            return;
+        }
+
+        if (WaveformPoints.Count == 0)
+            Phasors.ReplaceAll(Array.Empty<PhasorVector>());
+        WaveformState = $"Filling full window · {snapshot.WaveformPoints.Count:N0}/{expectedPoints:N0} points";
+    }
+
+    private static int ResolveTwoCyclePointCount(ushort? sampleRate)
+    {
+        var pointsPerCycle = sampleRate is > 1000
+            ? (int)Math.Round(sampleRate.Value / 50.0)
+            : sampleRate ?? 80;
+        return Math.Clamp(pointsPerCycle * 2, 32, 512);
+    }
 
-        Replace(Values, snapshot.Values.Take(64));
-        Replace(WaveformPoints, snapshot.WaveformPoints);
-        Replace(Phasors, snapshot.Phasors);
+    private static double ResolveObservationDuration(SvObservedStreamFacts? facts)
+    {
+        if (facts?.FirstTimestamp is not { } first || facts.LastTimestamp is not { } last)
+            return 0;
+        return Math.Max(0, (last - first).TotalSeconds);
+    }
+
+    private static int ResolveObservationSamples(SvObservedStreamFacts? facts)
+    {
+        if (facts is null)
+            return 0;
+        return facts.ObservationCount * Math.Max(1, facts.AsduPerFrame ?? 1);
+    }
+
+    private static string ConfidenceReason(SvProfileDetectionResult detection)
+        => detection.Confidence switch
+        {
+            SvProfileConfidence.Unknown => "insufficient evidence",
+            SvProfileConfidence.Possible => "partial evidence",
+            SvProfileConfidence.Likely => "strong engineering evidence",
+            SvProfileConfidence.Confirmed => "mature matching evidence",
+            SvProfileConfidence.Conflict => "conflicting evidence",
+            _ => "insufficient evidence"
+        };
+
+    private static string ResolveHealthDetail(
+        SvStreamSnapshot snapshot,
+        SvStreamObservationSnapshot? observation,
+        string health)
+    {
+        var blocking = observation?.ConfigurationComparison?.Findings
+            .FirstOrDefault(item => item.Severity == SvConfigurationFindingSeverity.Error);
+        if (blocking is not null)
+            return blocking.Message;
+
+        if (snapshot.PayloadIssueCount > 0 || snapshot.OutOfOrderCount > 0)
+            return snapshot.HealthDetail;
+
+        var warning = observation?.ConfigurationComparison?.Findings
+            .FirstOrDefault(item => item.Severity == SvConfigurationFindingSeverity.Warning);
+        if (warning is not null)
+            return warning.Message;
+
+        if (health == "GOOD")
+            return "SV stream is stable and matches the configured SCL expectation.";
+        return snapshot.HealthDetail;
     }
 
-    private static void Replace<T>(ObservableCollection<T> collection, IEnumerable<T> items)
+    private static IReadOnlyList<string> BuildEvidenceDetails(SvStreamObservationSnapshot? observation)
     {
-        collection.Clear();
-        foreach (var item in items)
-            collection.Add(item);
+        if (observation is null)
+            return ["No observation evidence is available yet."];
+
+        var lines = new List<string>();
+        if (observation.ProfileDetection is { } detection)
+        {
+            lines.Add($"Profile: {detection.Profile.DisplayName} · confidence {detection.Confidence} · score {detection.ScorePercent:0.#}% · evidence {detection.MatchedWeight}/{detection.EvaluatedWeight}.");
+            lines.AddRange(detection.Evidence.Select(item =>
+                $"PROFILE · {item.Field} · {item.Outcome} · expected {item.Expected} · observed {item.Observed} · {item.Message}"));
+        }
+
+        if (observation.ConfigurationComparison is { } comparison)
+        {
+            lines.Add($"SCL comparison: {comparison.Summary} · mode {comparison.Mode}.");
+            lines.AddRange(comparison.Findings.Select(item =>
+                $"SCL · {item.Severity} · {item.Field} · expected {item.Expected} · observed {item.Observed} · {item.Message}"));
+        }
+        else
+        {
+            lines.Add("SCL comparison: not configured.");
+        }
+
+        lines.AddRange(observation.Diagnostics.Select(item => $"OBSERVATION · {item}"));
+        return lines.Distinct(StringComparer.Ordinal).ToArray();
     }
 }

From 65480aa1dc42fd12a62805a4c1cf4408ce6900eb Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:04:26 +0700
Subject: [PATCH 13/39] Wire compact P3D state into Subscriber refresh pipeline

---
 .../ViewModels/SvSubscriberViewModel.cs       | 74 +++++++++++++------
 1 file changed, 53 insertions(+), 21 deletions(-)

diff --git a/src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs b/src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs
index 16bbcfc..18ed11f 100644
--- a/src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs
+++ b/src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs
@@ -15,6 +15,7 @@ namespace ARSVIN.Subscriber.ViewModels;
 public sealed class SvSubscriberViewModel : ObservableObject, IDisposable
 {
     private readonly ConcurrentDictionary<string, SvStreamRuntime> _runtimeStreams = new(StringComparer.Ordinal);
+    private readonly ConcurrentDictionary<string, SvStreamObservationSnapshot> _latestObservations = new(StringComparer.Ordinal);
     private readonly SvStreamObservationManager _observationManager = new();
     private readonly Dictionary<string, SvStreamViewModel> _streamRows = new(StringComparer.OrdinalIgnoreCase);
     private readonly DispatcherTimer _uiTimer;
@@ -60,7 +61,7 @@ public SvSubscriberViewModel()
 
     public ObservableCollection<AdapterChoice> Adapters { get; } = new();
     public ObservableCollection<SvStreamViewModel> Streams { get; } = new();
-    public ObservableCollection<DecodedValueRow> SelectedValues { get; } = new();
+    public BulkObservableCollection<DecodedValueRow> SelectedValues { get; } = new();
 
     public RelayCommand RefreshAdaptersCommand { get; }
     public AsyncRelayCommand OpenSclCommand { get; }
@@ -181,7 +182,6 @@ private async Task OpenSclAsync()
         }
     }
 
-
     private async Task OpenCaptureFileAsync()
     {
         var dialog = new OpenFileDialog
@@ -247,8 +247,13 @@ private void ObserveFrame(
         }
 
         var key = observation.Key.Id;
+        _latestObservations[key] = observation;
         var runtime = _runtimeStreams.GetOrAdd(key, _ => new SvStreamRuntime(key));
-        runtime.Observe(timestamp, frame, profile, observation);
+        runtime.Observe(
+            timestamp,
+            frame,
+            observation.IsBoundToScl ? profile : null,
+            observation);
     }
 
     private void ToggleCapture()
@@ -340,11 +345,34 @@ private bool PassesUserFilter(SampledValuesFrame frame)
         if (asdu is null || _sclProfiles.Count == 0)
             return null;
 
-        return _sclProfiles.FirstOrDefault(profile =>
-                   profile.AppId == frame.AppId &&
-                   string.Equals(profile.Stream.SvId, asdu.SvId, StringComparison.OrdinalIgnoreCase))
-               ?? _sclProfiles.FirstOrDefault(profile => profile.AppId == frame.AppId)
-               ?? _sclProfiles.FirstOrDefault(profile => string.Equals(profile.Stream.SvId, asdu.SvId, StringComparison.OrdinalIgnoreCase));
+        var addressCandidates = _sclProfiles.Where(profile =>
+                profile.AppId == frame.AppId &&
+                string.Equals(profile.Destination.ToString(), frame.Destination.ToString(), StringComparison.OrdinalIgnoreCase) &&
+                profile.Vlan?.VlanId == frame.Vlan?.VlanId)
+            .ToArray();
+        if (addressCandidates.Length == 0)
+            return null;
+
+        var exact = addressCandidates.Where(profile =>
+                string.Equals(profile.Stream.SvId, asdu.SvId, StringComparison.Ordinal) &&
+                string.Equals(profile.Stream.DataSetReference, asdu.DataSetReference, StringComparison.Ordinal))
+            .ToArray();
+        if (exact.Length == 1)
+            return exact[0];
+
+        var svIdMatches = addressCandidates.Where(profile =>
+                string.Equals(profile.Stream.SvId, asdu.SvId, StringComparison.Ordinal))
+            .ToArray();
+        if (svIdMatches.Length == 1)
+            return svIdMatches[0];
+
+        var dataSetMatches = addressCandidates.Where(profile =>
+                string.Equals(profile.Stream.DataSetReference, asdu.DataSetReference, StringComparison.Ordinal))
+            .ToArray();
+        if (dataSetMatches.Length == 1)
+            return dataSetMatches[0];
+
+        return addressCandidates.Length == 1 ? addressCandidates[0] : null;
     }
 
     private void RefreshUiSnapshots()
@@ -360,7 +388,8 @@ private void RefreshUiSnapshots()
                 SelectedStream ??= row;
             }
 
-            row.Apply(snapshot);
+            _latestObservations.TryGetValue(snapshot.Key, out var observation);
+            row.Apply(snapshot, observation);
         }
 
         var keys = snapshots.Select(x => x.Key).ToHashSet(StringComparer.OrdinalIgnoreCase);
@@ -378,12 +407,7 @@ private void RefreshUiSnapshots()
 
     private void RefreshSelectedValues()
     {
-        SelectedValues.Clear();
-        if (SelectedStream is null)
-            return;
-
-        foreach (var value in SelectedStream.Values)
-            SelectedValues.Add(value);
+        SelectedValues.ReplaceAll(SelectedStream?.Values ?? Array.Empty<DecodedValueRow>());
     }
 
     private void UpdateGlobalCards(IReadOnlyList<SvStreamSnapshot> snapshots)
@@ -392,7 +416,12 @@ private void UpdateGlobalCards(IReadOnlyList<SvStreamSnapshot> snapshots)
         var sv = Interlocked.Read(ref _svFrames);
         var parse = Interlocked.Read(ref _parseErrors);
         var dropped = Interlocked.Read(ref _droppedByFilter);
-        var issues = snapshots.Sum(x => x.SequenceGapCount + x.DuplicateCount + x.OutOfOrderCount + x.PayloadIssueCount + x.SclMismatchCount) + parse;
+        var runtimeIssues = snapshots.Sum(x => x.SequenceGapCount + x.DuplicateCount + x.OutOfOrderCount + x.PayloadIssueCount);
+        var configurationIssues = snapshots.Sum(snapshot =>
+            _latestObservations.TryGetValue(snapshot.Key, out var observation)
+                ? observation.ConfigurationComparison?.Findings.Count ?? 0
+                : 0);
+        var issues = runtimeIssues + configurationIssues + parse;
         var duration = _captureStarted.HasValue ? DateTimeOffset.Now - _captureStarted.Value : TimeSpan.Zero;
         var fps = duration.TotalSeconds > 0.001 ? sv / duration.TotalSeconds : 0;
 
@@ -405,12 +434,14 @@ private void UpdateGlobalCards(IReadOnlyList<SvStreamSnapshot> snapshots)
 
         if (!IsCapturing && snapshots.Count == 0)
             HealthText = "IDLE";
-        else if (issues > 0)
-            HealthText = snapshots.Any(x => x.Health == "BAD") || parse > 0 ? "BAD" : "WARN";
+        else if (_streamRows.Values.Any(row => row.Health == "BAD") || parse > 0)
+            HealthText = "BAD";
+        else if (_streamRows.Values.Any(row => row.Health == "WARN"))
+            HealthText = "WARN";
         else if (snapshots.Count == 0)
             HealthText = IsCapturing ? "LISTENING" : "IDLE";
         else
-            HealthText = snapshots.All(x => x.IsBoundToScl) ? "GOOD" : "WARN";
+            HealthText = "GOOD";
 
         if (dropped > 0 && IsCapturing)
             StatusText = $"Listening. User filter dropped {dropped:N0} SV frame(s).";
@@ -420,7 +451,7 @@ private void Clear()
     {
         ClearRuntimeOnly();
         Streams.Clear();
-        SelectedValues.Clear();
+        SelectedValues.ReplaceAll(Array.Empty<DecodedValueRow>());
         _streamRows.Clear();
         SelectedStream = null;
         HealthText = "IDLE";
@@ -431,10 +462,11 @@ private void Clear()
     private void ClearRuntimeOnly()
     {
         _runtimeStreams.Clear();
+        _latestObservations.Clear();
         _observationManager.Clear();
         _streamRows.Clear();
         Streams.Clear();
-        SelectedValues.Clear();
+        SelectedValues.ReplaceAll(Array.Empty<DecodedValueRow>());
         SelectedStream = null;
         Interlocked.Exchange(ref _rawFrames, 0);
         Interlocked.Exchange(ref _svFrames, 0);

From 09d80c66dff252876b8d81b2623b89c21b76c54f Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:05:27 +0700
Subject: [PATCH 14/39] Add compact P3D status and expandable evidence panel

---
 src/ARSVIN.Subscriber/MainWindow.xaml | 54 ++++++++++++++++++++++++++-
 1 file changed, 52 insertions(+), 2 deletions(-)

diff --git a/src/ARSVIN.Subscriber/MainWindow.xaml b/src/ARSVIN.Subscriber/MainWindow.xaml
index b965643..11a9f7f 100644
--- a/src/ARSVIN.Subscriber/MainWindow.xaml
+++ b/src/ARSVIN.Subscriber/MainWindow.xaml
@@ -182,6 +182,8 @@
             <Grid Grid.Column="2">
                 <Grid.RowDefinitions>
                     <RowDefinition Height="46" />
+                    <RowDefinition Height="66" />
+                    <RowDefinition Height="Auto" />
                     <RowDefinition Height="*" />
                 </Grid.RowDefinitions>
 
@@ -205,7 +207,55 @@
                     </Grid>
                 </Border>
 
-                <Border Grid.Row="1" Style="{StaticResource PanelShell}" Padding="10">
+                <Border Grid.Row="1" Style="{StaticResource PanelShell}" Padding="10,7" Margin="0,0,0,8">
+                    <Grid>
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="1.15*" />
+                            <ColumnDefinition Width="1.15*" />
+                            <ColumnDefinition Width="0.9*" />
+                            <ColumnDefinition Width="1.05*" />
+                        </Grid.ColumnDefinitions>
+                        <StackPanel Grid.Column="0" Margin="2,0,14,0">
+                            <TextBlock Text="PROFILE" Foreground="{StaticResource Dim}" FontSize="9.5" FontWeight="SemiBold" />
+                            <TextBlock Text="{Binding SelectedStream.Profile}" Foreground="{StaticResource Blue}" FontSize="11.5" FontWeight="SemiBold" TextTrimming="CharacterEllipsis" />
+                        </StackPanel>
+                        <StackPanel Grid.Column="1" Margin="2,0,14,0">
+                            <TextBlock Text="CONFIDENCE" Foreground="{StaticResource Dim}" FontSize="9.5" FontWeight="SemiBold" />
+                            <TextBlock Text="{Binding SelectedStream.Confidence}" Foreground="{StaticResource Muted}" FontSize="11.5" FontWeight="SemiBold" TextTrimming="CharacterEllipsis" />
+                        </StackPanel>
+                        <StackPanel Grid.Column="2" Margin="2,0,14,0">
+                            <TextBlock Text="SCL MATCH" Foreground="{StaticResource Dim}" FontSize="9.5" FontWeight="SemiBold" />
+                            <TextBlock Text="{Binding SelectedStream.SclMatch}" Foreground="{StaticResource Muted}" FontSize="11.5" FontWeight="SemiBold" TextTrimming="CharacterEllipsis" />
+                        </StackPanel>
+                        <StackPanel Grid.Column="3" Margin="2,0,0,0">
+                            <TextBlock Text="WINDOW" Foreground="{StaticResource Dim}" FontSize="9.5" FontWeight="SemiBold" />
+                            <TextBlock Text="{Binding SelectedStream.Window}" Foreground="{StaticResource Muted}" FontSize="11.5" FontFamily="Cascadia Mono, Consolas" TextTrimming="CharacterEllipsis" />
+                        </StackPanel>
+                    </Grid>
+                </Border>
+
+                <Expander Grid.Row="2" IsExpanded="False" Margin="0,0,0,8">
+                    <Expander.Header>
+                        <StackPanel Orientation="Horizontal">
+                            <TextBlock Text="Evidence details" Foreground="{StaticResource Blue}" FontSize="11.5" FontWeight="SemiBold" />
+                            <TextBlock Text=" · " Foreground="{StaticResource Dim}" />
+                            <TextBlock Text="{Binding SelectedStream.ComparisonMode}" Foreground="{StaticResource Muted}" FontSize="11" />
+                        </StackPanel>
+                    </Expander.Header>
+                    <Border Margin="0,6,0,0" Padding="10,7" CornerRadius="8" Background="#FBFDFF" BorderBrush="#DCE6F3" BorderThickness="1" MaxHeight="150">
+                        <ScrollViewer VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Disabled">
+                            <ItemsControl ItemsSource="{Binding SelectedStream.EvidenceDetails}">
+                                <ItemsControl.ItemTemplate>
+                                    <DataTemplate>
+                                        <TextBlock Text="{Binding}" TextWrapping="Wrap" Foreground="{StaticResource Muted}" FontSize="10.5" Margin="0,0,0,5" />
+                                    </DataTemplate>
+                                </ItemsControl.ItemTemplate>
+                            </ItemsControl>
+                        </ScrollViewer>
+                    </Border>
+                </Expander>
+
+                <Border Grid.Row="3" Style="{StaticResource PanelShell}" Padding="10">
                     <Grid>
                         <Grid.RowDefinitions>
                             <RowDefinition Height="24" />
@@ -213,7 +263,7 @@
                         </Grid.RowDefinitions>
                         <DockPanel Grid.Row="0" LastChildFill="False" Margin="2,0,2,6">
                             <TextBlock Text="Waveform" Style="{StaticResource SectionTitle}" />
-                            <TextBlock DockPanel.Dock="Right" Text="2-cycle live monitor" Foreground="{StaticResource Muted}" FontSize="11" />
+                            <TextBlock DockPanel.Dock="Right" Text="{Binding SelectedStream.WaveformState}" Foreground="{StaticResource Muted}" FontSize="11" />
                         </DockPanel>
                         <Border x:Name="ScopeHost" Grid.Row="1" />
                     </Grid>

From 9c8c5aa5f85803b965d53eb5bfcefccbf28bb0a6 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:05:43 +0700
Subject: [PATCH 15/39] Add deterministic P3D presentation contract tests

---
 .../Profiles/SvSubscriberUxContractTests.cs   | 77 +++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 tests/ARSVIN.Tests/SampledValues/Profiles/SvSubscriberUxContractTests.cs

diff --git a/tests/ARSVIN.Tests/SampledValues/Profiles/SvSubscriberUxContractTests.cs b/tests/ARSVIN.Tests/SampledValues/Profiles/SvSubscriberUxContractTests.cs
new file mode 100644
index 0000000..dd3a0ad
--- /dev/null
+++ b/tests/ARSVIN.Tests/SampledValues/Profiles/SvSubscriberUxContractTests.cs
@@ -0,0 +1,77 @@
+using AR.Iec61850.Ethernet;
+using AR.Iec61850.SampledValues;
+using AR.Iec61850.SampledValues.Profiles;
+using Xunit;
+
+namespace ARSVIN.Tests.SampledValues.Profiles;
+
+public sealed class SvSubscriberUxContractTests
+{
+    [Fact]
+    public void GenericLayer2ProfileRemainsUnknownWithInsufficientEvidence()
+    {
+        var manager = new SvStreamObservationManager();
+
+        Assert.True(manager.TryObserve(
+            DateTimeOffset.UnixEpoch,
+            CreateFrame(sampleCount: 1),
+            SvObservationInputKind.LiveCapture,
+            profile: null,
+            out var snapshot));
+
+        var detection = Assert.IsType<SvProfileDetectionResult>(snapshot.ProfileDetection);
+        Assert.Equal("Generic Layer-2 SV", detection.Profile.Family);
+        Assert.Equal(SvProfileConfidence.Unknown, detection.Confidence);
+        Assert.Equal(5, detection.EvaluatedWeight);
+        Assert.Equal(100, detection.ScorePercent);
+    }
+
+    [Fact]
+    public void ObservationSnapshotCarriesWindowFactsForCompactState()
+    {
+        var manager = new SvStreamObservationManager();
+
+        manager.TryObserve(
+            DateTimeOffset.UnixEpoch,
+            CreateFrame(sampleCount: 10),
+            SvObservationInputKind.PcapReplay,
+            profile: null,
+            out _);
+        manager.TryObserve(
+            DateTimeOffset.UnixEpoch.AddSeconds(2),
+            CreateFrame(sampleCount: 11),
+            SvObservationInputKind.PcapReplay,
+            profile: null,
+            out var snapshot);
+
+        Assert.Equal(2, snapshot.Facts.ObservationCount);
+        Assert.Equal(1, snapshot.Facts.AsduPerFrame);
+        Assert.Equal(DateTimeOffset.UnixEpoch, snapshot.Facts.FirstTimestamp);
+        Assert.Equal(DateTimeOffset.UnixEpoch.AddSeconds(2), snapshot.Facts.LastTimestamp);
+    }
+
+    private static SampledValuesFrame CreateFrame(ushort sampleCount)
+        => new()
+        {
+            Source = MacAddress.Parse("02:00:00:00:00:01"),
+            Destination = MacAddress.Parse("01:0C:CD:04:00:01"),
+            Vlan = new VlanTag(4, 100),
+            AppId = 0x4001,
+            Pdu = new SampledValuesPdu
+            {
+                Asdus =
+                [
+                    new SampledValueAsdu
+                    {
+                        SvId = "MU01SV01",
+                        DataSetReference = "MU01MUnn/LLN0$PhsMeas",
+                        SampleCount = sampleCount,
+                        ConfigurationRevision = 7,
+                        SampleRate = 80,
+                        SampleMode = 0,
+                        SamplePayload = new byte[8]
+                    }
+                ]
+            }
+        };
+}

From ebaddf3e7813e725f7473754c17aa2ad213d2640 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:06:42 +0700
Subject: [PATCH 16/39] Expose bulk collections through stable read-only
 bindings

---
 .../ViewModels/SvStreamViewModel.cs           | 24 +++++++++++--------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/ARSVIN.Subscriber/ViewModels/SvStreamViewModel.cs b/src/ARSVIN.Subscriber/ViewModels/SvStreamViewModel.cs
index 31b8fd6..976565b 100644
--- a/src/ARSVIN.Subscriber/ViewModels/SvStreamViewModel.cs
+++ b/src/ARSVIN.Subscriber/ViewModels/SvStreamViewModel.cs
@@ -5,6 +5,10 @@ namespace ARSVIN.Subscriber.ViewModels;
 
 public sealed class SvStreamViewModel : ObservableObject
 {
+    private readonly BulkObservableCollection<DecodedValueRow> _values = new();
+    private readonly BulkObservableCollection<WaveformPoint> _waveformPoints = new();
+    private readonly BulkObservableCollection<PhasorVector> _phasors = new();
+    private readonly BulkObservableCollection<string> _evidenceDetails = new();
     private string _key = string.Empty;
     private string _health = "IDLE";
     private string _healthDetail = string.Empty;
@@ -36,10 +40,10 @@ public sealed class SvStreamViewModel : ObservableObject
     private string _comparisonMode = "Compatible";
     private string _waveformState = "Waiting for complete two-cycle window";
 
-    public BulkObservableCollection<DecodedValueRow> Values { get; } = new();
-    public BulkObservableCollection<WaveformPoint> WaveformPoints { get; } = new();
-    public BulkObservableCollection<PhasorVector> Phasors { get; } = new();
-    public BulkObservableCollection<string> EvidenceDetails { get; } = new();
+    public IReadOnlyList<DecodedValueRow> Values => _values;
+    public IReadOnlyList<WaveformPoint> WaveformPoints => _waveformPoints;
+    public IReadOnlyList<PhasorVector> Phasors => _phasors;
+    public IReadOnlyList<string> EvidenceDetails => _evidenceDetails;
 
     public string Key { get => _key; set => SetProperty(ref _key, value); }
     public string Health { get => _health; set => SetProperty(ref _health, value); }
@@ -130,9 +134,9 @@ public void Apply(SvStreamSnapshot snapshot, SvStreamObservationSnapshot? observ
         var samples = ResolveObservationSamples(observation?.Facts);
         Window = $"{duration:0.0} s · {samples:N0} samples";
 
-        Values.ReplaceAll(snapshot.Values.Take(64));
+        _values.ReplaceAll(snapshot.Values.Take(64));
         UpdateStableVisuals(snapshot);
-        EvidenceDetails.ReplaceAll(BuildEvidenceDetails(observation));
+        _evidenceDetails.ReplaceAll(BuildEvidenceDetails(observation));
     }
 
     private void UpdateStableVisuals(SvStreamSnapshot snapshot)
@@ -141,14 +145,14 @@ private void UpdateStableVisuals(SvStreamSnapshot snapshot)
         var fullWindow = snapshot.WaveformPoints.Count >= expectedPoints;
         if (fullWindow)
         {
-            WaveformPoints.ReplaceAll(snapshot.WaveformPoints.TakeLast(expectedPoints));
-            Phasors.ReplaceAll(snapshot.Phasors);
+            _waveformPoints.ReplaceAll(snapshot.WaveformPoints.TakeLast(expectedPoints));
+            _phasors.ReplaceAll(snapshot.Phasors);
             WaveformState = $"2 cycles locked · {expectedPoints:N0} points";
             return;
         }
 
-        if (WaveformPoints.Count == 0)
-            Phasors.ReplaceAll(Array.Empty<PhasorVector>());
+        if (_waveformPoints.Count == 0)
+            _phasors.ReplaceAll(Array.Empty<PhasorVector>());
         WaveformState = $"Filling full window · {snapshot.WaveformPoints.Count:N0}/{expectedPoints:N0} points";
     }
 

From 106606261a3b01d90da8d8e8570ed95ea562aa27 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:07:04 +0700
Subject: [PATCH 17/39] Document compact Subscriber evidence UX

---
 docs/sv-profile-infrastructure.md | 43 +++++++++++++++++++++----------
 1 file changed, 29 insertions(+), 14 deletions(-)

diff --git a/docs/sv-profile-infrastructure.md b/docs/sv-profile-infrastructure.md
index 2ec52c8..7eb0547 100644
--- a/docs/sv-profile-infrastructure.md
+++ b/docs/sv-profile-infrastructure.md
@@ -94,23 +94,38 @@ Neither mode stops receive-side capture or decoding. Unknown and conflicting str
 
 Before accepting an SCL candidate, the observation manager requires APPID, destination MAC, and VLAN to identify the same configured stream. A candidate that fails this address gate is rejected instead of contaminating observed facts with the wrong dataset layout.
 
+## Subscriber compact state
+
+The selected stream now exposes one compact analysis strip instead of permanent large evidence cards:
+
+```text
+PROFILE       Generic Layer-2 SV
+CONFIDENCE    Unknown · insufficient evidence
+SCL MATCH     Exact | N warnings | N errors
+WINDOW        duration · observed samples
+```
+
+Detailed detector evidence, configuration findings, and observation diagnostics remain collapsed behind an expandable evidence panel. Capture and visualization continue without requiring repeated manual selection.
+
+Waveform, phasor, and RMS collections use one reset notification per UI refresh. The visual layer withholds partial waveform windows until a complete two-cycle set is available, then retains the most recent complete window if the next refresh is incomplete. Compatible SCL warnings remain warnings and do not force the stream into a blocking `BAD` state.
+
 ## Current integration boundary
 
-`SvStreamObservationManager` now:
+`SvStreamObservationManager` and Subscriber now:
 
-- accepts parsed frames from live Npcap capture and classic-PCAP replay;
-- groups frames by source, destination, VLAN, APPID, `svID`, and dataset reference;
-- deliberately keeps `confRev` outside the key so revision changes remain observable;
-- retains input provenance (`LiveCapture` or `PcapReplay`);
-- validates the SCL candidate against the observed address tuple;
-- converts a bound SCL stream into `SvExpectedStreamConfiguration`;
-- runs Compatible comparison by default, with Strict available per observation call;
-- adds SCL-derived dataset signatures when a stream is bound; and
-- exposes immutable rolling facts plus persistent configuration comparison results to Subscriber runtime snapshots.
+- accept parsed frames from live Npcap capture and classic-PCAP replay;
+- group frames by source, destination, VLAN, APPID, `svID`, and dataset reference;
+- deliberately keep `confRev` outside the key so revision changes remain observable;
+- retain input provenance (`LiveCapture` or `PcapReplay`);
+- validate the SCL candidate against the observed address tuple;
+- convert a bound SCL stream into `SvExpectedStreamConfiguration`;
+- run Compatible comparison by default, with Strict available per observation call;
+- evaluate the built-in evidence-aware profile catalog;
+- expose compact profile, confidence, SCL match, and observation-window state;
+- expose detailed evidence only on demand; and
+- keep full-window waveform, phasor, and RMS visualization stable through bulk collection refreshes.
 
 ## Next integration
 
-1. Present one compact profile/confidence and SCL-match state per selected stream.
-2. Show evidence and mismatch details on demand rather than adding permanent visual noise.
-3. Add profile-specific definitions only after source review and deterministic evidence.
-4. Serialize profile, configuration, provenance, and source evidence into Subscriber reports.
+1. Add profile-specific definitions only after source review and deterministic evidence.
+2. Serialize profile, configuration, provenance, observation-window, and source evidence into Subscriber reports.

From b1600a14867c5547f341a77c6afc693db1965ac7 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:09:46 +0700
Subject: [PATCH 18/39] Use a two-second Subscriber observation window

---
 .../SampledValues/Profiles/SvStreamObservationManager.cs   | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
index 2bc358e..9b43c2f 100644
--- a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
+++ b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Profiles/SvStreamObservationManager.cs
@@ -64,6 +64,9 @@ public sealed record SvStreamObservationSnapshot
 
 public sealed class SvStreamObservationManager
 {
+    public const int DefaultMaximumObservations = 12_288;
+    public static readonly TimeSpan DefaultMaximumAge = TimeSpan.FromSeconds(2);
+
     private sealed class StreamState
     {
         private readonly object _gate = new();
@@ -151,13 +154,13 @@ public SvStreamObservationSnapshot Snapshot(SvObservedStreamKey key)
     private readonly TimeSpan _maximumAge;
 
     public SvStreamObservationManager(
-        int maximumObservations = SvObservationAccumulator.DefaultMaximumObservations,
+        int maximumObservations = DefaultMaximumObservations,
         TimeSpan? maximumAge = null)
     {
         if (maximumObservations < 2)
             throw new ArgumentOutOfRangeException(nameof(maximumObservations));
 
-        _maximumAge = maximumAge ?? SvObservationAccumulator.DefaultMaximumAge;
+        _maximumAge = maximumAge ?? DefaultMaximumAge;
         if (_maximumAge <= TimeSpan.Zero)
             throw new ArgumentOutOfRangeException(nameof(maximumAge));
 

From d9d3ffeee1edd0ce4ecb5dc18c39e2e98d78887f Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:09:55 +0700
Subject: [PATCH 19/39] Lock the two-second Subscriber observation defaults

---
 .../Profiles/SvObservationWindowDefaultsTests.cs   | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 tests/ARSVIN.Tests/SampledValues/Profiles/SvObservationWindowDefaultsTests.cs

diff --git a/tests/ARSVIN.Tests/SampledValues/Profiles/SvObservationWindowDefaultsTests.cs b/tests/ARSVIN.Tests/SampledValues/Profiles/SvObservationWindowDefaultsTests.cs
new file mode 100644
index 0000000..8fcae5e
--- /dev/null
+++ b/tests/ARSVIN.Tests/SampledValues/Profiles/SvObservationWindowDefaultsTests.cs
@@ -0,0 +1,14 @@
+using AR.Iec61850.SampledValues.Profiles;
+using Xunit;
+
+namespace ARSVIN.Tests.SampledValues.Profiles;
+
+public sealed class SvObservationWindowDefaultsTests
+{
+    [Fact]
+    public void DefaultWindowSupportsTwoSecondsOfHighRateSampledValues()
+    {
+        Assert.Equal(TimeSpan.FromSeconds(2), SvStreamObservationManager.DefaultMaximumAge);
+        Assert.True(SvStreamObservationManager.DefaultMaximumObservations >= 9_600);
+    }
+}

From cb06dcb8899c7ba8d3931ae0a6ab32299dfa2bb7 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:36:10 +0700
Subject: [PATCH 20/39] Add deterministic SV evidence report schema and
 serializers

---
 .../Reporting/SvSubscriberEvidenceReport.cs   | 587 ++++++++++++++++++
 1 file changed, 587 insertions(+)
 create mode 100644 src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceReport.cs

diff --git a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceReport.cs b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceReport.cs
new file mode 100644
index 0000000..ee6bdec
--- /dev/null
+++ b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceReport.cs
@@ -0,0 +1,587 @@
+using System.Globalization;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using AR.Iec61850.SampledValues.Profiles;
+
+namespace AR.Iec61850.SampledValues.Reporting;
+
+public sealed record SvSubscriberEvidenceReport
+{
+    public const string CurrentSchemaVersion = "arsvin.sv-subscriber-evidence/v1";
+
+    public string SchemaVersion { get; init; } = CurrentSchemaVersion;
+    public DateTimeOffset GeneratedAt { get; init; }
+    public SvSubscriberSoftwareEvidence Software { get; init; } = new();
+    public SvSubscriberCaptureEvidence Capture { get; init; } = new();
+    public SvSubscriberSummaryEvidence Summary { get; init; } = new();
+    public IReadOnlyList<SvSubscriberStreamEvidence> Streams { get; init; }
+        = Array.Empty<SvSubscriberStreamEvidence>();
+
+    public void Validate()
+    {
+        if (!string.Equals(SchemaVersion, CurrentSchemaVersion, StringComparison.Ordinal))
+            throw new InvalidOperationException($"Unsupported SV report schema '{SchemaVersion}'.");
+        if (GeneratedAt == default)
+            throw new InvalidOperationException("SV report requires a generation timestamp.");
+        if (string.IsNullOrWhiteSpace(Software.Product))
+            throw new InvalidOperationException("SV report requires a product name.");
+        if (Summary.StreamCount != Streams.Count)
+            throw new InvalidOperationException("SV report summary stream count does not match the stream evidence collection.");
+        if (Streams.Any(stream => string.IsNullOrWhiteSpace(stream.Key)))
+            throw new InvalidOperationException("Every SV report stream requires a stable key.");
+        if (Streams.Select(stream => stream.Key).Distinct(StringComparer.Ordinal).Count() != Streams.Count)
+            throw new InvalidOperationException("SV report stream keys must be unique.");
+    }
+}
+
+public sealed record SvSubscriberSoftwareEvidence
+{
+    public string Product { get; init; } = string.Empty;
+    public string Version { get; init; } = string.Empty;
+    public string InformationalVersion { get; init; } = string.Empty;
+    public string Commit { get; init; } = string.Empty;
+    public string Repository { get; init; } = string.Empty;
+}
+
+public sealed record SvSubscriberCaptureEvidence
+{
+    public string Source { get; init; } = "Unknown";
+    public string SclPath { get; init; } = string.Empty;
+    public string Adapter { get; init; } = string.Empty;
+    public string Filter { get; init; } = string.Empty;
+    public DateTimeOffset? StartedAt { get; init; }
+    public DateTimeOffset EndedAt { get; init; }
+    public double DurationSeconds { get; init; }
+    public long RawFrames { get; init; }
+    public long SvFrames { get; init; }
+    public long ParseErrors { get; init; }
+    public long DroppedByFilter { get; init; }
+}
+
+public sealed record SvSubscriberSummaryEvidence
+{
+    public string Health { get; init; } = "IDLE";
+    public int StreamCount { get; init; }
+    public int RuntimeIssueCount { get; init; }
+    public int ConfigurationFindingCount { get; init; }
+}
+
+public sealed record SvSubscriberStreamEvidence
+{
+    public string Key { get; init; } = string.Empty;
+    public string Health { get; init; } = "IDLE";
+    public string HealthDetail { get; init; } = string.Empty;
+    public SvSubscriberStreamIdentityEvidence Identity { get; init; } = new();
+    public SvSubscriberRuntimeEvidence Runtime { get; init; } = new();
+    public SvSubscriberObservationEvidence Observation { get; init; } = new();
+    public IReadOnlyList<SvSubscriberPhasorEvidence> Phasors { get; init; }
+        = Array.Empty<SvSubscriberPhasorEvidence>();
+    public IReadOnlyList<string> Diagnostics { get; init; }
+        = Array.Empty<string>();
+}
+
+public sealed record SvSubscriberStreamIdentityEvidence
+{
+    public ushort AppId { get; init; }
+    public string SourceMac { get; init; } = string.Empty;
+    public string DestinationMac { get; init; } = string.Empty;
+    public ushort? VlanId { get; init; }
+    public byte? VlanPriority { get; init; }
+    public string SvId { get; init; } = string.Empty;
+    public string DataSetReference { get; init; } = string.Empty;
+    public uint? ConfigurationRevision { get; init; }
+    public int AsduPerFrame { get; init; }
+    public ushort? LastSampleCount { get; init; }
+    public ushort? DeclaredSampleRate { get; init; }
+    public ushort? DeclaredSampleMode { get; init; }
+    public byte? SampleSynchronization { get; init; }
+}
+
+public sealed record SvSubscriberRuntimeEvidence
+{
+    public long FrameCount { get; init; }
+    public long AsduCount { get; init; }
+    public double ActualFramesPerSecond { get; init; }
+    public double AverageFrameGapMilliseconds { get; init; }
+    public double MaximumFrameGapMilliseconds { get; init; }
+    public int SequenceGapCount { get; init; }
+    public int DuplicateCount { get; init; }
+    public int OutOfOrderCount { get; init; }
+    public int PayloadIssueCount { get; init; }
+    public int SclMismatchCount { get; init; }
+    public bool IsWaveformWindowReady { get; init; }
+    public string LayoutBinding { get; init; } = string.Empty;
+    public string QualitySummary { get; init; } = string.Empty;
+    public string CursorSummary { get; init; } = string.Empty;
+    public string LastSeen { get; init; } = string.Empty;
+}
+
+public sealed record SvSubscriberObservationEvidence
+{
+    public IReadOnlyList<SvObservationInputKind> InputKinds { get; init; }
+        = Array.Empty<SvObservationInputKind>();
+    public SvObservationInputKind LastInputKind { get; init; }
+    public bool IsBoundToScl { get; init; }
+    public string ControlBlockReference { get; init; } = string.Empty;
+    public int WindowFrames { get; init; }
+    public int WindowSamples { get; init; }
+    public double WindowDurationSeconds { get; init; }
+    public DateTimeOffset? FirstTimestamp { get; init; }
+    public DateTimeOffset? LastTimestamp { get; init; }
+    public SvObservedStreamFacts Facts { get; init; } = new();
+    public IReadOnlyDictionary<string, SvFactSource> FactProvenance { get; init; }
+        = new Dictionary<string, SvFactSource>(StringComparer.Ordinal);
+    public SvProfileDetectionResult? ProfileDetection { get; init; }
+    public SvExpectedStreamConfiguration? ExpectedConfiguration { get; init; }
+    public SvConfigurationComparisonResult? ConfigurationComparison { get; init; }
+    public IReadOnlyList<string> Diagnostics { get; init; }
+        = Array.Empty<string>();
+}
+
+public sealed record SvSubscriberPhasorEvidence
+{
+    public string Channel { get; init; } = string.Empty;
+    public string Kind { get; init; } = string.Empty;
+    public double Rms { get; init; }
+    public double Peak { get; init; }
+    public double AngleDegrees { get; init; }
+}
+
+public static class SvSubscriberEvidenceReportSerializer
+{
+    private static readonly JsonSerializerOptions JsonOptions = CreateJsonOptions();
+
+    public static string ToJson(SvSubscriberEvidenceReport report)
+    {
+        ArgumentNullException.ThrowIfNull(report);
+        report.Validate();
+        return JsonSerializer.Serialize(report, JsonOptions);
+    }
+
+    public static SvSubscriberEvidenceReport FromJson(string json)
+    {
+        if (string.IsNullOrWhiteSpace(json))
+            throw new ArgumentException("SV report JSON cannot be empty.", nameof(json));
+
+        var report = JsonSerializer.Deserialize<SvSubscriberEvidenceReport>(json, JsonOptions)
+            ?? throw new InvalidDataException("SV report JSON did not contain a report document.");
+        report.Validate();
+        return report;
+    }
+
+    public static string ToMarkdown(SvSubscriberEvidenceReport report)
+    {
+        ArgumentNullException.ThrowIfNull(report);
+        report.Validate();
+
+        var builder = new StringBuilder();
+        builder.AppendLine("# ARSVIN Subscriber Evidence Report");
+        builder.AppendLine();
+        builder.AppendLine("> Receiver-side engineering evidence. This document is not a formal IEC 61850 conformance certificate.");
+        builder.AppendLine();
+        builder.AppendLine("## Report metadata");
+        builder.AppendLine();
+        AppendKeyValueTable(builder,
+        [
+            ("Schema", report.SchemaVersion),
+            ("Generated", Timestamp(report.GeneratedAt)),
+            ("Product", report.Software.Product),
+            ("Version", report.Software.Version),
+            ("Informational version", report.Software.InformationalVersion),
+            ("Commit", report.Software.Commit),
+            ("Repository", report.Software.Repository),
+            ("Capture source", report.Capture.Source),
+            ("SCL", Empty(report.Capture.SclPath, "not loaded")),
+            ("Adapter", Empty(report.Capture.Adapter)),
+            ("Filter", Empty(report.Capture.Filter, "none")),
+            ("Capture started", Timestamp(report.Capture.StartedAt)),
+            ("Capture ended", Timestamp(report.Capture.EndedAt)),
+            ("Capture duration", Number(report.Capture.DurationSeconds, "0.###") + " s")
+        ]);
+
+        builder.AppendLine("## Summary");
+        builder.AppendLine();
+        AppendKeyValueTable(builder,
+        [
+            ("Health", report.Summary.Health),
+            ("Raw frames", report.Capture.RawFrames.ToString("N0", CultureInfo.InvariantCulture)),
+            ("SV frames", report.Capture.SvFrames.ToString("N0", CultureInfo.InvariantCulture)),
+            ("Streams", report.Summary.StreamCount.ToString("N0", CultureInfo.InvariantCulture)),
+            ("Runtime issues", report.Summary.RuntimeIssueCount.ToString("N0", CultureInfo.InvariantCulture)),
+            ("Configuration findings", report.Summary.ConfigurationFindingCount.ToString("N0", CultureInfo.InvariantCulture)),
+            ("Parse errors", report.Capture.ParseErrors.ToString("N0", CultureInfo.InvariantCulture)),
+            ("Dropped by filter", report.Capture.DroppedByFilter.ToString("N0", CultureInfo.InvariantCulture))
+        ]);
+
+        builder.AppendLine("## Streams");
+        builder.AppendLine();
+        builder.AppendLine("| Health | APPID | svID | Profile | Confidence | SCL match | Window | Input |" );
+        builder.AppendLine("|---|---:|---|---|---|---|---:|---|");
+        foreach (var stream in report.Streams)
+        {
+            var profile = stream.Observation.ProfileDetection;
+            var comparison = stream.Observation.ConfigurationComparison;
+            builder.Append("| ").Append(Cell(stream.Health))
+                .Append(" | ").Append(Hex(stream.Identity.AppId))
+                .Append(" | ").Append(Cell(stream.Identity.SvId))
+                .Append(" | ").Append(Cell(profile?.Profile.DisplayName ?? "Unknown"))
+                .Append(" | ").Append(Cell(profile?.Confidence.ToString() ?? "Unknown"))
+                .Append(" | ").Append(Cell(comparison?.Summary ?? "Not configured"))
+                .Append(" | ").Append(stream.Observation.WindowSamples.ToString("N0", CultureInfo.InvariantCulture))
+                .Append(" samples | ").Append(Cell(InputText(stream.Observation.InputKinds)))
+                .AppendLine(" |");
+        }
+        builder.AppendLine();
+
+        foreach (var stream in report.Streams)
+            AppendStream(builder, stream);
+
+        return builder.ToString();
+    }
+
+    private static void AppendStream(StringBuilder builder, SvSubscriberStreamEvidence stream)
+    {
+        builder.Append("## ").Append(Hex(stream.Identity.AppId)).Append(" — ")
+            .AppendLine(Heading(stream.Identity.SvId));
+        builder.AppendLine();
+        AppendKeyValueTable(builder,
+        [
+            ("Stream key", stream.Key),
+            ("Health", stream.Health),
+            ("Health detail", stream.HealthDetail),
+            ("Source MAC", stream.Identity.SourceMac),
+            ("Destination MAC", stream.Identity.DestinationMac),
+            ("VLAN", stream.Identity.VlanId?.ToString(CultureInfo.InvariantCulture) ?? "untagged"),
+            ("VLAN priority", Value(stream.Identity.VlanPriority)),
+            ("Dataset", stream.Identity.DataSetReference),
+            ("confRev", Value(stream.Identity.ConfigurationRevision)),
+            ("nofASDU", stream.Identity.AsduPerFrame.ToString(CultureInfo.InvariantCulture)),
+            ("Last smpCnt", Value(stream.Identity.LastSampleCount)),
+            ("Declared sample rate", Value(stream.Identity.DeclaredSampleRate)),
+            ("Declared sample mode", Value(stream.Identity.DeclaredSampleMode)),
+            ("smpSynch", Value(stream.Identity.SampleSynchronization)),
+            ("SCL binding", stream.Observation.IsBoundToScl ? Empty(stream.Observation.ControlBlockReference) : "not bound")
+        ]);
+
+        builder.AppendLine("### Observation window");
+        builder.AppendLine();
+        AppendKeyValueTable(builder,
+        [
+            ("Input kinds", InputText(stream.Observation.InputKinds)),
+            ("Last input kind", stream.Observation.LastInputKind.ToString()),
+            ("First timestamp", Timestamp(stream.Observation.FirstTimestamp)),
+            ("Last timestamp", Timestamp(stream.Observation.LastTimestamp)),
+            ("Duration", Number(stream.Observation.WindowDurationSeconds, "0.###") + " s"),
+            ("Frames", stream.Observation.WindowFrames.ToString("N0", CultureInfo.InvariantCulture)),
+            ("Samples", stream.Observation.WindowSamples.ToString("N0", CultureInfo.InvariantCulture)),
+            ("Observed fps", Number(stream.Observation.Facts.ObservedFramesPerSecond, "0.###")),
+            ("Observed samples/s", Number(stream.Observation.Facts.ObservedSamplesPerSecond, "0.###")),
+            ("Observed counter wrap", Value(stream.Observation.Facts.ObservedCounterWrap))
+        ]);
+
+        builder.AppendLine("### Runtime integrity");
+        builder.AppendLine();
+        AppendKeyValueTable(builder,
+        [
+            ("Total frames", stream.Runtime.FrameCount.ToString("N0", CultureInfo.InvariantCulture)),
+            ("Total ASDUs", stream.Runtime.AsduCount.ToString("N0", CultureInfo.InvariantCulture)),
+            ("Actual fps", Number(stream.Runtime.ActualFramesPerSecond, "0.###")),
+            ("Average frame gap", Number(stream.Runtime.AverageFrameGapMilliseconds, "0.###") + " ms"),
+            ("Maximum frame gap", Number(stream.Runtime.MaximumFrameGapMilliseconds, "0.###") + " ms"),
+            ("Sequence gaps", stream.Runtime.SequenceGapCount.ToString(CultureInfo.InvariantCulture)),
+            ("Duplicates", stream.Runtime.DuplicateCount.ToString(CultureInfo.InvariantCulture)),
+            ("Out-of-order", stream.Runtime.OutOfOrderCount.ToString(CultureInfo.InvariantCulture)),
+            ("Payload issues", stream.Runtime.PayloadIssueCount.ToString(CultureInfo.InvariantCulture)),
+            ("SCL mismatches", stream.Runtime.SclMismatchCount.ToString(CultureInfo.InvariantCulture)),
+            ("Waveform window ready", stream.Runtime.IsWaveformWindowReady ? "yes" : "no"),
+            ("Layout binding", stream.Runtime.LayoutBinding),
+            ("Quality", stream.Runtime.QualitySummary),
+            ("Cursor", stream.Runtime.CursorSummary),
+            ("Last seen", stream.Runtime.LastSeen)
+        ]);
+
+        AppendObservedFacts(builder, stream.Observation.Facts);
+        AppendExpectedConfiguration(builder, stream.Observation.ExpectedConfiguration);
+        AppendConfigurationFindings(builder, stream.Observation.ConfigurationComparison);
+        AppendProfileEvidence(builder, stream.Observation.ProfileDetection);
+        AppendPhasors(builder, stream.Phasors);
+        AppendDiagnostics(builder, stream.Diagnostics, stream.Observation.Diagnostics);
+    }
+
+    private static void AppendObservedFacts(StringBuilder builder, SvObservedStreamFacts facts)
+    {
+        builder.AppendLine("### Observed facts and provenance");
+        builder.AppendLine();
+        builder.AppendLine("| Fact | Value | Source |");
+        builder.AppendLine("|---|---|---|");
+        AppendFact(builder, facts, nameof(facts.EtherType), "EtherType", facts.EtherType.HasValue ? Hex(facts.EtherType.Value) : "unknown");
+        AppendFact(builder, facts, nameof(facts.AppId), "APPID", facts.AppId.HasValue ? Hex(facts.AppId.Value) : "unknown");
+        AppendFact(builder, facts, nameof(facts.DestinationMac), "Destination MAC", facts.DestinationMac);
+        AppendFact(builder, facts, nameof(facts.VlanId), "VLAN ID", Value(facts.VlanId));
+        AppendFact(builder, facts, nameof(facts.VlanPriority), "VLAN priority", Value(facts.VlanPriority));
+        AppendFact(builder, facts, nameof(facts.SvId), "svID", facts.SvId);
+        AppendFact(builder, facts, nameof(facts.DataSetReference), "Dataset reference", facts.DataSetReference);
+        AppendFact(builder, facts, nameof(facts.ConfigurationRevision), "confRev", Value(facts.ConfigurationRevision));
+        AppendFact(builder, facts, nameof(facts.AsduPerFrame), "ASDU per frame", Value(facts.AsduPerFrame));
+        AppendFact(builder, facts, nameof(facts.PayloadBytesPerAsdu), "Payload bytes per ASDU", Value(facts.PayloadBytesPerAsdu));
+        AppendFact(builder, facts, nameof(facts.DeclaredSampleRate), "Declared sample rate", Value(facts.DeclaredSampleRate));
+        AppendFact(builder, facts, nameof(facts.DeclaredSampleMode), "Declared sample mode", Value(facts.DeclaredSampleMode));
+        AppendFact(builder, facts, nameof(facts.ObservedFramesPerSecond), "Observed frames/s", Number(facts.ObservedFramesPerSecond, "0.###"));
+        AppendFact(builder, facts, nameof(facts.ObservedSamplesPerSecond), "Observed samples/s", Number(facts.ObservedSamplesPerSecond, "0.###"));
+        AppendFact(builder, facts, nameof(facts.ObservedCounterWrap), "Observed counter wrap", Value(facts.ObservedCounterWrap));
+        AppendFact(builder, facts, nameof(facts.NominalFrequencyHz), "Nominal frequency", Number(facts.NominalFrequencyHz, "0.###"));
+        AppendFact(builder, facts, nameof(facts.DataSetSignature), "Dataset signature", Signature(facts.DataSetSignature));
+        var transitions = facts.CounterTransitions;
+        AppendFact(builder, facts, nameof(facts.CounterTransitions), "Counter transitions",
+            $"sequential {transitions.SequentialCount}, gaps {transitions.GapCount}, duplicates {transitions.DuplicateCount}, out-of-order/reset {transitions.OutOfOrderOrResetCount}, wraps {transitions.ConfirmedWrapCount}");
+        builder.AppendLine();
+    }
+
+    private static void AppendExpectedConfiguration(StringBuilder builder, SvExpectedStreamConfiguration? expected)
+    {
+        builder.AppendLine("### Expected SCL configuration");
+        builder.AppendLine();
+        if (expected is null)
+        {
+            builder.AppendLine("- Not configured.");
+            builder.AppendLine();
+            return;
+        }
+
+        AppendKeyValueTable(builder,
+        [
+            ("EtherType", expected.EtherType.HasValue ? Hex(expected.EtherType.Value) : "unknown"),
+            ("APPID", expected.AppId.HasValue ? Hex(expected.AppId.Value) : "unknown"),
+            ("Destination MAC", expected.DestinationMac),
+            ("VLAN ID", Value(expected.VlanId)),
+            ("VLAN priority", Value(expected.VlanPriority)),
+            ("svID", expected.SvId),
+            ("Dataset", expected.DataSetReference),
+            ("confRev", Value(expected.ConfigurationRevision)),
+            ("ASDU per frame", Value(expected.AsduPerFrame)),
+            ("Payload bytes per ASDU", Value(expected.PayloadBytesPerAsdu)),
+            ("Declared sample rate", Value(expected.DeclaredSampleRate)),
+            ("Declared sample mode", Value(expected.DeclaredSampleMode)),
+            ("Dataset signature", Signature(expected.DataSetSignature))
+        ]);
+    }
+
+    private static void AppendConfigurationFindings(StringBuilder builder, SvConfigurationComparisonResult? comparison)
+    {
+        builder.AppendLine("### Configuration comparison");
+        builder.AppendLine();
+        if (comparison is null)
+        {
+            builder.AppendLine("- Not configured.");
+            builder.AppendLine();
+            return;
+        }
+
+        builder.Append("- Mode: **").Append(comparison.Mode).AppendLine("**");
+        builder.Append("- Result: **").Append(comparison.Summary).AppendLine("**");
+        builder.AppendLine();
+        if (comparison.Findings.Count == 0)
+        {
+            builder.AppendLine("- No differences found.");
+            builder.AppendLine();
+            return;
+        }
+
+        builder.AppendLine("| Severity | Code | Field | Expected | Observed | Message |");
+        builder.AppendLine("|---|---|---|---|---|---|");
+        foreach (var finding in comparison.Findings)
+        {
+            builder.Append("| ").Append(Cell(finding.Severity.ToString()))
+                .Append(" | ").Append(Cell(finding.Code))
+                .Append(" | ").Append(Cell(finding.Field))
+                .Append(" | ").Append(Cell(finding.Expected))
+                .Append(" | ").Append(Cell(finding.Observed))
+                .Append(" | ").Append(Cell(finding.Message)).AppendLine(" |");
+        }
+        builder.AppendLine();
+    }
+
+    private static void AppendProfileEvidence(StringBuilder builder, SvProfileDetectionResult? detection)
+    {
+        builder.AppendLine("### Profile detection evidence");
+        builder.AppendLine();
+        if (detection is null)
+        {
+            builder.AppendLine("- No profile result.");
+            builder.AppendLine();
+            return;
+        }
+
+        AppendKeyValueTable(builder,
+        [
+            ("Profile", detection.Profile.DisplayName),
+            ("Profile ID", detection.Profile.Id),
+            ("Family", detection.Profile.Family),
+            ("Confidence", detection.Confidence.ToString()),
+            ("Raw confidence", detection.RawConfidence.ToString()),
+            ("Score", Number(detection.ScorePercent, "0.###") + "%"),
+            ("Matched weight", detection.MatchedWeight.ToString(CultureInfo.InvariantCulture)),
+            ("Conflict weight", detection.ConflictWeight.ToString(CultureInfo.InvariantCulture)),
+            ("Evaluated weight", detection.EvaluatedWeight.ToString(CultureInfo.InvariantCulture)),
+            ("Evidence status", detection.Profile.EvidenceStatus.ToString())
+        ]);
+
+        builder.AppendLine("#### Evidence sources");
+        builder.AppendLine();
+        builder.AppendLine("| Source | Status | Description |");
+        builder.AppendLine("|---|---|---|");
+        foreach (var source in detection.Profile.Sources)
+        {
+            builder.Append("| ").Append(Cell(source.SourceId))
+                .Append(" | ").Append(Cell(source.Status.ToString()))
+                .Append(" | ").Append(Cell(source.Description)).AppendLine(" |");
+        }
+        builder.AppendLine();
+
+        builder.AppendLine("#### Match evidence");
+        builder.AppendLine();
+        if (detection.Evidence.Count == 0)
+        {
+            builder.AppendLine("- No evaluated evidence fields.");
+            builder.AppendLine();
+            return;
+        }
+
+        builder.AppendLine("| Field | Outcome | Weight | Expected | Observed | Message |");
+        builder.AppendLine("|---|---|---:|---|---|---|");
+        foreach (var evidence in detection.Evidence)
+        {
+            builder.Append("| ").Append(Cell(evidence.Field))
+                .Append(" | ").Append(Cell(evidence.Outcome.ToString()))
+                .Append(" | ").Append(evidence.Weight.ToString(CultureInfo.InvariantCulture))
+                .Append(" | ").Append(Cell(evidence.Expected))
+                .Append(" | ").Append(Cell(evidence.Observed))
+                .Append(" | ").Append(Cell(evidence.Message)).AppendLine(" |");
+        }
+        builder.AppendLine();
+    }
+
+    private static void AppendPhasors(StringBuilder builder, IReadOnlyList<SvSubscriberPhasorEvidence> phasors)
+    {
+        builder.AppendLine("### Phasors");
+        builder.AppendLine();
+        if (phasors.Count == 0)
+        {
+            builder.AppendLine("- No complete decoded phasor window.");
+            builder.AppendLine();
+            return;
+        }
+
+        builder.AppendLine("| Channel | Kind | RMS | Peak | Angle |");
+        builder.AppendLine("|---|---|---:|---:|---:|");
+        foreach (var phasor in phasors)
+        {
+            builder.Append("| ").Append(Cell(phasor.Channel))
+                .Append(" | ").Append(Cell(phasor.Kind))
+                .Append(" | ").Append(Number(phasor.Rms, "0.###"))
+                .Append(" | ").Append(Number(phasor.Peak, "0.###"))
+                .Append(" | ").Append(Number(phasor.AngleDegrees, "0.###")).AppendLine("° |");
+        }
+        builder.AppendLine();
+    }
+
+    private static void AppendDiagnostics(
+        StringBuilder builder,
+        IReadOnlyList<string> runtimeDiagnostics,
+        IReadOnlyList<string> observationDiagnostics)
+    {
+        builder.AppendLine("### Diagnostics");
+        builder.AppendLine();
+        var diagnostics = runtimeDiagnostics.Concat(observationDiagnostics)
+            .Where(item => !string.IsNullOrWhiteSpace(item))
+            .Distinct(StringComparer.Ordinal)
+            .ToArray();
+        if (diagnostics.Length == 0)
+        {
+            builder.AppendLine("- No diagnostics.");
+            builder.AppendLine();
+            return;
+        }
+
+        foreach (var diagnostic in diagnostics)
+            builder.Append("- ").AppendLine(diagnostic);
+        builder.AppendLine();
+    }
+
+    private static void AppendFact(
+        StringBuilder builder,
+        SvObservedStreamFacts facts,
+        string propertyName,
+        string label,
+        string value)
+    {
+        var source = facts.Provenance.TryGetValue(propertyName, out var factSource)
+            ? factSource.ToString()
+            : SvFactSource.Unknown.ToString();
+        builder.Append("| ").Append(Cell(label))
+            .Append(" | ").Append(Cell(Empty(value, "unknown")))
+            .Append(" | ").Append(Cell(source)).AppendLine(" |");
+    }
+
+    private static void AppendKeyValueTable(StringBuilder builder, IEnumerable<(string Key, string Value)> rows)
+    {
+        builder.AppendLine("| Field | Value |");
+        builder.AppendLine("|---|---|");
+        foreach (var row in rows)
+            builder.Append("| ").Append(Cell(row.Key)).Append(" | ").Append(Cell(Empty(row.Value))).AppendLine(" |");
+        builder.AppendLine();
+    }
+
+    private static JsonSerializerOptions CreateJsonOptions()
+    {
+        var options = new JsonSerializerOptions
+        {
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+            WriteIndented = true
+        };
+        options.Converters.Add(new JsonStringEnumConverter(JsonNamingPolicy.CamelCase));
+        return options;
+    }
+
+    private static string InputText(IReadOnlyList<SvObservationInputKind> inputKinds)
+        => inputKinds.Count == 0 ? "Unknown" : string.Join(", ", inputKinds);
+
+    private static string Signature(IReadOnlyList<SvDatasetElementSignature> signature)
+        => signature.Count == 0
+            ? "unknown"
+            : string.Join(", ", signature.Select(item =>
+                $"{Empty(item.BType, "-")}/{Empty(item.Cdc, "-")}" +
+                (item.IsQuality ? ":quality" : string.Empty) +
+                (item.IsTimestamp ? ":timestamp" : string.Empty)));
+
+    private static string Timestamp(DateTimeOffset? value)
+        => value.HasValue ? Timestamp(value.Value) : "unknown";
+
+    private static string Timestamp(DateTimeOffset value)
+        => value.ToString("yyyy-MM-dd HH:mm:ss.fff zzz", CultureInfo.InvariantCulture);
+
+    private static string Hex(ushort value)
+        => $"0x{value:X4}";
+
+    private static string Number(double? value, string format)
+        => value.HasValue ? Number(value.Value, format) : "unknown";
+
+    private static string Number(double value, string format)
+        => value.ToString(format, CultureInfo.InvariantCulture);
+
+    private static string Value<T>(T? value) where T : struct
+        => value.HasValue ? Convert.ToString(value.Value, CultureInfo.InvariantCulture) ?? "unknown" : "unknown";
+
+    private static string Empty(string? value, string fallback = "-")
+        => string.IsNullOrWhiteSpace(value) ? fallback : value;
+
+    private static string Cell(string? value)
+        => Empty(value).Replace("|", "\\|", StringComparison.Ordinal)
+            .Replace("\r", " ", StringComparison.Ordinal)
+            .Replace("\n", " ", StringComparison.Ordinal);
+
+    private static string Heading(string? value)
+        => Empty(value, "Unknown stream").Replace("\r", " ", StringComparison.Ordinal)
+            .Replace("\n", " ", StringComparison.Ordinal);
+}

From 03455ce9f3aa5e2b23c5597c61431a7ddf22bc01 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:36:48 +0700
Subject: [PATCH 21/39] Build Subscriber evidence reports from runtime and
 observation snapshots

---
 .../Reporting/SvSubscriberReportBuilder.cs    | 259 ++++++++++++++++++
 1 file changed, 259 insertions(+)
 create mode 100644 src/ARSVIN.Subscriber/Reporting/SvSubscriberReportBuilder.cs

diff --git a/src/ARSVIN.Subscriber/Reporting/SvSubscriberReportBuilder.cs b/src/ARSVIN.Subscriber/Reporting/SvSubscriberReportBuilder.cs
new file mode 100644
index 0000000..c392fad
--- /dev/null
+++ b/src/ARSVIN.Subscriber/Reporting/SvSubscriberReportBuilder.cs
@@ -0,0 +1,259 @@
+using System.Reflection;
+using AR.Iec61850.SampledValues.Profiles;
+using AR.Iec61850.SampledValues.Reporting;
+using ARSVIN.Subscriber.Models;
+
+namespace ARSVIN.Subscriber.Reporting;
+
+internal sealed record SvSubscriberReportContext
+{
+    public DateTimeOffset GeneratedAt { get; init; }
+    public DateTimeOffset? CaptureStartedAt { get; init; }
+    public string Health { get; init; } = "IDLE";
+    public string SclPath { get; init; } = string.Empty;
+    public string Adapter { get; init; } = string.Empty;
+    public string Filter { get; init; } = string.Empty;
+    public long RawFrames { get; init; }
+    public long SvFrames { get; init; }
+    public long ParseErrors { get; init; }
+    public long DroppedByFilter { get; init; }
+    public IReadOnlyList<SvStreamSnapshot> Streams { get; init; }
+        = Array.Empty<SvStreamSnapshot>();
+    public IReadOnlyDictionary<string, SvStreamObservationSnapshot> Observations { get; init; }
+        = new Dictionary<string, SvStreamObservationSnapshot>(StringComparer.Ordinal);
+}
+
+internal static class SvSubscriberReportBuilder
+{
+    private const string RepositoryUrl = "https://github.com/masarray/arsvin";
+
+    public static SvSubscriberEvidenceReport Build(SvSubscriberReportContext context)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+        if (context.GeneratedAt == default)
+            throw new ArgumentException("Report context requires a generation timestamp.", nameof(context));
+
+        var streams = context.Streams
+            .OrderBy(stream => stream.AppId)
+            .ThenBy(stream => stream.SvId, StringComparer.Ordinal)
+            .Select(stream => BuildStream(stream, ResolveObservation(context, stream.Key)))
+            .ToArray();
+        var runtimeIssues = streams.Sum(stream =>
+            stream.Runtime.SequenceGapCount +
+            stream.Runtime.DuplicateCount +
+            stream.Runtime.OutOfOrderCount +
+            stream.Runtime.PayloadIssueCount);
+        var configurationFindings = streams.Sum(stream =>
+            stream.Observation.ConfigurationComparison?.Findings.Count ?? 0);
+        var duration = context.CaptureStartedAt.HasValue
+            ? Math.Max(0, (context.GeneratedAt - context.CaptureStartedAt.Value).TotalSeconds)
+            : 0;
+
+        return new SvSubscriberEvidenceReport
+        {
+            GeneratedAt = context.GeneratedAt,
+            Software = ResolveSoftwareEvidence(),
+            Capture = new SvSubscriberCaptureEvidence
+            {
+                Source = ResolveCaptureSource(streams),
+                SclPath = context.SclPath,
+                Adapter = context.Adapter,
+                Filter = context.Filter,
+                StartedAt = context.CaptureStartedAt,
+                EndedAt = context.GeneratedAt,
+                DurationSeconds = duration,
+                RawFrames = context.RawFrames,
+                SvFrames = context.SvFrames,
+                ParseErrors = context.ParseErrors,
+                DroppedByFilter = context.DroppedByFilter
+            },
+            Summary = new SvSubscriberSummaryEvidence
+            {
+                Health = context.Health,
+                StreamCount = streams.Length,
+                RuntimeIssueCount = runtimeIssues,
+                ConfigurationFindingCount = configurationFindings
+            },
+            Streams = streams
+        };
+    }
+
+    private static SvSubscriberStreamEvidence BuildStream(
+        SvStreamSnapshot stream,
+        SvStreamObservationSnapshot? observation)
+    {
+        var facts = observation?.Facts ?? BuildFallbackFacts(stream);
+        var inputKinds = observation?.InputKinds ?? stream.ObservationInputKinds;
+        var observationDiagnostics = observation?.Diagnostics ?? stream.ObservationDiagnostics;
+        var profileDetection = observation?.ProfileDetection ?? stream.ProfileDetection;
+        var configurationComparison = observation?.ConfigurationComparison ?? stream.ConfigurationComparison;
+        var diagnostics = stream.Diagnostics.Concat(observationDiagnostics)
+            .Where(item => !string.IsNullOrWhiteSpace(item))
+            .Distinct(StringComparer.Ordinal)
+            .ToArray();
+
+        return new SvSubscriberStreamEvidence
+        {
+            Key = stream.Key,
+            Health = stream.Health,
+            HealthDetail = stream.HealthDetail,
+            Identity = new SvSubscriberStreamIdentityEvidence
+            {
+                AppId = stream.AppId,
+                SourceMac = stream.Source,
+                DestinationMac = stream.Destination,
+                VlanId = stream.VlanId,
+                VlanPriority = stream.VlanPriority,
+                SvId = stream.SvId,
+                DataSetReference = stream.DataSet,
+                ConfigurationRevision = stream.ConfRev,
+                AsduPerFrame = stream.NofAsdu,
+                LastSampleCount = stream.LastSmpCnt,
+                DeclaredSampleRate = stream.SampleRate,
+                DeclaredSampleMode = stream.SampleMode,
+                SampleSynchronization = stream.SmpSynch
+            },
+            Runtime = new SvSubscriberRuntimeEvidence
+            {
+                FrameCount = stream.FrameCount,
+                AsduCount = stream.AsduCount,
+                ActualFramesPerSecond = stream.ActualFps,
+                AverageFrameGapMilliseconds = stream.AverageFrameGapMilliseconds,
+                MaximumFrameGapMilliseconds = stream.MaxFrameGapMilliseconds,
+                SequenceGapCount = stream.SequenceGapCount,
+                DuplicateCount = stream.DuplicateCount,
+                OutOfOrderCount = stream.OutOfOrderCount,
+                PayloadIssueCount = stream.PayloadIssueCount,
+                SclMismatchCount = stream.SclMismatchCount,
+                IsWaveformWindowReady = stream.IsWaveformWindowReady,
+                LayoutBinding = stream.LayoutBinding,
+                QualitySummary = stream.QualitySummary,
+                CursorSummary = stream.CursorSummary,
+                LastSeen = stream.LastSeen
+            },
+            Observation = new SvSubscriberObservationEvidence
+            {
+                InputKinds = inputKinds,
+                LastInputKind = observation?.LastInputKind ?? inputKinds.LastOrDefault(),
+                IsBoundToScl = observation?.IsBoundToScl ?? stream.IsBoundToScl,
+                ControlBlockReference = observation?.ControlBlockReference ?? stream.ControlBlockReference,
+                WindowFrames = facts.ObservationCount > 0
+                    ? facts.ObservationCount
+                    : stream.ObservationWindowFrames,
+                WindowSamples = stream.ObservationWindowSamples,
+                WindowDurationSeconds = ResolveWindowDuration(facts, stream.ObservationWindowDurationSeconds),
+                FirstTimestamp = facts.FirstTimestamp,
+                LastTimestamp = facts.LastTimestamp,
+                Facts = facts,
+                FactProvenance = facts.Provenance.Count > 0
+                    ? facts.Provenance
+                    : stream.FactProvenance,
+                ProfileDetection = profileDetection,
+                ExpectedConfiguration = observation?.ExpectedConfiguration,
+                ConfigurationComparison = configurationComparison,
+                Diagnostics = observationDiagnostics
+            },
+            Phasors = stream.Phasors.Select(phasor => new SvSubscriberPhasorEvidence
+            {
+                Channel = phasor.Channel,
+                Kind = phasor.Kind,
+                Rms = phasor.Rms,
+                Peak = phasor.Peak,
+                AngleDegrees = phasor.AngleDegrees
+            }).ToArray(),
+            Diagnostics = diagnostics
+        };
+    }
+
+    private static SvStreamObservationSnapshot? ResolveObservation(
+        SvSubscriberReportContext context,
+        string key)
+        => context.Observations.TryGetValue(key, out var observation)
+            ? observation
+            : null;
+
+    private static SvObservedStreamFacts BuildFallbackFacts(SvStreamSnapshot stream)
+        => new()
+        {
+            EtherType = 0x88BA,
+            AppId = stream.AppId,
+            DestinationMac = stream.Destination,
+            VlanId = stream.VlanId,
+            VlanPriority = stream.VlanPriority,
+            SvId = stream.SvId,
+            DataSetReference = stream.DataSet,
+            ConfigurationRevision = stream.ConfRev,
+            AsduPerFrame = stream.NofAsdu > 0 ? stream.NofAsdu : null,
+            ObservedFramesPerSecond = stream.ObservedFramesPerSecond,
+            ObservedSamplesPerSecond = stream.ObservedSamplesPerSecond,
+            ObservedCounterWrap = stream.ObservedCounterWrap,
+            DeclaredSampleRate = stream.SampleRate,
+            DeclaredSampleMode = stream.SampleMode,
+            Provenance = stream.FactProvenance,
+            ObservationCount = stream.ObservationWindowFrames,
+            Diagnostics = stream.ObservationDiagnostics
+        };
+
+    private static double ResolveWindowDuration(SvObservedStreamFacts facts, double fallback)
+    {
+        if (facts.FirstTimestamp.HasValue && facts.LastTimestamp.HasValue)
+            return Math.Max(0, (facts.LastTimestamp.Value - facts.FirstTimestamp.Value).TotalSeconds);
+        return Math.Max(0, fallback);
+    }
+
+    private static string ResolveCaptureSource(IReadOnlyList<SvSubscriberStreamEvidence> streams)
+    {
+        var kinds = streams.SelectMany(stream => stream.Observation.InputKinds)
+            .Where(kind => kind != SvObservationInputKind.Unknown)
+            .Distinct()
+            .OrderBy(kind => kind)
+            .ToArray();
+        return kinds.Length switch
+        {
+            0 => "Unknown",
+            1 => kinds[0].ToString(),
+            _ => "Mixed: " + string.Join(", ", kinds)
+        };
+    }
+
+    private static SvSubscriberSoftwareEvidence ResolveSoftwareEvidence()
+    {
+        var assembly = typeof(SvSubscriberReportBuilder).Assembly;
+        var informationalVersion = assembly
+            .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?
+            .InformationalVersion ?? string.Empty;
+        var product = assembly.GetCustomAttribute<AssemblyProductAttribute>()?.Product;
+        var version = assembly.GetName().Version?.ToString() ?? "unknown";
+
+        return new SvSubscriberSoftwareEvidence
+        {
+            Product = string.IsNullOrWhiteSpace(product) ? "ARSVIN Subscriber" : product,
+            Version = version,
+            InformationalVersion = string.IsNullOrWhiteSpace(informationalVersion)
+                ? version
+                : informationalVersion,
+            Commit = ResolveCommit(informationalVersion),
+            Repository = RepositoryUrl
+        };
+    }
+
+    private static string ResolveCommit(string informationalVersion)
+    {
+        foreach (var environmentVariable in new[] { "ARSVIN_COMMIT_SHA", "GITHUB_SHA" })
+        {
+            var value = Environment.GetEnvironmentVariable(environmentVariable);
+            if (!string.IsNullOrWhiteSpace(value))
+                return value.Trim();
+        }
+
+        var separator = informationalVersion.LastIndexOf('+');
+        if (separator >= 0 && separator + 1 < informationalVersion.Length)
+        {
+            var candidate = informationalVersion[(separator + 1)..].Trim();
+            if (candidate.Length >= 7 && candidate.All(Uri.IsHexDigit))
+                return candidate;
+        }
+
+        return "unknown";
+    }
+}

From 4cbd2b7f4f3d390fbf9a62c8c4440082044b6ccf Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:38:01 +0700
Subject: [PATCH 22/39] Export paired Markdown and JSON SV evidence reports

---
 .../ViewModels/SvSubscriberViewModel.cs       | 115 +++++++-----------
 1 file changed, 43 insertions(+), 72 deletions(-)

diff --git a/src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs b/src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs
index 18ed11f..0330b63 100644
--- a/src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs
+++ b/src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs
@@ -4,10 +4,12 @@
 using System.Windows.Threading;
 using AR.Iec61850.SampledValues;
 using AR.Iec61850.SampledValues.Profiles;
+using AR.Iec61850.SampledValues.Reporting;
 using AR.Iec61850.Scl;
 using AR.Iec61850.Transports;
 using AR.Iec61850.Transports.Npcap;
 using ARSVIN.Subscriber.Models;
+using ARSVIN.Subscriber.Reporting;
 using Microsoft.Win32;
 
 namespace ARSVIN.Subscriber.ViewModels;
@@ -481,88 +483,57 @@ private async Task ExportReportAsync()
     {
         var dialog = new SaveFileDialog
         {
-            Title = "Export SV subscriber verification report",
-            Filter = "Markdown report (*.md)|*.md|All files (*.*)|*.*",
-            FileName = $"arsvin-subscriber-report-{DateTime.Now:yyyyMMdd-HHmmss}.md"
+            Title = "Export SV subscriber evidence bundle",
+            Filter = "ARSVIN evidence bundle (*.md)|*.md|Markdown report (*.md)|*.md|JSON evidence (*.json)|*.json",
+            DefaultExt = ".md",
+            AddExtension = true,
+            FileName = $"arsvin-subscriber-evidence-{DateTime.Now:yyyyMMdd-HHmmss}.md"
         };
 
         if (dialog.ShowDialog() != true)
             return;
 
-        var snapshots = _runtimeStreams.Values.Select(x => x.Snapshot()).OrderBy(x => x.AppId).ThenBy(x => x.SvId).ToArray();
-        var lines = new List<string>
+        try
         {
-            "# ARSVIN Subscriber Verification Report",
-            string.Empty,
-            $"Generated: {DateTimeOffset.Now:yyyy-MM-dd HH:mm:ss zzz}",
-            $"SCL: {(string.IsNullOrWhiteSpace(_selectedSclPath) ? "not loaded" : _selectedSclPath)}",
-            $"Adapter: {SelectedAdapter?.DisplayName ?? "-"}",
-            $"Filter: {(string.IsNullOrWhiteSpace(FilterText) ? "none" : FilterText)}",
-            string.Empty,
-            "> This report is receiver-side evidence from ARSVIN Subscriber. It is not a formal IEC 61850 conformance certificate.",
-            string.Empty,
-            "## Summary",
-            string.Empty,
-            $"- Raw frames: {Interlocked.Read(ref _rawFrames):N0}",
-            $"- SV frames: {Interlocked.Read(ref _svFrames):N0}",
-            $"- Streams: {snapshots.Length:N0}",
-            $"- Health: {HealthText}",
-            string.Empty,
-            "## Streams",
-            string.Empty,
-            "| Health | APPID | svID | Bound | nofASDU | fps | smpCnt | Quality | Issues |",
-            "|---|---:|---|---|---:|---:|---:|---|---:|"
-        };
+            var generatedAt = DateTimeOffset.Now;
+            var snapshots = _runtimeStreams.Values
+                .Select(runtime => runtime.Snapshot())
+                .OrderBy(snapshot => snapshot.AppId)
+                .ThenBy(snapshot => snapshot.SvId)
+                .ToArray();
+            var observations = _latestObservations.ToDictionary(
+                pair => pair.Key,
+                pair => pair.Value,
+                StringComparer.Ordinal);
+            var report = SvSubscriberReportBuilder.Build(new SvSubscriberReportContext
+            {
+                GeneratedAt = generatedAt,
+                CaptureStartedAt = _captureStarted,
+                Health = HealthText,
+                SclPath = _selectedSclPath,
+                Adapter = SelectedAdapter?.DisplayName ?? string.Empty,
+                Filter = string.IsNullOrWhiteSpace(FilterText) ? string.Empty : FilterText,
+                RawFrames = Interlocked.Read(ref _rawFrames),
+                SvFrames = Interlocked.Read(ref _svFrames),
+                ParseErrors = Interlocked.Read(ref _parseErrors),
+                DroppedByFilter = Interlocked.Read(ref _droppedByFilter),
+                Streams = snapshots,
+                Observations = observations
+            });
 
-        foreach (var stream in snapshots)
-        {
-            var issues = stream.SequenceGapCount + stream.DuplicateCount + stream.OutOfOrderCount + stream.PayloadIssueCount + stream.SclMismatchCount;
-            lines.Add($"| {stream.Health} | 0x{stream.AppId:X4} | {Escape(stream.SvId)} | {(stream.IsBoundToScl ? "yes" : "no")} | {stream.NofAsdu} | {stream.ActualFps:0.0} | {stream.LastSmpCnt?.ToString() ?? "-"} | {Escape(stream.QualitySummary)} | {issues} |");
-        }
+            var markdownPath = Path.ChangeExtension(dialog.FileName, ".md");
+            var jsonPath = Path.ChangeExtension(dialog.FileName, ".json");
+            var markdown = SvSubscriberEvidenceReportSerializer.ToMarkdown(report);
+            var json = SvSubscriberEvidenceReportSerializer.ToJson(report);
+            await Task.WhenAll(
+                File.WriteAllTextAsync(markdownPath, markdown),
+                File.WriteAllTextAsync(jsonPath, json)).ConfigureAwait(true);
 
-        lines.Add(string.Empty);
-        lines.Add("## Phasors");
-        lines.Add(string.Empty);
-        foreach (var stream in snapshots)
-        {
-            lines.Add($"### 0x{stream.AppId:X4} — {stream.SvId}");
-            lines.Add(string.Empty);
-            lines.Add($"- Cursor: {stream.CursorSummary}");
-            lines.Add("- Phasors:");
-            if (stream.Phasors.Count == 0)
-            {
-                lines.Add("  - Not enough decoded waveform samples or no SCL binding.");
-            }
-            else
-            {
-                foreach (var phasor in stream.Phasors)
-                    lines.Add($"  - {phasor.Channel}: RMS {phasor.Rms:0.###}, peak {phasor.Peak:0.###}, angle {phasor.AngleDegrees:0.0}°");
-            }
-            lines.Add(string.Empty);
+            StatusText = $"Evidence bundle exported: {Path.GetFileName(markdownPath)} + {Path.GetFileName(jsonPath)}";
         }
-
-        lines.Add("## Diagnostics");
-        lines.Add(string.Empty);
-        foreach (var stream in snapshots)
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidOperationException)
         {
-            lines.Add($"### 0x{stream.AppId:X4} — {stream.SvId}");
-            lines.Add(string.Empty);
-            if (stream.Diagnostics.Count == 0)
-            {
-                lines.Add("- No diagnostics.");
-            }
-            else
-            {
-                foreach (var diagnostic in stream.Diagnostics)
-                    lines.Add($"- {diagnostic}");
-            }
-            lines.Add(string.Empty);
+            StatusText = $"Evidence export failed: {ex.Message}";
         }
-
-        await File.WriteAllLinesAsync(dialog.FileName, lines).ConfigureAwait(true);
-        StatusText = $"Subscriber report exported: {dialog.FileName}";
     }
-
-    private static string Escape(string value)
-        => string.IsNullOrWhiteSpace(value) ? "-" : value.Replace("|", "\\|", StringComparison.Ordinal);
 }

From ef1d1ba11bc1502ad140be0171d10cb2b9cadfb2 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:38:40 +0700
Subject: [PATCH 23/39] Test SV evidence report JSON and Markdown contracts

---
 .../SvSubscriberEvidenceReportTests.cs        | 267 ++++++++++++++++++
 1 file changed, 267 insertions(+)
 create mode 100644 tests/ARSVIN.Tests/SampledValues/Profiles/SvSubscriberEvidenceReportTests.cs

diff --git a/tests/ARSVIN.Tests/SampledValues/Profiles/SvSubscriberEvidenceReportTests.cs b/tests/ARSVIN.Tests/SampledValues/Profiles/SvSubscriberEvidenceReportTests.cs
new file mode 100644
index 0000000..b9e426c
--- /dev/null
+++ b/tests/ARSVIN.Tests/SampledValues/Profiles/SvSubscriberEvidenceReportTests.cs
@@ -0,0 +1,267 @@
+using AR.Iec61850.SampledValues.Profiles;
+using AR.Iec61850.SampledValues.Reporting;
+using Xunit;
+
+namespace ARSVIN.Tests.SampledValues.Profiles;
+
+public sealed class SvSubscriberEvidenceReportTests
+{
+    [Fact]
+    public void JsonRoundTripPreservesEvidenceContract()
+    {
+        var report = CreateReport();
+
+        var json = SvSubscriberEvidenceReportSerializer.ToJson(report);
+        var restored = SvSubscriberEvidenceReportSerializer.FromJson(json);
+
+        Assert.Contains("arsvin.sv-subscriber-evidence/v1", json, StringComparison.Ordinal);
+        Assert.Contains("liveCapture", json, StringComparison.Ordinal);
+        Assert.Contains("wireObserved", json, StringComparison.Ordinal);
+        Assert.Contains("SV_CONFREV_MISMATCH", json, StringComparison.Ordinal);
+        Assert.Equal("abc1234", restored.Software.Commit);
+        var stream = Assert.Single(restored.Streams);
+        Assert.Equal(SvObservationInputKind.LiveCapture, Assert.Single(stream.Observation.InputKinds));
+        Assert.Equal(SvFactSource.WireObserved, stream.Observation.FactProvenance[nameof(SvObservedStreamFacts.AppId)]);
+        Assert.Equal("1 warning", stream.Observation.ConfigurationComparison?.Summary);
+        Assert.Equal(SvProfileConfidence.Likely, stream.Observation.ProfileDetection?.Confidence);
+    }
+
+    [Fact]
+    public void MarkdownIncludesProfileConfigurationProvenanceAndBuildIdentity()
+    {
+        var markdown = SvSubscriberEvidenceReportSerializer.ToMarkdown(CreateReport());
+
+        Assert.Contains("## Report metadata", markdown, StringComparison.Ordinal);
+        Assert.Contains("abc1234", markdown, StringComparison.Ordinal);
+        Assert.Contains("### Observed facts and provenance", markdown, StringComparison.Ordinal);
+        Assert.Contains("WireObserved", markdown, StringComparison.Ordinal);
+        Assert.Contains("### Expected SCL configuration", markdown, StringComparison.Ordinal);
+        Assert.Contains("### Configuration comparison", markdown, StringComparison.Ordinal);
+        Assert.Contains("SV_CONFREV_MISMATCH", markdown, StringComparison.Ordinal);
+        Assert.Contains("### Profile detection evidence", markdown, StringComparison.Ordinal);
+        Assert.Contains("Generic SCL-driven Layer-2 SV", markdown, StringComparison.Ordinal);
+        Assert.Contains("### Phasors", markdown, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ValidationRejectsDuplicateStreamKeys()
+    {
+        var report = CreateReport();
+        var duplicate = report with
+        {
+            Summary = report.Summary with { StreamCount = 2 },
+            Streams = [report.Streams[0], report.Streams[0]]
+        };
+
+        var exception = Assert.Throws<InvalidOperationException>(() =>
+            SvSubscriberEvidenceReportSerializer.ToJson(duplicate));
+
+        Assert.Contains("unique", exception.Message, StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static SvSubscriberEvidenceReport CreateReport()
+    {
+        var facts = new SvObservedStreamFacts
+        {
+            EtherType = 0x88BA,
+            AppId = 0x4001,
+            DestinationMac = "01:0C:CD:04:00:01",
+            VlanId = 100,
+            VlanPriority = 4,
+            SvId = "MU01SV01",
+            DataSetReference = "MU01MUnn/LLN0$PhsMeas",
+            ConfigurationRevision = 8,
+            AsduPerFrame = 1,
+            PayloadBytesPerAsdu = 8,
+            ObservedFramesPerSecond = 4000,
+            ObservedSamplesPerSecond = 4000,
+            ObservedCounterWrap = 4000,
+            CounterTransitions = new SvCounterTransitionSummary
+            {
+                SequentialCount = 7998,
+                GapCount = 1,
+                DuplicateCount = 0,
+                OutOfOrderOrResetCount = 0,
+                ConfirmedWrapCount = 1
+            },
+            DeclaredSampleRate = 80,
+            DeclaredSampleMode = 0,
+            DataSetSignature =
+            [
+                new SvDatasetElementSignature { BType = "INT32", Cdc = "SAV" },
+                new SvDatasetElementSignature { BType = "Quality", Cdc = "SAV", IsQuality = true }
+            ],
+            Provenance = new Dictionary<string, SvFactSource>(StringComparer.Ordinal)
+            {
+                [nameof(SvObservedStreamFacts.AppId)] = SvFactSource.WireObserved,
+                [nameof(SvObservedStreamFacts.ObservedFramesPerSecond)] = SvFactSource.CaptureCalculated,
+                [nameof(SvObservedStreamFacts.DataSetSignature)] = SvFactSource.SclDerived
+            },
+            ObservationCount = 8000,
+            FirstTimestamp = DateTimeOffset.UnixEpoch,
+            LastTimestamp = DateTimeOffset.UnixEpoch.AddSeconds(2)
+        };
+        var expected = new SvExpectedStreamConfiguration
+        {
+            EtherType = 0x88BA,
+            AppId = 0x4001,
+            DestinationMac = "01:0C:CD:04:00:01",
+            VlanId = 100,
+            VlanPriority = 4,
+            SvId = "MU01SV01",
+            DataSetReference = "MU01MUnn/LLN0$PhsMeas",
+            ConfigurationRevision = 7,
+            AsduPerFrame = 1,
+            PayloadBytesPerAsdu = 8,
+            DeclaredSampleRate = 80,
+            DeclaredSampleMode = 0,
+            DataSetSignature = facts.DataSetSignature
+        };
+        var comparison = new SvConfigurationComparisonResult
+        {
+            Mode = SvComparisonMode.Compatible,
+            Findings =
+            [
+                new SvConfigurationFinding(
+                    SvConfigurationFindingSeverity.Warning,
+                    "SV_CONFREV_MISMATCH",
+                    "confRev",
+                    "7",
+                    "8",
+                    "Configured confRev differs from observed traffic. Capture and decoding remain active.")
+            ]
+        };
+        var profile = new SvProfileDetectionResult
+        {
+            Profile = new SvProfileDefinition
+            {
+                Id = "generic-scl-layer2",
+                DisplayName = "Generic SCL-driven Layer-2 SV",
+                Family = "Generic Layer-2 SV",
+                SamplingBasis = SvSamplingBasis.Custom,
+                ExpectedEtherType = 0x88BA,
+                EvidenceStatus = SvProfileEvidenceStatus.ImplementedGeneric,
+                Sources =
+                [
+                    new SvProfileSourceEvidence(
+                        "arsvin-engine",
+                        "Generic Layer-2 SV mechanisms implemented by the shared engine.",
+                        SvProfileEvidenceStatus.ImplementedGeneric)
+                ]
+            },
+            RawConfidence = SvProfileConfidence.Likely,
+            ScorePercent = 100,
+            MatchedWeight = 5,
+            EvaluatedWeight = 5,
+            Evidence =
+            [
+                new SvProfileMatchEvidence(
+                    "EtherType",
+                    SvProfileEvidenceOutcome.Match,
+                    5,
+                    "0x88BA",
+                    "0x88BA",
+                    "EtherType matches the generic Layer-2 SV transport.")
+            ]
+        };
+
+        return new SvSubscriberEvidenceReport
+        {
+            GeneratedAt = DateTimeOffset.UnixEpoch.AddHours(1),
+            Software = new SvSubscriberSoftwareEvidence
+            {
+                Product = "ArSubsv",
+                Version = "0.4.0.0",
+                InformationalVersion = "0.4.0+abc1234",
+                Commit = "abc1234",
+                Repository = "https://github.com/masarray/arsvin"
+            },
+            Capture = new SvSubscriberCaptureEvidence
+            {
+                Source = "LiveCapture",
+                SclPath = "station.scd",
+                Adapter = "Ethernet 1",
+                Filter = "0x4001",
+                StartedAt = DateTimeOffset.UnixEpoch,
+                EndedAt = DateTimeOffset.UnixEpoch.AddSeconds(2),
+                DurationSeconds = 2,
+                RawFrames = 8000,
+                SvFrames = 8000
+            },
+            Summary = new SvSubscriberSummaryEvidence
+            {
+                Health = "WARN",
+                StreamCount = 1,
+                RuntimeIssueCount = 1,
+                ConfigurationFindingCount = 1
+            },
+            Streams =
+            [
+                new SvSubscriberStreamEvidence
+                {
+                    Key = "SV|4001|02:00:00:00:00:01|01:0C:CD:04:00:01|100|MU01SV01|MU01MUnn/LLN0$PhsMeas",
+                    Health = "WARN",
+                    HealthDetail = "Configuration differs from observed traffic.",
+                    Identity = new SvSubscriberStreamIdentityEvidence
+                    {
+                        AppId = 0x4001,
+                        SourceMac = "02:00:00:00:00:01",
+                        DestinationMac = "01:0C:CD:04:00:01",
+                        VlanId = 100,
+                        VlanPriority = 4,
+                        SvId = "MU01SV01",
+                        DataSetReference = "MU01MUnn/LLN0$PhsMeas",
+                        ConfigurationRevision = 8,
+                        AsduPerFrame = 1,
+                        LastSampleCount = 3999,
+                        DeclaredSampleRate = 80,
+                        DeclaredSampleMode = 0,
+                        SampleSynchronization = 2
+                    },
+                    Runtime = new SvSubscriberRuntimeEvidence
+                    {
+                        FrameCount = 8000,
+                        AsduCount = 8000,
+                        ActualFramesPerSecond = 4000,
+                        SequenceGapCount = 1,
+                        IsWaveformWindowReady = true,
+                        LayoutBinding = "SCL: MU01MUnn/LLN0$SV$MSVCB01",
+                        QualitySummary = "Quality good 8,000, non-zero 0",
+                        CursorSummary = "Cursor compare ready",
+                        LastSeen = "00:00:02.000"
+                    },
+                    Observation = new SvSubscriberObservationEvidence
+                    {
+                        InputKinds = [SvObservationInputKind.LiveCapture],
+                        LastInputKind = SvObservationInputKind.LiveCapture,
+                        IsBoundToScl = true,
+                        ControlBlockReference = "MU01MUnn/LLN0$SV$MSVCB01",
+                        WindowFrames = 8000,
+                        WindowSamples = 8000,
+                        WindowDurationSeconds = 2,
+                        FirstTimestamp = facts.FirstTimestamp,
+                        LastTimestamp = facts.LastTimestamp,
+                        Facts = facts,
+                        FactProvenance = facts.Provenance,
+                        ProfileDetection = profile,
+                        ExpectedConfiguration = expected,
+                        ConfigurationComparison = comparison,
+                        Diagnostics = ["Observed 1 forward sample-counter gap transition(s)."]
+                    },
+                    Phasors =
+                    [
+                        new SvSubscriberPhasorEvidence
+                        {
+                            Channel = "Ia",
+                            Kind = "Current",
+                            Rms = 1000,
+                            Peak = 1414.2,
+                            AngleDegrees = 0
+                        }
+                    ],
+                    Diagnostics = ["Configured confRev differs from observed traffic."]
+                }
+            ]
+        };
+    }
+}

From 8ce308525fd6a290c4dfd22b92773d0aa9936515 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:39:01 +0700
Subject: [PATCH 24/39] Embed CI source revision in application informational
 version

---
 Directory.Build.props | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Directory.Build.props b/Directory.Build.props
index b562075..d584239 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -9,6 +9,8 @@
     <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
     <RestoreLockedMode Condition="'$(CI)' == 'true'">true</RestoreLockedMode>
     <VersionPrefix>0.4.0</VersionPrefix>
+    <SourceRevisionId Condition="'$(SourceRevisionId)' == '' and '$(GITHUB_SHA)' != ''">$(GITHUB_SHA)</SourceRevisionId>
+    <IncludeSourceRevisionInInformationalVersion>true</IncludeSourceRevisionInInformationalVersion>
     <RepositoryUrl>https://github.com/masarray/arsvin</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
     <PackageLicenseExpression>GPL-3.0-or-later</PackageLicenseExpression>
@@ -16,4 +18,4 @@
     <Company>Ari Sulistiono</Company>
     <Copyright>Copyright © 2026 Ari Sulistiono</Copyright>
   </PropertyGroup>
-</Project>
\ No newline at end of file
+</Project>

From 22b62c74b4d851010f6b8f4e34ac9715376829fa Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:39:27 +0700
Subject: [PATCH 25/39] Document Subscriber evidence report contract

---
 docs/sv-profile-infrastructure.md | 32 +++++++++++++++++++++++++++----
 1 file changed, 28 insertions(+), 4 deletions(-)

diff --git a/docs/sv-profile-infrastructure.md b/docs/sv-profile-infrastructure.md
index 7eb0547..4685c5d 100644
--- a/docs/sv-profile-infrastructure.md
+++ b/docs/sv-profile-infrastructure.md
@@ -96,7 +96,7 @@ Before accepting an SCL candidate, the observation manager requires APPID, desti
 
 ## Subscriber compact state
 
-The selected stream now exposes one compact analysis strip instead of permanent large evidence cards:
+The selected stream exposes one compact analysis strip instead of permanent large evidence cards:
 
 ```text
 PROFILE       Generic Layer-2 SV
@@ -109,6 +109,29 @@ Detailed detector evidence, configuration findings, and observation diagnostics
 
 Waveform, phasor, and RMS collections use one reset notification per UI refresh. The visual layer withholds partial waveform windows until a complete two-cycle set is available, then retains the most recent complete window if the next refresh is incomplete. Compatible SCL warnings remain warnings and do not force the stream into a blocking `BAD` state.
 
+## Evidence report bundle
+
+Subscriber Export creates two files from the same report snapshot:
+
+- a Markdown engineering report for review and handover,
+- a JSON evidence document using schema `arsvin.sv-subscriber-evidence/v1` for automation, archival, and later comparison.
+
+Both files include:
+
+- generation time, product version, informational version, repository, and source commit,
+- live, PCAP, or mixed input provenance,
+- SCL path, adapter, user filter, capture duration, frame counts, parse errors, and filtered-frame counts,
+- per-stream identity, runtime integrity, quality, cursor state, waveform readiness, and phasors,
+- first and last observation timestamps, frame and sample counts, measured rates, sample-counter transitions, and wrap evidence,
+- every stable observed fact with its provenance (`WireObserved`, `CaptureCalculated`, `SclDerived`, or trusted context),
+- profile definition, evidence maturity, confidence, weighted match evidence, and source metadata,
+- expected SCL configuration, comparison mode, exact/warning/error summary, and field-level findings,
+- runtime and observation diagnostics.
+
+Unknown values remain explicit `null` values in JSON and `unknown` values in Markdown. They are not silently removed or interpreted as matches. The report schema validates generation time, product identity, stream count, and unique stream keys before serialization.
+
+GitHub Actions injects `GITHUB_SHA` into `SourceRevisionId`; the .NET informational version therefore carries the build commit for release and CI artifacts. Local builds without source revision metadata report the commit as `unknown` rather than inventing one.
+
 ## Current integration boundary
 
 `SvStreamObservationManager` and Subscriber now:
@@ -122,10 +145,11 @@ Waveform, phasor, and RMS collections use one reset notification per UI refresh.
 - run Compatible comparison by default, with Strict available per observation call;
 - evaluate the built-in evidence-aware profile catalog;
 - expose compact profile, confidence, SCL match, and observation-window state;
-- expose detailed evidence only on demand; and
-- keep full-window waveform, phasor, and RMS visualization stable through bulk collection refreshes.
+- expose detailed evidence only on demand;
+- keep full-window waveform, phasor, and RMS visualization stable through bulk collection refreshes; and
+- serialize the same observation, profile, configuration, provenance, source, and build evidence into paired Markdown and JSON reports.
 
 ## Next integration
 
 1. Add profile-specific definitions only after source review and deterministic evidence.
-2. Serialize profile, configuration, provenance, observation-window, and source evidence into Subscriber reports.
+2. Add report-to-report comparison after the evidence schema has real capture history and compatibility requirements.

From ff2282a8f444933bd5f2651432c75818b5dc0774 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 03:41:36 +0700
Subject: [PATCH 26/39] Clarify unknown values in SV report schema

---
 docs/sv-profile-infrastructure.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/sv-profile-infrastructure.md b/docs/sv-profile-infrastructure.md
index 4685c5d..441a409 100644
--- a/docs/sv-profile-infrastructure.md
+++ b/docs/sv-profile-infrastructure.md
@@ -128,7 +128,7 @@ Both files include:
 - expected SCL configuration, comparison mode, exact/warning/error summary, and field-level findings,
 - runtime and observation diagnostics.
 
-Unknown values remain explicit `null` values in JSON and `unknown` values in Markdown. They are not silently removed or interpreted as matches. The report schema validates generation time, product identity, stream count, and unique stream keys before serialization.
+Unknown nullable values remain explicit `null`; unknown text fields remain empty strings in JSON and render as `unknown` in Markdown. They are not silently removed or interpreted as matches. The report schema validates generation time, product identity, stream count, and unique stream keys before serialization.
 
 GitHub Actions injects `GITHUB_SHA` into `SourceRevisionId`; the .NET informational version therefore carries the build commit for release and CI artifacts. Local builds without source revision metadata report the commit as `unknown` rather than inventing one.
 

From 4b1c68271152dd5f69fed5a5ad70917b8f4ac192 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 04:37:35 +0700
Subject: [PATCH 27/39] Add P3F evidence report comparison engine

---
 .../SvSubscriberEvidenceComparison.cs         | 827 ++++++++++++++++++
 1 file changed, 827 insertions(+)
 create mode 100644 src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceComparison.cs

diff --git a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceComparison.cs b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceComparison.cs
new file mode 100644
index 0000000..2292be7
--- /dev/null
+++ b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceComparison.cs
@@ -0,0 +1,827 @@
+using System.Globalization;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using AR.Iec61850.SampledValues.Profiles;
+
+namespace AR.Iec61850.SampledValues.Reporting;
+
+public enum SvEvidenceChangeKind
+{
+    Added,
+    Removed,
+    Changed,
+    Unchanged
+}
+
+public enum SvEvidenceChangeSeverity
+{
+    Info,
+    Warning,
+    Error
+}
+
+public sealed record SvSubscriberEvidenceComparison
+{
+    public const string CurrentSchemaVersion = "arsvin.sv-subscriber-evidence-comparison/v1";
+
+    public string SchemaVersion { get; init; } = CurrentSchemaVersion;
+    public DateTimeOffset GeneratedAt { get; init; }
+    public SvEvidenceReportReference Baseline { get; init; } = new();
+    public SvEvidenceReportReference Candidate { get; init; } = new();
+    public SvEvidenceComparisonSummary Summary { get; init; } = new();
+    public IReadOnlyList<SvEvidenceFieldChange> ReportChanges { get; init; }
+        = Array.Empty<SvEvidenceFieldChange>();
+    public IReadOnlyList<SvSubscriberStreamComparison> Streams { get; init; }
+        = Array.Empty<SvSubscriberStreamComparison>();
+
+    public void Validate()
+    {
+        if (!string.Equals(SchemaVersion, CurrentSchemaVersion, StringComparison.Ordinal))
+            throw new InvalidOperationException($"Unsupported SV comparison schema '{SchemaVersion}'.");
+        if (GeneratedAt == default)
+            throw new InvalidOperationException("SV comparison requires a generation timestamp.");
+        if (string.IsNullOrWhiteSpace(Baseline.SchemaVersion) || string.IsNullOrWhiteSpace(Candidate.SchemaVersion))
+            throw new InvalidOperationException("SV comparison requires baseline and candidate schema metadata.");
+        if (Streams.Select(stream => stream.ComparisonKey).Distinct(StringComparer.Ordinal).Count() != Streams.Count)
+            throw new InvalidOperationException("SV comparison stream keys must be unique.");
+
+        var classified = Summary.AddedStreamCount + Summary.RemovedStreamCount +
+                         Summary.ChangedStreamCount + Summary.UnchangedStreamCount;
+        if (classified != Streams.Count)
+            throw new InvalidOperationException("SV comparison summary does not match the stream comparison collection.");
+
+        var allChanges = ReportChanges.Concat(Streams.SelectMany(stream => stream.Changes)).ToArray();
+        if (Summary.InfoChangeCount != allChanges.Count(change => change.Severity == SvEvidenceChangeSeverity.Info) ||
+            Summary.WarningChangeCount != allChanges.Count(change => change.Severity == SvEvidenceChangeSeverity.Warning) ||
+            Summary.ErrorChangeCount != allChanges.Count(change => change.Severity == SvEvidenceChangeSeverity.Error))
+        {
+            throw new InvalidOperationException("SV comparison severity totals do not match the comparison evidence.");
+        }
+    }
+}
+
+public sealed record SvEvidenceReportReference
+{
+    public string SchemaVersion { get; init; } = string.Empty;
+    public DateTimeOffset GeneratedAt { get; init; }
+    public string Product { get; init; } = string.Empty;
+    public string Version { get; init; } = string.Empty;
+    public string Commit { get; init; } = string.Empty;
+    public string CaptureSource { get; init; } = string.Empty;
+    public string Health { get; init; } = string.Empty;
+    public int StreamCount { get; init; }
+}
+
+public sealed record SvEvidenceComparisonSummary
+{
+    public int BaselineStreamCount { get; init; }
+    public int CandidateStreamCount { get; init; }
+    public int AddedStreamCount { get; init; }
+    public int RemovedStreamCount { get; init; }
+    public int ChangedStreamCount { get; init; }
+    public int UnchangedStreamCount { get; init; }
+    public int InfoChangeCount { get; init; }
+    public int WarningChangeCount { get; init; }
+    public int ErrorChangeCount { get; init; }
+    public bool HasRegressions => WarningChangeCount > 0 || ErrorChangeCount > 0;
+}
+
+public sealed record SvSubscriberStreamComparison
+{
+    public string ComparisonKey { get; init; } = string.Empty;
+    public SvEvidenceChangeKind Kind { get; init; }
+    public SvEvidenceChangeSeverity Severity { get; init; }
+    public string BaselineStreamKey { get; init; } = string.Empty;
+    public string CandidateStreamKey { get; init; } = string.Empty;
+    public SvSubscriberStreamIdentityEvidence Identity { get; init; } = new();
+    public IReadOnlyList<SvEvidenceFieldChange> Changes { get; init; }
+        = Array.Empty<SvEvidenceFieldChange>();
+}
+
+public sealed record SvEvidenceFieldChange
+{
+    public string Category { get; init; } = string.Empty;
+    public string Field { get; init; } = string.Empty;
+    public SvEvidenceChangeSeverity Severity { get; init; }
+    public string Baseline { get; init; } = string.Empty;
+    public string Candidate { get; init; } = string.Empty;
+    public string Message { get; init; } = string.Empty;
+}
+
+public sealed class SvSubscriberEvidenceComparator
+{
+    private const double RateTolerancePercent = 1.0;
+
+    public SvSubscriberEvidenceComparison Compare(
+        SvSubscriberEvidenceReport baseline,
+        SvSubscriberEvidenceReport candidate,
+        DateTimeOffset generatedAt)
+    {
+        ArgumentNullException.ThrowIfNull(baseline);
+        ArgumentNullException.ThrowIfNull(candidate);
+        baseline.Validate();
+        candidate.Validate();
+        if (generatedAt == default)
+            throw new ArgumentException("Comparison requires a generation timestamp.", nameof(generatedAt));
+
+        var reportChanges = CompareReportMetadata(baseline, candidate);
+        var streamComparisons = CompareStreams(baseline.Streams, candidate.Streams);
+        var allChanges = reportChanges.Concat(streamComparisons.SelectMany(stream => stream.Changes)).ToArray();
+
+        var result = new SvSubscriberEvidenceComparison
+        {
+            GeneratedAt = generatedAt,
+            Baseline = ToReference(baseline),
+            Candidate = ToReference(candidate),
+            Summary = new SvEvidenceComparisonSummary
+            {
+                BaselineStreamCount = baseline.Streams.Count,
+                CandidateStreamCount = candidate.Streams.Count,
+                AddedStreamCount = streamComparisons.Count(stream => stream.Kind == SvEvidenceChangeKind.Added),
+                RemovedStreamCount = streamComparisons.Count(stream => stream.Kind == SvEvidenceChangeKind.Removed),
+                ChangedStreamCount = streamComparisons.Count(stream => stream.Kind == SvEvidenceChangeKind.Changed),
+                UnchangedStreamCount = streamComparisons.Count(stream => stream.Kind == SvEvidenceChangeKind.Unchanged),
+                InfoChangeCount = allChanges.Count(change => change.Severity == SvEvidenceChangeSeverity.Info),
+                WarningChangeCount = allChanges.Count(change => change.Severity == SvEvidenceChangeSeverity.Warning),
+                ErrorChangeCount = allChanges.Count(change => change.Severity == SvEvidenceChangeSeverity.Error)
+            },
+            ReportChanges = reportChanges,
+            Streams = streamComparisons
+        };
+        result.Validate();
+        return result;
+    }
+
+    private static IReadOnlyList<SvEvidenceFieldChange> CompareReportMetadata(
+        SvSubscriberEvidenceReport baseline,
+        SvSubscriberEvidenceReport candidate)
+    {
+        var changes = new List<SvEvidenceFieldChange>();
+        AddTextChange(changes, "Report", "Schema version", baseline.SchemaVersion, candidate.SchemaVersion,
+            SvEvidenceChangeSeverity.Error, "Evidence schema changed; compatibility must be reviewed.");
+        AddTextChange(changes, "Software", "Product", baseline.Software.Product, candidate.Software.Product,
+            SvEvidenceChangeSeverity.Warning, "Product identity changed between reports.");
+        AddTextChange(changes, "Software", "Version", baseline.Software.Version, candidate.Software.Version,
+            SvEvidenceChangeSeverity.Info, "Software version changed.");
+        AddTextChange(changes, "Software", "Commit", baseline.Software.Commit, candidate.Software.Commit,
+            SvEvidenceChangeSeverity.Info, "Build commit changed.");
+        AddTextChange(changes, "Capture", "Source", baseline.Capture.Source, candidate.Capture.Source,
+            SvEvidenceChangeSeverity.Info, "Capture source changed.");
+        AddTextChange(changes, "Capture", "SCL path", baseline.Capture.SclPath, candidate.Capture.SclPath,
+            SvEvidenceChangeSeverity.Info, "SCL source changed.");
+        AddHealthChange(changes, "Report", baseline.Summary.Health, candidate.Summary.Health);
+        return changes;
+    }
+
+    private static IReadOnlyList<SvSubscriberStreamComparison> CompareStreams(
+        IReadOnlyList<SvSubscriberStreamEvidence> baselineStreams,
+        IReadOnlyList<SvSubscriberStreamEvidence> candidateStreams)
+    {
+        var result = new List<SvSubscriberStreamComparison>();
+        var candidateByKey = candidateStreams.ToDictionary(stream => stream.Key, StringComparer.Ordinal);
+        var usedCandidateKeys = new HashSet<string>(StringComparer.Ordinal);
+        var unmatchedBaseline = new List<SvSubscriberStreamEvidence>();
+
+        foreach (var baseline in baselineStreams)
+        {
+            if (candidateByKey.TryGetValue(baseline.Key, out var exact))
+            {
+                result.Add(ComparePair(baseline, exact));
+                usedCandidateKeys.Add(exact.Key);
+            }
+            else
+            {
+                unmatchedBaseline.Add(baseline);
+            }
+        }
+
+        var unmatchedCandidate = candidateStreams
+            .Where(stream => !usedCandidateKeys.Contains(stream.Key))
+            .ToArray();
+        var baselineLogicalGroups = unmatchedBaseline.GroupBy(LogicalKey, StringComparer.Ordinal)
+            .ToDictionary(group => group.Key, group => group.ToArray(), StringComparer.Ordinal);
+        var candidateLogicalGroups = unmatchedCandidate.GroupBy(LogicalKey, StringComparer.Ordinal)
+            .ToDictionary(group => group.Key, group => group.ToArray(), StringComparer.Ordinal);
+
+        foreach (var baseline in unmatchedBaseline)
+        {
+            var logicalKey = LogicalKey(baseline);
+            if (baselineLogicalGroups[logicalKey].Length == 1 &&
+                candidateLogicalGroups.TryGetValue(logicalKey, out var candidates) &&
+                candidates.Length == 1 &&
+                usedCandidateKeys.Add(candidates[0].Key))
+            {
+                result.Add(ComparePair(baseline, candidates[0]));
+                continue;
+            }
+
+            result.Add(Removed(baseline));
+        }
+
+        foreach (var candidate in candidateStreams.Where(stream => !usedCandidateKeys.Contains(stream.Key)))
+            result.Add(Added(candidate));
+
+        return result
+            .OrderBy(stream => stream.Identity.AppId)
+            .ThenBy(stream => stream.Identity.SvId, StringComparer.Ordinal)
+            .ThenBy(stream => stream.Kind)
+            .ToArray();
+    }
+
+    private static SvSubscriberStreamComparison ComparePair(
+        SvSubscriberStreamEvidence baseline,
+        SvSubscriberStreamEvidence candidate)
+    {
+        var changes = new List<SvEvidenceFieldChange>();
+        AddHealthChange(changes, "Stream", baseline.Health, candidate.Health);
+        AddTextChange(changes, "Identity", "Source MAC", baseline.Identity.SourceMac, candidate.Identity.SourceMac,
+            SvEvidenceChangeSeverity.Info, "Publisher source MAC changed while the logical stream identity remained stable.");
+        AddNullableChange(changes, "Identity", "confRev", baseline.Identity.ConfigurationRevision,
+            candidate.Identity.ConfigurationRevision, SvEvidenceChangeSeverity.Warning, "Configuration revision changed.");
+        AddNullableChange(changes, "Identity", "ASDU per frame", baseline.Identity.AsduPerFrame,
+            candidate.Identity.AsduPerFrame, SvEvidenceChangeSeverity.Warning, "ASDU packing changed.");
+        AddNullableChange(changes, "Identity", "Declared sample rate", baseline.Identity.DeclaredSampleRate,
+            candidate.Identity.DeclaredSampleRate, SvEvidenceChangeSeverity.Warning, "Declared sample rate changed.");
+        AddNullableChange(changes, "Identity", "Declared sample mode", baseline.Identity.DeclaredSampleMode,
+            candidate.Identity.DeclaredSampleMode, SvEvidenceChangeSeverity.Warning, "Declared sample mode changed.");
+
+        CompareIssueCounter(changes, "Sequence gaps", baseline.Runtime.SequenceGapCount, candidate.Runtime.SequenceGapCount,
+            SvEvidenceChangeSeverity.Warning);
+        CompareIssueCounter(changes, "Duplicates", baseline.Runtime.DuplicateCount, candidate.Runtime.DuplicateCount,
+            SvEvidenceChangeSeverity.Warning);
+        CompareIssueCounter(changes, "Out-of-order", baseline.Runtime.OutOfOrderCount, candidate.Runtime.OutOfOrderCount,
+            SvEvidenceChangeSeverity.Error);
+        CompareIssueCounter(changes, "Payload issues", baseline.Runtime.PayloadIssueCount, candidate.Runtime.PayloadIssueCount,
+            SvEvidenceChangeSeverity.Error);
+        CompareIssueCounter(changes, "SCL mismatches", baseline.Runtime.SclMismatchCount, candidate.Runtime.SclMismatchCount,
+            SvEvidenceChangeSeverity.Warning);
+        CompareRate(changes, "Observed frames/s", baseline.Observation.Facts.ObservedFramesPerSecond,
+            candidate.Observation.Facts.ObservedFramesPerSecond);
+        CompareRate(changes, "Observed samples/s", baseline.Observation.Facts.ObservedSamplesPerSecond,
+            candidate.Observation.Facts.ObservedSamplesPerSecond);
+        CompareWindow(changes, baseline.Observation, candidate.Observation);
+        CompareBinding(changes, baseline.Observation, candidate.Observation);
+        CompareProfile(changes, baseline.Observation.ProfileDetection, candidate.Observation.ProfileDetection);
+        CompareConfiguration(changes, baseline.Observation.ConfigurationComparison,
+            candidate.Observation.ConfigurationComparison);
+        CompareFacts(changes, baseline.Observation.Facts, candidate.Observation.Facts);
+        CompareDiagnostics(changes, baseline.Diagnostics.Concat(baseline.Observation.Diagnostics),
+            candidate.Diagnostics.Concat(candidate.Observation.Diagnostics));
+
+        var kind = changes.Count == 0 ? SvEvidenceChangeKind.Unchanged : SvEvidenceChangeKind.Changed;
+        return new SvSubscriberStreamComparison
+        {
+            ComparisonKey = LogicalKey(candidate),
+            Kind = kind,
+            Severity = MaximumSeverity(changes),
+            BaselineStreamKey = baseline.Key,
+            CandidateStreamKey = candidate.Key,
+            Identity = candidate.Identity,
+            Changes = changes
+        };
+    }
+
+    private static void CompareWindow(
+        ICollection<SvEvidenceFieldChange> changes,
+        SvSubscriberObservationEvidence baseline,
+        SvSubscriberObservationEvidence candidate)
+    {
+        if (baseline.WindowSamples != candidate.WindowSamples)
+        {
+            var severity = baseline.WindowSamples > 0 && candidate.WindowSamples < baseline.WindowSamples / 2
+                ? SvEvidenceChangeSeverity.Warning
+                : SvEvidenceChangeSeverity.Info;
+            Add(changes, "Observation window", "Samples", severity,
+                baseline.WindowSamples.ToString(CultureInfo.InvariantCulture),
+                candidate.WindowSamples.ToString(CultureInfo.InvariantCulture),
+                severity == SvEvidenceChangeSeverity.Warning
+                    ? "Candidate observation window contains materially fewer samples."
+                    : "Observation-window sample count changed.");
+        }
+
+        if (!ApproximatelyEqual(baseline.WindowDurationSeconds, candidate.WindowDurationSeconds, 0.01))
+        {
+            Add(changes, "Observation window", "Duration", SvEvidenceChangeSeverity.Info,
+                Number(baseline.WindowDurationSeconds), Number(candidate.WindowDurationSeconds),
+                "Observation-window duration changed.");
+        }
+    }
+
+    private static void CompareBinding(
+        ICollection<SvEvidenceFieldChange> changes,
+        SvSubscriberObservationEvidence baseline,
+        SvSubscriberObservationEvidence candidate)
+    {
+        if (baseline.IsBoundToScl != candidate.IsBoundToScl)
+        {
+            var severity = baseline.IsBoundToScl && !candidate.IsBoundToScl
+                ? SvEvidenceChangeSeverity.Warning
+                : SvEvidenceChangeSeverity.Info;
+            Add(changes, "SCL", "Binding", severity,
+                baseline.IsBoundToScl ? "bound" : "not bound",
+                candidate.IsBoundToScl ? "bound" : "not bound",
+                severity == SvEvidenceChangeSeverity.Warning
+                    ? "Candidate stream lost its SCL binding."
+                    : "Candidate stream gained an SCL binding.");
+        }
+
+        AddTextChange(changes, "SCL", "Control block", baseline.ControlBlockReference,
+            candidate.ControlBlockReference, SvEvidenceChangeSeverity.Info,
+            "SCL control-block reference changed.");
+    }
+
+    private static void CompareProfile(
+        ICollection<SvEvidenceFieldChange> changes,
+        SvProfileDetectionResult? baseline,
+        SvProfileDetectionResult? candidate)
+    {
+        AddTextChange(changes, "Profile", "Profile ID", baseline?.Profile.Id ?? string.Empty,
+            candidate?.Profile.Id ?? string.Empty, SvEvidenceChangeSeverity.Warning,
+            "Detected profile changed.");
+
+        var baselineConfidence = baseline?.Confidence ?? SvProfileConfidence.Unknown;
+        var candidateConfidence = candidate?.Confidence ?? SvProfileConfidence.Unknown;
+        if (baselineConfidence == candidateConfidence)
+            return;
+
+        var severity = candidateConfidence == SvProfileConfidence.Conflict
+            ? SvEvidenceChangeSeverity.Error
+            : ConfidenceRank(candidateConfidence) < ConfidenceRank(baselineConfidence)
+                ? SvEvidenceChangeSeverity.Warning
+                : SvEvidenceChangeSeverity.Info;
+        Add(changes, "Profile", "Confidence", severity, baselineConfidence.ToString(),
+            candidateConfidence.ToString(),
+            severity == SvEvidenceChangeSeverity.Error
+                ? "Candidate profile classification is conflicting."
+                : severity == SvEvidenceChangeSeverity.Warning
+                    ? "Candidate profile confidence decreased."
+                    : "Candidate profile confidence improved.");
+    }
+
+    private static void CompareConfiguration(
+        ICollection<SvEvidenceFieldChange> changes,
+        SvConfigurationComparisonResult? baseline,
+        SvConfigurationComparisonResult? candidate)
+    {
+        var baselineSummary = baseline?.Summary ?? "Not configured";
+        var candidateSummary = candidate?.Summary ?? "Not configured";
+        if (string.Equals(baselineSummary, candidateSummary, StringComparison.Ordinal) &&
+            baseline?.Mode == candidate?.Mode)
+            return;
+
+        var introducedBlocking = candidate?.HasBlockingErrors == true && baseline?.HasBlockingErrors != true;
+        var warningIncrease = (candidate?.WarningCount ?? 0) > (baseline?.WarningCount ?? 0);
+        var severity = introducedBlocking
+            ? SvEvidenceChangeSeverity.Error
+            : warningIncrease || (baseline is not null && candidate is null)
+                ? SvEvidenceChangeSeverity.Warning
+                : SvEvidenceChangeSeverity.Info;
+        Add(changes, "Configuration", "Comparison", severity, baselineSummary, candidateSummary,
+            introducedBlocking
+                ? "Candidate introduced blocking configuration errors."
+                : severity == SvEvidenceChangeSeverity.Warning
+                    ? "Candidate configuration evidence regressed."
+                    : "Configuration comparison result changed.");
+    }
+
+    private static void CompareFacts(
+        ICollection<SvEvidenceFieldChange> changes,
+        SvObservedStreamFacts baseline,
+        SvObservedStreamFacts candidate)
+    {
+        AddNullableChange(changes, "Observed facts", "Payload bytes per ASDU",
+            baseline.PayloadBytesPerAsdu, candidate.PayloadBytesPerAsdu,
+            SvEvidenceChangeSeverity.Warning, "Observed payload length changed.");
+        AddNullableChange(changes, "Observed facts", "Counter wrap", baseline.ObservedCounterWrap,
+            candidate.ObservedCounterWrap, SvEvidenceChangeSeverity.Warning,
+            "Observed sample-counter wrap changed.");
+        AddNullableChange(changes, "Observed facts", "Nominal frequency", baseline.NominalFrequencyHz,
+            candidate.NominalFrequencyHz, SvEvidenceChangeSeverity.Warning,
+            "Nominal-frequency context changed.");
+
+        var baselineSignature = Signature(baseline.DataSetSignature);
+        var candidateSignature = Signature(candidate.DataSetSignature);
+        AddTextChange(changes, "Observed facts", "Dataset signature", baselineSignature,
+            candidateSignature, SvEvidenceChangeSeverity.Error,
+            "Observed dataset element order or types changed.");
+
+        var provenanceKeys = baseline.Provenance.Keys.Concat(candidate.Provenance.Keys)
+            .Distinct(StringComparer.Ordinal);
+        foreach (var key in provenanceKeys)
+        {
+            var baselineSource = baseline.Provenance.TryGetValue(key, out var b) ? b : SvFactSource.Unknown;
+            var candidateSource = candidate.Provenance.TryGetValue(key, out var c) ? c : SvFactSource.Unknown;
+            if (baselineSource != candidateSource)
+            {
+                Add(changes, "Provenance", key, SvEvidenceChangeSeverity.Info,
+                    baselineSource.ToString(), candidateSource.ToString(),
+                    "Fact provenance changed.");
+            }
+        }
+    }
+
+    private static void CompareDiagnostics(
+        ICollection<SvEvidenceFieldChange> changes,
+        IEnumerable<string> baseline,
+        IEnumerable<string> candidate)
+    {
+        var baselineSet = baseline.Where(item => !string.IsNullOrWhiteSpace(item))
+            .ToHashSet(StringComparer.Ordinal);
+        var candidateSet = candidate.Where(item => !string.IsNullOrWhiteSpace(item))
+            .ToHashSet(StringComparer.Ordinal);
+
+        foreach (var added in candidateSet.Except(baselineSet, StringComparer.Ordinal).Order(StringComparer.Ordinal))
+            Add(changes, "Diagnostics", "Added", SvEvidenceChangeSeverity.Warning, "-", added,
+                "Candidate introduced a diagnostic.");
+        foreach (var removed in baselineSet.Except(candidateSet, StringComparer.Ordinal).Order(StringComparer.Ordinal))
+            Add(changes, "Diagnostics", "Resolved", SvEvidenceChangeSeverity.Info, removed, "-",
+                "A baseline diagnostic is no longer present.");
+    }
+
+    private static void CompareIssueCounter(
+        ICollection<SvEvidenceFieldChange> changes,
+        string field,
+        int baseline,
+        int candidate,
+        SvEvidenceChangeSeverity regressionSeverity)
+    {
+        if (baseline == candidate)
+            return;
+        var severity = candidate > baseline ? regressionSeverity : SvEvidenceChangeSeverity.Info;
+        Add(changes, "Runtime integrity", field, severity,
+            baseline.ToString(CultureInfo.InvariantCulture),
+            candidate.ToString(CultureInfo.InvariantCulture),
+            candidate > baseline ? $"Candidate {field.ToLowerInvariant()} increased." : $"Candidate {field.ToLowerInvariant()} decreased.");
+    }
+
+    private static void CompareRate(
+        ICollection<SvEvidenceFieldChange> changes,
+        string field,
+        double? baseline,
+        double? candidate)
+    {
+        if (!baseline.HasValue && !candidate.HasValue)
+            return;
+        if (!baseline.HasValue || !candidate.HasValue)
+        {
+            Add(changes, "Observed rate", field, SvEvidenceChangeSeverity.Warning,
+                Number(baseline), Number(candidate), "Observed rate availability changed.");
+            return;
+        }
+        if (ApproximatelyEqual(baseline.Value, candidate.Value, RateTolerancePercent))
+            return;
+
+        Add(changes, "Observed rate", field, SvEvidenceChangeSeverity.Warning,
+            Number(baseline), Number(candidate),
+            $"Observed rate changed by more than {RateTolerancePercent:0.###}%.");
+    }
+
+    private static void AddHealthChange(
+        ICollection<SvEvidenceFieldChange> changes,
+        string category,
+        string baseline,
+        string candidate)
+    {
+        if (string.Equals(baseline, candidate, StringComparison.OrdinalIgnoreCase))
+            return;
+        var severity = HealthRank(candidate) > HealthRank(baseline)
+            ? HealthRank(candidate) >= 2 ? SvEvidenceChangeSeverity.Error : SvEvidenceChangeSeverity.Warning
+            : SvEvidenceChangeSeverity.Info;
+        Add(changes, category, "Health", severity, baseline, candidate,
+            severity == SvEvidenceChangeSeverity.Info ? "Health improved or changed without regression." : "Health regressed.");
+    }
+
+    private static void AddTextChange(
+        ICollection<SvEvidenceFieldChange> changes,
+        string category,
+        string field,
+        string baseline,
+        string candidate,
+        SvEvidenceChangeSeverity severity,
+        string message)
+    {
+        if (!string.Equals(baseline ?? string.Empty, candidate ?? string.Empty, StringComparison.Ordinal))
+            Add(changes, category, field, severity, Empty(baseline), Empty(candidate), message);
+    }
+
+    private static void AddNullableChange<T>(
+        ICollection<SvEvidenceFieldChange> changes,
+        string category,
+        string field,
+        T? baseline,
+        T? candidate,
+        SvEvidenceChangeSeverity severity,
+        string message)
+        where T : struct, IEquatable<T>
+    {
+        if (!Nullable.Equals(baseline, candidate))
+            Add(changes, category, field, severity, Value(baseline), Value(candidate), message);
+    }
+
+    private static void Add(
+        ICollection<SvEvidenceFieldChange> changes,
+        string category,
+        string field,
+        SvEvidenceChangeSeverity severity,
+        string baseline,
+        string candidate,
+        string message)
+        => changes.Add(new SvEvidenceFieldChange
+        {
+            Category = category,
+            Field = field,
+            Severity = severity,
+            Baseline = baseline,
+            Candidate = candidate,
+            Message = message
+        });
+
+    private static SvSubscriberStreamComparison Added(SvSubscriberStreamEvidence stream)
+        => new()
+        {
+            ComparisonKey = LogicalKey(stream),
+            Kind = SvEvidenceChangeKind.Added,
+            Severity = SvEvidenceChangeSeverity.Info,
+            CandidateStreamKey = stream.Key,
+            Identity = stream.Identity,
+            Changes =
+            [
+                new SvEvidenceFieldChange
+                {
+                    Category = "Stream",
+                    Field = "Presence",
+                    Severity = SvEvidenceChangeSeverity.Info,
+                    Baseline = "absent",
+                    Candidate = "present",
+                    Message = "Candidate contains a new logical stream."
+                }
+            ]
+        };
+
+    private static SvSubscriberStreamComparison Removed(SvSubscriberStreamEvidence stream)
+        => new()
+        {
+            ComparisonKey = LogicalKey(stream),
+            Kind = SvEvidenceChangeKind.Removed,
+            Severity = SvEvidenceChangeSeverity.Error,
+            BaselineStreamKey = stream.Key,
+            Identity = stream.Identity,
+            Changes =
+            [
+                new SvEvidenceFieldChange
+                {
+                    Category = "Stream",
+                    Field = "Presence",
+                    Severity = SvEvidenceChangeSeverity.Error,
+                    Baseline = "present",
+                    Candidate = "absent",
+                    Message = "Candidate no longer contains this logical stream."
+                }
+            ]
+        };
+
+    private static SvEvidenceReportReference ToReference(SvSubscriberEvidenceReport report)
+        => new()
+        {
+            SchemaVersion = report.SchemaVersion,
+            GeneratedAt = report.GeneratedAt,
+            Product = report.Software.Product,
+            Version = report.Software.Version,
+            Commit = report.Software.Commit,
+            CaptureSource = report.Capture.Source,
+            Health = report.Summary.Health,
+            StreamCount = report.Streams.Count
+        };
+
+    private static SvEvidenceChangeSeverity MaximumSeverity(IEnumerable<SvEvidenceFieldChange> changes)
+        => changes.Select(change => change.Severity).DefaultIfEmpty(SvEvidenceChangeSeverity.Info).Max();
+
+    private static string LogicalKey(SvSubscriberStreamEvidence stream)
+    {
+        var identity = stream.Identity;
+        var vlan = identity.VlanId?.ToString(CultureInfo.InvariantCulture) ?? "-";
+        return $"SV|{identity.AppId:X4}|{NormalizeMac(identity.DestinationMac)}|{vlan}|" +
+               $"{NormalizeIdentifier(identity.SvId)}|{NormalizeIdentifier(identity.DataSetReference)}";
+    }
+
+    private static string NormalizeMac(string value)
+        => new((value ?? string.Empty).Where(Uri.IsHexDigit).Select(char.ToUpperInvariant).ToArray());
+
+    private static string NormalizeIdentifier(string value)
+        => (value ?? string.Empty).Trim().ToUpperInvariant();
+
+    private static int HealthRank(string value)
+        => (value ?? string.Empty).Trim().ToUpperInvariant() switch
+        {
+            "GOOD" => 0,
+            "IDLE" => 0,
+            "LISTENING" => 0,
+            "WARN" => 1,
+            "BAD" => 2,
+            "ERROR" => 3,
+            _ => 1
+        };
+
+    private static int ConfidenceRank(SvProfileConfidence value)
+        => value switch
+        {
+            SvProfileConfidence.Confirmed => 4,
+            SvProfileConfidence.Likely => 3,
+            SvProfileConfidence.Possible => 2,
+            SvProfileConfidence.Unknown => 1,
+            SvProfileConfidence.Conflict => 0,
+            _ => 0
+        };
+
+    private static bool ApproximatelyEqual(double baseline, double candidate, double tolerancePercent)
+    {
+        if (baseline == 0)
+            return candidate == 0;
+        return Math.Abs(candidate - baseline) / Math.Abs(baseline) * 100 <= tolerancePercent;
+    }
+
+    private static string Signature(IReadOnlyList<SvDatasetElementSignature> signature)
+        => signature.Count == 0
+            ? string.Empty
+            : string.Join(",", signature.Select(item =>
+                $"{item.NormalizedBType}|{item.NormalizedCdc}|{item.IsQuality}|{item.IsTimestamp}"));
+
+    private static string Number(double? value)
+        => value.HasValue ? Number(value.Value) : "unknown";
+
+    private static string Number(double value)
+        => value.ToString("0.###", CultureInfo.InvariantCulture);
+
+    private static string Value<T>(T? value) where T : struct
+        => value.HasValue ? Convert.ToString(value.Value, CultureInfo.InvariantCulture) ?? "unknown" : "unknown";
+
+    private static string Empty(string? value)
+        => string.IsNullOrWhiteSpace(value) ? "unknown" : value;
+}
+
+public static class SvSubscriberEvidenceComparisonSerializer
+{
+    private static readonly JsonSerializerOptions JsonOptions = CreateJsonOptions();
+
+    public static string ToJson(SvSubscriberEvidenceComparison comparison)
+    {
+        ArgumentNullException.ThrowIfNull(comparison);
+        comparison.Validate();
+        return JsonSerializer.Serialize(comparison, JsonOptions);
+    }
+
+    public static SvSubscriberEvidenceComparison FromJson(string json)
+    {
+        if (string.IsNullOrWhiteSpace(json))
+            throw new ArgumentException("SV comparison JSON cannot be empty.", nameof(json));
+        var comparison = JsonSerializer.Deserialize<SvSubscriberEvidenceComparison>(json, JsonOptions)
+            ?? throw new InvalidDataException("SV comparison JSON did not contain a comparison document.");
+        comparison.Validate();
+        return comparison;
+    }
+
+    public static string ToMarkdown(SvSubscriberEvidenceComparison comparison)
+    {
+        ArgumentNullException.ThrowIfNull(comparison);
+        comparison.Validate();
+
+        var builder = new StringBuilder();
+        builder.AppendLine("# ARSVIN Subscriber Evidence Comparison");
+        builder.AppendLine();
+        builder.AppendLine("> Baseline-versus-candidate engineering evidence. Warnings and errors identify regressions for review; this is not a formal IEC 61850 conformance certificate.");
+        builder.AppendLine();
+        builder.AppendLine("## Comparison metadata");
+        builder.AppendLine();
+        AppendKeyValueTable(builder,
+        [
+            ("Schema", comparison.SchemaVersion),
+            ("Generated", Timestamp(comparison.GeneratedAt)),
+            ("Baseline generated", Timestamp(comparison.Baseline.GeneratedAt)),
+            ("Baseline version", comparison.Baseline.Version),
+            ("Baseline commit", comparison.Baseline.Commit),
+            ("Baseline capture", comparison.Baseline.CaptureSource),
+            ("Candidate generated", Timestamp(comparison.Candidate.GeneratedAt)),
+            ("Candidate version", comparison.Candidate.Version),
+            ("Candidate commit", comparison.Candidate.Commit),
+            ("Candidate capture", comparison.Candidate.CaptureSource)
+        ]);
+
+        builder.AppendLine("## Summary");
+        builder.AppendLine();
+        AppendKeyValueTable(builder,
+        [
+            ("Baseline streams", comparison.Summary.BaselineStreamCount.ToString(CultureInfo.InvariantCulture)),
+            ("Candidate streams", comparison.Summary.CandidateStreamCount.ToString(CultureInfo.InvariantCulture)),
+            ("Added", comparison.Summary.AddedStreamCount.ToString(CultureInfo.InvariantCulture)),
+            ("Removed", comparison.Summary.RemovedStreamCount.ToString(CultureInfo.InvariantCulture)),
+            ("Changed", comparison.Summary.ChangedStreamCount.ToString(CultureInfo.InvariantCulture)),
+            ("Unchanged", comparison.Summary.UnchangedStreamCount.ToString(CultureInfo.InvariantCulture)),
+            ("Info changes", comparison.Summary.InfoChangeCount.ToString(CultureInfo.InvariantCulture)),
+            ("Warnings", comparison.Summary.WarningChangeCount.ToString(CultureInfo.InvariantCulture)),
+            ("Errors", comparison.Summary.ErrorChangeCount.ToString(CultureInfo.InvariantCulture)),
+            ("Regression status", comparison.Summary.HasRegressions ? "REVIEW REQUIRED" : "NO REGRESSION DETECTED")
+        ]);
+
+        AppendChanges(builder, "Report-level changes", comparison.ReportChanges);
+
+        builder.AppendLine("## Stream comparison");
+        builder.AppendLine();
+        builder.AppendLine("| Kind | Severity | APPID | svID | Dataset | Changes |");
+        builder.AppendLine("|---|---|---:|---|---|---:|");
+        foreach (var stream in comparison.Streams)
+        {
+            builder.Append("| ").Append(Cell(stream.Kind.ToString()))
+                .Append(" | ").Append(Cell(stream.Severity.ToString()))
+                .Append(" | 0x").Append(stream.Identity.AppId.ToString("X4", CultureInfo.InvariantCulture))
+                .Append(" | ").Append(Cell(stream.Identity.SvId))
+                .Append(" | ").Append(Cell(stream.Identity.DataSetReference))
+                .Append(" | ").Append(stream.Changes.Count.ToString(CultureInfo.InvariantCulture)).AppendLine(" |");
+        }
+        builder.AppendLine();
+
+        foreach (var stream in comparison.Streams.Where(stream => stream.Changes.Count > 0))
+        {
+            builder.Append("## 0x").Append(stream.Identity.AppId.ToString("X4", CultureInfo.InvariantCulture))
+                .Append(" — ").AppendLine(Heading(stream.Identity.SvId));
+            builder.AppendLine();
+            AppendKeyValueTable(builder,
+            [
+                ("Kind", stream.Kind.ToString()),
+                ("Severity", stream.Severity.ToString()),
+                ("Logical key", stream.ComparisonKey),
+                ("Baseline stream key", Empty(stream.BaselineStreamKey)),
+                ("Candidate stream key", Empty(stream.CandidateStreamKey)),
+                ("Destination MAC", stream.Identity.DestinationMac),
+                ("VLAN", stream.Identity.VlanId?.ToString(CultureInfo.InvariantCulture) ?? "untagged"),
+                ("Dataset", stream.Identity.DataSetReference)
+            ]);
+            AppendChanges(builder, "Changes", stream.Changes);
+        }
+
+        return builder.ToString();
+    }
+
+    private static void AppendChanges(
+        StringBuilder builder,
+        string title,
+        IReadOnlyList<SvEvidenceFieldChange> changes)
+    {
+        builder.Append("## ").AppendLine(title);
+        builder.AppendLine();
+        if (changes.Count == 0)
+        {
+            builder.AppendLine("- No changes.");
+            builder.AppendLine();
+            return;
+        }
+
+        builder.AppendLine("| Severity | Category | Field | Baseline | Candidate | Message |");
+        builder.AppendLine("|---|---|---|---|---|---|");
+        foreach (var change in changes)
+        {
+            builder.Append("| ").Append(Cell(change.Severity.ToString()))
+                .Append(" | ").Append(Cell(change.Category))
+                .Append(" | ").Append(Cell(change.Field))
+                .Append(" | ").Append(Cell(change.Baseline))
+                .Append(" | ").Append(Cell(change.Candidate))
+                .Append(" | ").Append(Cell(change.Message)).AppendLine(" |");
+        }
+        builder.AppendLine();
+    }
+
+    private static void AppendKeyValueTable(StringBuilder builder, IEnumerable<(string Key, string Value)> rows)
+    {
+        builder.AppendLine("| Field | Value |");
+        builder.AppendLine("|---|---|");
+        foreach (var row in rows)
+            builder.Append("| ").Append(Cell(row.Key)).Append(" | ").Append(Cell(Empty(row.Value))).AppendLine(" |");
+        builder.AppendLine();
+    }
+
+    private static JsonSerializerOptions CreateJsonOptions()
+    {
+        var options = new JsonSerializerOptions
+        {
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+            WriteIndented = true
+        };
+        options.Converters.Add(new JsonStringEnumConverter(JsonNamingPolicy.CamelCase));
+        return options;
+    }
+
+    private static string Timestamp(DateTimeOffset value)
+        => value.ToString("yyyy-MM-dd HH:mm:ss.fff zzz", CultureInfo.InvariantCulture);
+
+    private static string Empty(string? value)
+        => string.IsNullOrWhiteSpace(value) ? "-" : value;
+
+    private static string Cell(string? value)
+        => Empty(value).Replace("|", "\\|", StringComparison.Ordinal)
+            .Replace("\r", " ", StringComparison.Ordinal)
+            .Replace("\n", " ", StringComparison.Ordinal);
+
+    private static string Heading(string? value)
+        => Empty(value).Replace("\r", " ", StringComparison.Ordinal)
+            .Replace("\n", " ", StringComparison.Ordinal);
+}

From b1bf78e6c0eb22dde027ac9ec62e9cf037231946 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 04:38:09 +0700
Subject: [PATCH 28/39] Add deterministic P3F comparison tests

---
 .../SvSubscriberEvidenceComparisonTests.cs    | 200 ++++++++++++++++++
 1 file changed, 200 insertions(+)
 create mode 100644 tests/ARSVIN.Tests/SampledValues/Profiles/SvSubscriberEvidenceComparisonTests.cs

diff --git a/tests/ARSVIN.Tests/SampledValues/Profiles/SvSubscriberEvidenceComparisonTests.cs b/tests/ARSVIN.Tests/SampledValues/Profiles/SvSubscriberEvidenceComparisonTests.cs
new file mode 100644
index 0000000..a72d222
--- /dev/null
+++ b/tests/ARSVIN.Tests/SampledValues/Profiles/SvSubscriberEvidenceComparisonTests.cs
@@ -0,0 +1,200 @@
+using AR.Iec61850.SampledValues.Profiles;
+using AR.Iec61850.SampledValues.Reporting;
+using Xunit;
+
+namespace ARSVIN.Tests.SampledValues.Profiles;
+
+public sealed class SvSubscriberEvidenceComparisonTests
+{
+    [Fact]
+    public void SourceFailoverMatchesLogicalStreamAndSurfacesRegression()
+    {
+        var baseline = CreateReport(CreateStream("stream-a", "02:00:00:00:00:01", "GOOD", sequenceGaps: 0));
+        var candidate = CreateReport(
+            CreateStream("stream-b", "02:00:00:00:00:02", "BAD", sequenceGaps: 2),
+            commit: "candidate123");
+
+        var comparison = new SvSubscriberEvidenceComparator().Compare(
+            baseline,
+            candidate,
+            DateTimeOffset.UnixEpoch.AddMinutes(5));
+
+        var stream = Assert.Single(comparison.Streams);
+        Assert.Equal(SvEvidenceChangeKind.Changed, stream.Kind);
+        Assert.Equal(SvEvidenceChangeSeverity.Error, stream.Severity);
+        Assert.Contains(stream.Changes, change => change.Field == "Source MAC");
+        Assert.Contains(stream.Changes, change =>
+            change.Field == "Health" && change.Severity == SvEvidenceChangeSeverity.Error);
+        Assert.Contains(stream.Changes, change =>
+            change.Field == "Sequence gaps" && change.Severity == SvEvidenceChangeSeverity.Warning);
+        Assert.Equal(0, comparison.Summary.AddedStreamCount);
+        Assert.Equal(0, comparison.Summary.RemovedStreamCount);
+        Assert.True(comparison.Summary.HasRegressions);
+    }
+
+    [Fact]
+    public void MissingAndNewLogicalStreamsAreClassifiedDeterministically()
+    {
+        var baseline = CreateReport(CreateStream("baseline", "02:00:00:00:00:01", "GOOD", svId: "MU01SV01"));
+        var candidate = CreateReport(CreateStream("candidate", "02:00:00:00:00:02", "GOOD", svId: "MU02SV01"));
+
+        var comparison = new SvSubscriberEvidenceComparator().Compare(
+            baseline,
+            candidate,
+            DateTimeOffset.UnixEpoch.AddMinutes(5));
+
+        Assert.Equal(2, comparison.Streams.Count);
+        Assert.Equal(1, comparison.Summary.AddedStreamCount);
+        Assert.Equal(1, comparison.Summary.RemovedStreamCount);
+        Assert.Contains(comparison.Streams, stream =>
+            stream.Kind == SvEvidenceChangeKind.Removed && stream.Severity == SvEvidenceChangeSeverity.Error);
+        Assert.Contains(comparison.Streams, stream =>
+            stream.Kind == SvEvidenceChangeKind.Added && stream.Severity == SvEvidenceChangeSeverity.Info);
+    }
+
+    [Fact]
+    public void JsonRoundTripAndMarkdownPreserveRegressionEvidence()
+    {
+        var baseline = CreateReport(CreateStream("stream-a", "02:00:00:00:00:01", "GOOD", sequenceGaps: 0));
+        var candidate = CreateReport(CreateStream("stream-a", "02:00:00:00:00:01", "WARN", sequenceGaps: 1));
+        var comparison = new SvSubscriberEvidenceComparator().Compare(
+            baseline,
+            candidate,
+            DateTimeOffset.UnixEpoch.AddMinutes(5));
+
+        var json = SvSubscriberEvidenceComparisonSerializer.ToJson(comparison);
+        var restored = SvSubscriberEvidenceComparisonSerializer.FromJson(json);
+        var markdown = SvSubscriberEvidenceComparisonSerializer.ToMarkdown(restored);
+
+        Assert.Contains("arsvin.sv-subscriber-evidence-comparison/v1", json, StringComparison.Ordinal);
+        Assert.Contains("warning", json, StringComparison.Ordinal);
+        Assert.Equal(comparison.Summary.WarningChangeCount, restored.Summary.WarningChangeCount);
+        Assert.Contains("# ARSVIN Subscriber Evidence Comparison", markdown, StringComparison.Ordinal);
+        Assert.Contains("REVIEW REQUIRED", markdown, StringComparison.Ordinal);
+        Assert.Contains("Sequence gaps", markdown, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void RateMovementInsideToleranceDoesNotCreateFalseRegression()
+    {
+        var baselineStream = CreateStream("stream-a", "02:00:00:00:00:01", "GOOD", observedSamplesPerSecond: 4000);
+        var candidateStream = CreateStream("stream-a", "02:00:00:00:00:01", "GOOD", observedSamplesPerSecond: 4020);
+        var baseline = CreateReport(baselineStream);
+        var candidate = CreateReport(candidateStream);
+
+        var comparison = new SvSubscriberEvidenceComparator().Compare(
+            baseline,
+            candidate,
+            DateTimeOffset.UnixEpoch.AddMinutes(5));
+
+        var stream = Assert.Single(comparison.Streams);
+        Assert.Equal(SvEvidenceChangeKind.Unchanged, stream.Kind);
+        Assert.Empty(stream.Changes);
+        Assert.False(comparison.Summary.HasRegressions);
+    }
+
+    private static SvSubscriberEvidenceReport CreateReport(
+        SvSubscriberStreamEvidence stream,
+        string commit = "baseline123")
+        => new()
+        {
+            GeneratedAt = DateTimeOffset.UnixEpoch.AddMinutes(1),
+            Software = new SvSubscriberSoftwareEvidence
+            {
+                Product = "ARSVIN Subscriber",
+                Version = "0.4.0",
+                InformationalVersion = $"0.4.0+{commit}",
+                Commit = commit,
+                Repository = "https://github.com/masarray/arsvin"
+            },
+            Capture = new SvSubscriberCaptureEvidence
+            {
+                Source = "LiveCapture",
+                EndedAt = DateTimeOffset.UnixEpoch.AddMinutes(1),
+                RawFrames = 8000,
+                SvFrames = 8000
+            },
+            Summary = new SvSubscriberSummaryEvidence
+            {
+                Health = stream.Health,
+                StreamCount = 1
+            },
+            Streams = [stream]
+        };
+
+    private static SvSubscriberStreamEvidence CreateStream(
+        string key,
+        string sourceMac,
+        string health,
+        int sequenceGaps = 0,
+        string svId = "MU01SV01",
+        double observedSamplesPerSecond = 4000)
+    {
+        var facts = new SvObservedStreamFacts
+        {
+            EtherType = 0x88BA,
+            AppId = 0x4001,
+            DestinationMac = "01:0C:CD:04:00:01",
+            VlanId = 100,
+            VlanPriority = 4,
+            SvId = svId,
+            DataSetReference = $"{svId}/LLN0$PhsMeas",
+            ConfigurationRevision = 7,
+            AsduPerFrame = 1,
+            PayloadBytesPerAsdu = 8,
+            ObservedFramesPerSecond = observedSamplesPerSecond,
+            ObservedSamplesPerSecond = observedSamplesPerSecond,
+            ObservedCounterWrap = 4000,
+            DeclaredSampleRate = 80,
+            DeclaredSampleMode = 0,
+            Provenance = new Dictionary<string, SvFactSource>(StringComparer.Ordinal)
+            {
+                [nameof(SvObservedStreamFacts.AppId)] = SvFactSource.WireObserved,
+                [nameof(SvObservedStreamFacts.ObservedSamplesPerSecond)] = SvFactSource.CaptureCalculated
+            },
+            ObservationCount = 8000,
+            FirstTimestamp = DateTimeOffset.UnixEpoch,
+            LastTimestamp = DateTimeOffset.UnixEpoch.AddSeconds(2)
+        };
+
+        return new SvSubscriberStreamEvidence
+        {
+            Key = key,
+            Health = health,
+            Identity = new SvSubscriberStreamIdentityEvidence
+            {
+                AppId = 0x4001,
+                SourceMac = sourceMac,
+                DestinationMac = facts.DestinationMac,
+                VlanId = facts.VlanId,
+                VlanPriority = facts.VlanPriority,
+                SvId = facts.SvId,
+                DataSetReference = facts.DataSetReference,
+                ConfigurationRevision = facts.ConfigurationRevision,
+                AsduPerFrame = 1,
+                DeclaredSampleRate = facts.DeclaredSampleRate,
+                DeclaredSampleMode = facts.DeclaredSampleMode
+            },
+            Runtime = new SvSubscriberRuntimeEvidence
+            {
+                FrameCount = 8000,
+                AsduCount = 8000,
+                ActualFramesPerSecond = observedSamplesPerSecond,
+                SequenceGapCount = sequenceGaps,
+                IsWaveformWindowReady = true
+            },
+            Observation = new SvSubscriberObservationEvidence
+            {
+                InputKinds = [SvObservationInputKind.LiveCapture],
+                LastInputKind = SvObservationInputKind.LiveCapture,
+                WindowFrames = 8000,
+                WindowSamples = 8000,
+                WindowDurationSeconds = 2,
+                FirstTimestamp = facts.FirstTimestamp,
+                LastTimestamp = facts.LastTimestamp,
+                Facts = facts,
+                FactProvenance = facts.Provenance
+            }
+        };
+    }
+}

From 3d1ec20c5f92607f5514a45e3f81c4d82df586a8 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 04:38:57 +0700
Subject: [PATCH 29/39] Add P3F evidence comparison action

---
 src/ARSVIN.Subscriber/MainWindow.xaml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/ARSVIN.Subscriber/MainWindow.xaml b/src/ARSVIN.Subscriber/MainWindow.xaml
index 11a9f7f..27d69bb 100644
--- a/src/ARSVIN.Subscriber/MainWindow.xaml
+++ b/src/ARSVIN.Subscriber/MainWindow.xaml
@@ -102,6 +102,7 @@
                         <Button Style="{StaticResource ToolbarButton}" Command="{Binding OpenSclCommand}" Content="Import SCL" Margin="0,0,6,0" />
                         <Button Style="{StaticResource ToolbarButton}" Command="{Binding OpenCaptureFileCommand}" Content="Open PCAP" Margin="0,0,6,0" />
                         <Button Style="{StaticResource ToolbarButton}" Command="{Binding ExportReportCommand}" Content="Export" Margin="0,0,6,0" />
+                        <Button Style="{StaticResource ToolbarButton}" Click="CompareEvidence_Click" Content="Compare" ToolTip="Compare two ARSVIN evidence JSON reports" Margin="0,0,6,0" />
                         <Button Style="{StaticResource ToolbarButton}" Command="{Binding RefreshAdaptersCommand}" Content="Refresh" Margin="0,0,6,0" />
                         <Button Style="{StaticResource ToolbarButton}" Command="{Binding ClearCommand}" Content="Clear" Margin="0,0,6,0" />
                     </StackPanel>
@@ -350,4 +351,4 @@
             </DockPanel>
         </Border>
     </Grid>
-</Window>
+</Window>
\ No newline at end of file

From a8431f446701dd6ce7cbc27148dac85aa929579b Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 04:39:17 +0700
Subject: [PATCH 30/39] Wire P3F report comparison workflow

---
 src/ARSVIN.Subscriber/MainWindow.xaml.cs | 77 ++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/src/ARSVIN.Subscriber/MainWindow.xaml.cs b/src/ARSVIN.Subscriber/MainWindow.xaml.cs
index 58b5712..43bd8ab 100644
--- a/src/ARSVIN.Subscriber/MainWindow.xaml.cs
+++ b/src/ARSVIN.Subscriber/MainWindow.xaml.cs
@@ -1,7 +1,10 @@
+using System.Text.Json;
 using System.Windows;
 using System.Windows.Data;
+using AR.Iec61850.SampledValues.Reporting;
 using ARSVIN.Subscriber.Controls;
 using ARSVIN.Subscriber.ViewModels;
+using Microsoft.Win32;
 
 namespace ARSVIN.Subscriber;
 
@@ -34,6 +37,80 @@ private void AttachLivePlotControls()
         PhasorHost.Child = phasor;
     }
 
+    private async void CompareEvidence_Click(object sender, RoutedEventArgs e)
+    {
+        var baselineDialog = new OpenFileDialog
+        {
+            Title = "Select baseline ARSVIN evidence JSON",
+            Filter = "ARSVIN evidence JSON (*.json)|*.json|All files (*.*)|*.*",
+            Multiselect = false
+        };
+        if (baselineDialog.ShowDialog(this) != true)
+            return;
+
+        var candidateDialog = new OpenFileDialog
+        {
+            Title = "Select candidate ARSVIN evidence JSON",
+            Filter = "ARSVIN evidence JSON (*.json)|*.json|All files (*.*)|*.*",
+            Multiselect = false,
+            InitialDirectory = Path.GetDirectoryName(baselineDialog.FileName)
+        };
+        if (candidateDialog.ShowDialog(this) != true)
+            return;
+
+        var saveDialog = new SaveFileDialog
+        {
+            Title = "Save ARSVIN evidence comparison bundle",
+            Filter = "ARSVIN comparison bundle (*.md)|*.md|Markdown comparison (*.md)|*.md|JSON comparison (*.json)|*.json",
+            DefaultExt = ".md",
+            AddExtension = true,
+            FileName = $"arsvin-subscriber-comparison-{DateTime.Now:yyyyMMdd-HHmmss}.md"
+        };
+        if (saveDialog.ShowDialog(this) != true)
+            return;
+
+        try
+        {
+            var baselineJsonTask = File.ReadAllTextAsync(baselineDialog.FileName);
+            var candidateJsonTask = File.ReadAllTextAsync(candidateDialog.FileName);
+            await Task.WhenAll(baselineJsonTask, candidateJsonTask).ConfigureAwait(true);
+
+            var baseline = SvSubscriberEvidenceReportSerializer.FromJson(await baselineJsonTask.ConfigureAwait(true));
+            var candidate = SvSubscriberEvidenceReportSerializer.FromJson(await candidateJsonTask.ConfigureAwait(true));
+            var comparison = new SvSubscriberEvidenceComparator().Compare(
+                baseline,
+                candidate,
+                DateTimeOffset.Now);
+
+            var markdownPath = Path.ChangeExtension(saveDialog.FileName, ".md");
+            var jsonPath = Path.ChangeExtension(saveDialog.FileName, ".json");
+            await Task.WhenAll(
+                File.WriteAllTextAsync(markdownPath, SvSubscriberEvidenceComparisonSerializer.ToMarkdown(comparison)),
+                File.WriteAllTextAsync(jsonPath, SvSubscriberEvidenceComparisonSerializer.ToJson(comparison))).ConfigureAwait(true);
+
+            var status = comparison.Summary.HasRegressions
+                ? $"Review required: {comparison.Summary.WarningChangeCount} warning(s), {comparison.Summary.ErrorChangeCount} error(s)."
+                : "No regression detected.";
+            MessageBox.Show(
+                this,
+                $"Evidence comparison exported:\n{Path.GetFileName(markdownPath)}\n{Path.GetFileName(jsonPath)}\n\n{status}",
+                "ARSVIN Evidence Comparison",
+                MessageBoxButton.OK,
+                comparison.Summary.HasRegressions ? MessageBoxImage.Warning : MessageBoxImage.Information);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or
+                                   ArgumentException or InvalidDataException or
+                                   InvalidOperationException or JsonException)
+        {
+            MessageBox.Show(
+                this,
+                $"Evidence comparison failed: {ex.Message}",
+                "ARSVIN Evidence Comparison",
+                MessageBoxButton.OK,
+                MessageBoxImage.Error);
+        }
+    }
+
     protected override void OnClosed(EventArgs e)
     {
         _viewModel.Dispose();

From c0ed7b4446649d1dd7305f3a6a6ea869fdf279e2 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 04:39:47 +0700
Subject: [PATCH 31/39] Document P3F evidence comparison workflow

---
 docs/sv-profile-infrastructure.md | 31 ++++++++++++++++++++++++++++---
 1 file changed, 28 insertions(+), 3 deletions(-)

diff --git a/docs/sv-profile-infrastructure.md b/docs/sv-profile-infrastructure.md
index 441a409..9935f9b 100644
--- a/docs/sv-profile-infrastructure.md
+++ b/docs/sv-profile-infrastructure.md
@@ -132,6 +132,30 @@ Unknown nullable values remain explicit `null`; unknown text fields remain empty
 
 GitHub Actions injects `GITHUB_SHA` into `SourceRevisionId`; the .NET informational version therefore carries the build commit for release and CI artifacts. Local builds without source revision metadata report the commit as `unknown` rather than inventing one.
 
+## Evidence report comparison
+
+The Subscriber **Compare** action accepts a baseline and candidate `arsvin.sv-subscriber-evidence/v1` JSON report and writes a paired comparison bundle:
+
+- Markdown for engineering review,
+- JSON using schema `arsvin.sv-subscriber-evidence-comparison/v1` for automation and regression gates.
+
+Comparison uses the full stable stream key first. Unmatched streams are then paired through a logical identity made from APPID, destination MAC, VLAN, `svID`, and dataset reference. Source MAC is deliberately excluded from that fallback identity so publisher/NIC failover is reported as a source change rather than a false removed-plus-added stream.
+
+The comparison classifies:
+
+- report-level schema, software, commit, capture-source, SCL-source, and health changes,
+- added, removed, changed, and unchanged logical streams,
+- health regression or recovery,
+- source-MAC failover,
+- `confRev`, ASDU packing, sample-rate, and sample-mode changes,
+- sequence gaps, duplicates, out-of-order frames, payload issues, and SCL mismatches,
+- observation-window size and measured-rate changes,
+- SCL binding and configuration-comparison regression,
+- profile identity and confidence changes,
+- payload, counter-wrap, nominal-frequency, dataset-signature, provenance, and diagnostic changes.
+
+Changes are assigned `Info`, `Warning`, or `Error` severity. Removed streams, health transitions to `BAD`/`ERROR`, new out-of-order or payload failures, blocking configuration errors, profile conflicts, and dataset-signature changes are treated as high-signal regressions. Measured-rate changes within the one-percent comparison tolerance do not create false warnings.
+
 ## Current integration boundary
 
 `SvStreamObservationManager` and Subscriber now:
@@ -146,10 +170,11 @@ GitHub Actions injects `GITHUB_SHA` into `SourceRevisionId`; the .NET informatio
 - evaluate the built-in evidence-aware profile catalog;
 - expose compact profile, confidence, SCL match, and observation-window state;
 - expose detailed evidence only on demand;
-- keep full-window waveform, phasor, and RMS visualization stable through bulk collection refreshes; and
-- serialize the same observation, profile, configuration, provenance, source, and build evidence into paired Markdown and JSON reports.
+- keep full-window waveform, phasor, and RMS visualization stable through bulk collection refreshes;
+- serialize the same observation, profile, configuration, provenance, source, and build evidence into paired Markdown and JSON reports; and
+- compare baseline and candidate evidence reports through deterministic, severity-ranked Markdown and JSON output.
 
 ## Next integration
 
 1. Add profile-specific definitions only after source review and deterministic evidence.
-2. Add report-to-report comparison after the evidence schema has real capture history and compatibility requirements.
+2. Accumulate real comparison history before defining organization-specific pass/fail policy or CI blocking thresholds.

From 612a196f7f802c1950ce1b317cf00bd74060f4a4 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 04:44:57 +0700
Subject: [PATCH 32/39] Add temporary P3F compile diagnostics

---
 .github/workflows/p3f-compile-diagnostic.yml | 54 ++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 .github/workflows/p3f-compile-diagnostic.yml

diff --git a/.github/workflows/p3f-compile-diagnostic.yml b/.github/workflows/p3f-compile-diagnostic.yml
new file mode 100644
index 0000000..ccaf151
--- /dev/null
+++ b/.github/workflows/p3f-compile-diagnostic.yml
@@ -0,0 +1,54 @@
+name: P3F Compile Diagnostic
+
+on:
+  pull_request:
+    branches: [ main ]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  compile-log:
+    runs-on: windows-2025
+    steps:
+      - name: Checkout
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@26b0ec14cb23fa6904739307f278c14f94c95bf1 # v5
+        with:
+          dotnet-version: 8.0.4xx
+
+      - name: Restore
+        run: dotnet restore ARSVIN.sln --locked-mode
+
+      - name: Capture Publisher build log
+        id: publisher
+        shell: pwsh
+        run: |
+          dotnet build src/ARSVIN/ARSVIN.csproj -c Release --no-restore -warnaserror *> artifacts/p3f-publisher-build.log
+          "exit_code=$LASTEXITCODE" >> $env:GITHUB_OUTPUT
+          exit 0
+
+      - name: Capture Subscriber build log
+        id: subscriber
+        shell: pwsh
+        run: |
+          dotnet build src/ARSVIN.Subscriber/ARSVIN.Subscriber.csproj -c Release --no-restore -warnaserror *> artifacts/p3f-subscriber-build.log
+          "exit_code=$LASTEXITCODE" >> $env:GITHUB_OUTPUT
+          exit 0
+
+      - name: Upload complete compiler logs
+        if: always()
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
+        with:
+          name: p3f-compiler-logs
+          path: artifacts/p3f-*-build.log
+          if-no-files-found: error
+          retention-days: 1
+
+      - name: Enforce compiler results
+        if: steps.publisher.outputs.exit_code != '0' || steps.subscriber.outputs.exit_code != '0'
+        shell: pwsh
+        run: exit 1

From 44aaba7640a0dcd0a6888100923ebaf52af23958 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 04:46:31 +0700
Subject: [PATCH 33/39] Fix temporary compiler log capture

---
 .github/workflows/p3f-compile-diagnostic.yml | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/.github/workflows/p3f-compile-diagnostic.yml b/.github/workflows/p3f-compile-diagnostic.yml
index ccaf151..22ea03c 100644
--- a/.github/workflows/p3f-compile-diagnostic.yml
+++ b/.github/workflows/p3f-compile-diagnostic.yml
@@ -23,18 +23,26 @@ jobs:
       - name: Restore
         run: dotnet restore ARSVIN.sln --locked-mode
 
+      - name: Prepare diagnostic output
+        shell: pwsh
+        run: New-Item -ItemType Directory -Force artifacts | Out-Null
+
       - name: Capture Publisher build log
         id: publisher
+        continue-on-error: true
         shell: pwsh
         run: |
+          $PSNativeCommandUseErrorActionPreference = $false
           dotnet build src/ARSVIN/ARSVIN.csproj -c Release --no-restore -warnaserror *> artifacts/p3f-publisher-build.log
           "exit_code=$LASTEXITCODE" >> $env:GITHUB_OUTPUT
           exit 0
 
       - name: Capture Subscriber build log
         id: subscriber
+        continue-on-error: true
         shell: pwsh
         run: |
+          $PSNativeCommandUseErrorActionPreference = $false
           dotnet build src/ARSVIN.Subscriber/ARSVIN.Subscriber.csproj -c Release --no-restore -warnaserror *> artifacts/p3f-subscriber-build.log
           "exit_code=$LASTEXITCODE" >> $env:GITHUB_OUTPUT
           exit 0

From 79dc2b58401124053fdeb3a34e3446669628bbf3 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 04:50:34 +0700
Subject: [PATCH 34/39] Harden P3F evidence comparator

---
 .../SvSubscriberEvidenceComparison.cs         | 559 +++++++-----------
 1 file changed, 220 insertions(+), 339 deletions(-)

diff --git a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceComparison.cs b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceComparison.cs
index 2292be7..7215394 100644
--- a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceComparison.cs
+++ b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceComparison.cs
@@ -1,7 +1,4 @@
 using System.Globalization;
-using System.Text;
-using System.Text.Json;
-using System.Text.Json.Serialization;
 using AR.Iec61850.SampledValues.Profiles;
 
 namespace AR.Iec61850.SampledValues.Reporting;
@@ -43,20 +40,22 @@ public void Validate()
             throw new InvalidOperationException("SV comparison requires a generation timestamp.");
         if (string.IsNullOrWhiteSpace(Baseline.SchemaVersion) || string.IsNullOrWhiteSpace(Candidate.SchemaVersion))
             throw new InvalidOperationException("SV comparison requires baseline and candidate schema metadata.");
+        if (Streams.Any(stream => string.IsNullOrWhiteSpace(stream.ComparisonKey)))
+            throw new InvalidOperationException("Every stream comparison requires a stable comparison key.");
         if (Streams.Select(stream => stream.ComparisonKey).Distinct(StringComparer.Ordinal).Count() != Streams.Count)
-            throw new InvalidOperationException("SV comparison stream keys must be unique.");
+            throw new InvalidOperationException("SV comparison keys must be unique.");
 
         var classified = Summary.AddedStreamCount + Summary.RemovedStreamCount +
                          Summary.ChangedStreamCount + Summary.UnchangedStreamCount;
         if (classified != Streams.Count)
-            throw new InvalidOperationException("SV comparison summary does not match the stream comparison collection.");
+            throw new InvalidOperationException("SV comparison summary does not match the stream collection.");
 
-        var allChanges = ReportChanges.Concat(Streams.SelectMany(stream => stream.Changes)).ToArray();
-        if (Summary.InfoChangeCount != allChanges.Count(change => change.Severity == SvEvidenceChangeSeverity.Info) ||
-            Summary.WarningChangeCount != allChanges.Count(change => change.Severity == SvEvidenceChangeSeverity.Warning) ||
-            Summary.ErrorChangeCount != allChanges.Count(change => change.Severity == SvEvidenceChangeSeverity.Error))
+        var changes = ReportChanges.Concat(Streams.SelectMany(stream => stream.Changes)).ToArray();
+        if (Summary.InfoChangeCount != changes.Count(change => change.Severity == SvEvidenceChangeSeverity.Info) ||
+            Summary.WarningChangeCount != changes.Count(change => change.Severity == SvEvidenceChangeSeverity.Warning) ||
+            Summary.ErrorChangeCount != changes.Count(change => change.Severity == SvEvidenceChangeSeverity.Error))
         {
-            throw new InvalidOperationException("SV comparison severity totals do not match the comparison evidence.");
+            throw new InvalidOperationException("SV comparison severity totals do not match the evidence.");
         }
     }
 }
@@ -90,6 +89,7 @@ public sealed record SvEvidenceComparisonSummary
 public sealed record SvSubscriberStreamComparison
 {
     public string ComparisonKey { get; init; } = string.Empty;
+    public string LogicalStreamKey { get; init; } = string.Empty;
     public SvEvidenceChangeKind Kind { get; init; }
     public SvEvidenceChangeSeverity Severity { get; init; }
     public string BaselineStreamKey { get; init; } = string.Empty;
@@ -126,31 +126,30 @@ public SvSubscriberEvidenceComparison Compare(
             throw new ArgumentException("Comparison requires a generation timestamp.", nameof(generatedAt));
 
         var reportChanges = CompareReportMetadata(baseline, candidate);
-        var streamComparisons = CompareStreams(baseline.Streams, candidate.Streams);
-        var allChanges = reportChanges.Concat(streamComparisons.SelectMany(stream => stream.Changes)).ToArray();
-
-        var result = new SvSubscriberEvidenceComparison
+        var streams = CompareStreams(baseline.Streams, candidate.Streams);
+        var allChanges = reportChanges.Concat(streams.SelectMany(stream => stream.Changes)).ToArray();
+        var comparison = new SvSubscriberEvidenceComparison
         {
             GeneratedAt = generatedAt,
-            Baseline = ToReference(baseline),
-            Candidate = ToReference(candidate),
+            Baseline = Reference(baseline),
+            Candidate = Reference(candidate),
+            ReportChanges = reportChanges,
+            Streams = streams,
             Summary = new SvEvidenceComparisonSummary
             {
                 BaselineStreamCount = baseline.Streams.Count,
                 CandidateStreamCount = candidate.Streams.Count,
-                AddedStreamCount = streamComparisons.Count(stream => stream.Kind == SvEvidenceChangeKind.Added),
-                RemovedStreamCount = streamComparisons.Count(stream => stream.Kind == SvEvidenceChangeKind.Removed),
-                ChangedStreamCount = streamComparisons.Count(stream => stream.Kind == SvEvidenceChangeKind.Changed),
-                UnchangedStreamCount = streamComparisons.Count(stream => stream.Kind == SvEvidenceChangeKind.Unchanged),
+                AddedStreamCount = streams.Count(stream => stream.Kind == SvEvidenceChangeKind.Added),
+                RemovedStreamCount = streams.Count(stream => stream.Kind == SvEvidenceChangeKind.Removed),
+                ChangedStreamCount = streams.Count(stream => stream.Kind == SvEvidenceChangeKind.Changed),
+                UnchangedStreamCount = streams.Count(stream => stream.Kind == SvEvidenceChangeKind.Unchanged),
                 InfoChangeCount = allChanges.Count(change => change.Severity == SvEvidenceChangeSeverity.Info),
                 WarningChangeCount = allChanges.Count(change => change.Severity == SvEvidenceChangeSeverity.Warning),
                 ErrorChangeCount = allChanges.Count(change => change.Severity == SvEvidenceChangeSeverity.Error)
-            },
-            ReportChanges = reportChanges,
-            Streams = streamComparisons
+            }
         };
-        result.Validate();
-        return result;
+        comparison.Validate();
+        return comparison;
     }
 
     private static IReadOnlyList<SvEvidenceFieldChange> CompareReportMetadata(
@@ -158,123 +157,126 @@ private static IReadOnlyList<SvEvidenceFieldChange> CompareReportMetadata(
         SvSubscriberEvidenceReport candidate)
     {
         var changes = new List<SvEvidenceFieldChange>();
-        AddTextChange(changes, "Report", "Schema version", baseline.SchemaVersion, candidate.SchemaVersion,
+        TextChange(changes, "Report", "Schema version", baseline.SchemaVersion, candidate.SchemaVersion,
             SvEvidenceChangeSeverity.Error, "Evidence schema changed; compatibility must be reviewed.");
-        AddTextChange(changes, "Software", "Product", baseline.Software.Product, candidate.Software.Product,
-            SvEvidenceChangeSeverity.Warning, "Product identity changed between reports.");
-        AddTextChange(changes, "Software", "Version", baseline.Software.Version, candidate.Software.Version,
+        TextChange(changes, "Software", "Product", baseline.Software.Product, candidate.Software.Product,
+            SvEvidenceChangeSeverity.Warning, "Product identity changed.");
+        TextChange(changes, "Software", "Version", baseline.Software.Version, candidate.Software.Version,
             SvEvidenceChangeSeverity.Info, "Software version changed.");
-        AddTextChange(changes, "Software", "Commit", baseline.Software.Commit, candidate.Software.Commit,
+        TextChange(changes, "Software", "Commit", baseline.Software.Commit, candidate.Software.Commit,
             SvEvidenceChangeSeverity.Info, "Build commit changed.");
-        AddTextChange(changes, "Capture", "Source", baseline.Capture.Source, candidate.Capture.Source,
+        TextChange(changes, "Capture", "Source", baseline.Capture.Source, candidate.Capture.Source,
             SvEvidenceChangeSeverity.Info, "Capture source changed.");
-        AddTextChange(changes, "Capture", "SCL path", baseline.Capture.SclPath, candidate.Capture.SclPath,
+        TextChange(changes, "Capture", "SCL path", baseline.Capture.SclPath, candidate.Capture.SclPath,
             SvEvidenceChangeSeverity.Info, "SCL source changed.");
-        AddHealthChange(changes, "Report", baseline.Summary.Health, candidate.Summary.Health);
+        HealthChange(changes, "Report", baseline.Summary.Health, candidate.Summary.Health);
         return changes;
     }
 
     private static IReadOnlyList<SvSubscriberStreamComparison> CompareStreams(
-        IReadOnlyList<SvSubscriberStreamEvidence> baselineStreams,
-        IReadOnlyList<SvSubscriberStreamEvidence> candidateStreams)
+        IReadOnlyList<SvSubscriberStreamEvidence> baseline,
+        IReadOnlyList<SvSubscriberStreamEvidence> candidate)
     {
-        var result = new List<SvSubscriberStreamComparison>();
-        var candidateByKey = candidateStreams.ToDictionary(stream => stream.Key, StringComparer.Ordinal);
+        var comparisons = new List<SvSubscriberStreamComparison>();
+        var candidateByKey = candidate.ToDictionary(stream => stream.Key, StringComparer.Ordinal);
         var usedCandidateKeys = new HashSet<string>(StringComparer.Ordinal);
         var unmatchedBaseline = new List<SvSubscriberStreamEvidence>();
 
-        foreach (var baseline in baselineStreams)
+        foreach (var baselineStream in baseline)
         {
-            if (candidateByKey.TryGetValue(baseline.Key, out var exact))
+            if (candidateByKey.TryGetValue(baselineStream.Key, out var exact))
             {
-                result.Add(ComparePair(baseline, exact));
+                comparisons.Add(Pair(baselineStream, exact));
                 usedCandidateKeys.Add(exact.Key);
             }
             else
             {
-                unmatchedBaseline.Add(baseline);
+                unmatchedBaseline.Add(baselineStream);
             }
         }
 
-        var unmatchedCandidate = candidateStreams
-            .Where(stream => !usedCandidateKeys.Contains(stream.Key))
-            .ToArray();
-        var baselineLogicalGroups = unmatchedBaseline.GroupBy(LogicalKey, StringComparer.Ordinal)
+        var unmatchedCandidate = candidate.Where(stream => !usedCandidateKeys.Contains(stream.Key)).ToArray();
+        var baselineLogical = unmatchedBaseline.GroupBy(LogicalKey, StringComparer.Ordinal)
             .ToDictionary(group => group.Key, group => group.ToArray(), StringComparer.Ordinal);
-        var candidateLogicalGroups = unmatchedCandidate.GroupBy(LogicalKey, StringComparer.Ordinal)
+        var candidateLogical = unmatchedCandidate.GroupBy(LogicalKey, StringComparer.Ordinal)
             .ToDictionary(group => group.Key, group => group.ToArray(), StringComparer.Ordinal);
 
-        foreach (var baseline in unmatchedBaseline)
+        foreach (var baselineStream in unmatchedBaseline)
         {
-            var logicalKey = LogicalKey(baseline);
-            if (baselineLogicalGroups[logicalKey].Length == 1 &&
-                candidateLogicalGroups.TryGetValue(logicalKey, out var candidates) &&
+            var logicalKey = LogicalKey(baselineStream);
+            if (baselineLogical[logicalKey].Length == 1 &&
+                candidateLogical.TryGetValue(logicalKey, out var candidates) &&
                 candidates.Length == 1 &&
                 usedCandidateKeys.Add(candidates[0].Key))
             {
-                result.Add(ComparePair(baseline, candidates[0]));
-                continue;
+                comparisons.Add(Pair(baselineStream, candidates[0]));
+            }
+            else
+            {
+                comparisons.Add(Removed(baselineStream));
             }
-
-            result.Add(Removed(baseline));
         }
 
-        foreach (var candidate in candidateStreams.Where(stream => !usedCandidateKeys.Contains(stream.Key)))
-            result.Add(Added(candidate));
+        foreach (var candidateStream in candidate.Where(stream => !usedCandidateKeys.Contains(stream.Key)))
+            comparisons.Add(Added(candidateStream));
 
-        return result
-            .OrderBy(stream => stream.Identity.AppId)
+        return comparisons.OrderBy(stream => stream.Identity.AppId)
             .ThenBy(stream => stream.Identity.SvId, StringComparer.Ordinal)
             .ThenBy(stream => stream.Kind)
+            .ThenBy(stream => stream.ComparisonKey, StringComparer.Ordinal)
             .ToArray();
     }
 
-    private static SvSubscriberStreamComparison ComparePair(
+    private static SvSubscriberStreamComparison Pair(
         SvSubscriberStreamEvidence baseline,
         SvSubscriberStreamEvidence candidate)
     {
         var changes = new List<SvEvidenceFieldChange>();
-        AddHealthChange(changes, "Stream", baseline.Health, candidate.Health);
-        AddTextChange(changes, "Identity", "Source MAC", baseline.Identity.SourceMac, candidate.Identity.SourceMac,
-            SvEvidenceChangeSeverity.Info, "Publisher source MAC changed while the logical stream identity remained stable.");
-        AddNullableChange(changes, "Identity", "confRev", baseline.Identity.ConfigurationRevision,
+        HealthChange(changes, "Stream", baseline.Health, candidate.Health);
+        TextChange(changes, "Identity", "Source MAC", baseline.Identity.SourceMac, candidate.Identity.SourceMac,
+            SvEvidenceChangeSeverity.Info, "Publisher source MAC changed while logical identity remained stable.");
+        UIntChange(changes, "Identity", "confRev", baseline.Identity.ConfigurationRevision,
             candidate.Identity.ConfigurationRevision, SvEvidenceChangeSeverity.Warning, "Configuration revision changed.");
-        AddNullableChange(changes, "Identity", "ASDU per frame", baseline.Identity.AsduPerFrame,
+        IntChange(changes, "Identity", "ASDU per frame", baseline.Identity.AsduPerFrame,
             candidate.Identity.AsduPerFrame, SvEvidenceChangeSeverity.Warning, "ASDU packing changed.");
-        AddNullableChange(changes, "Identity", "Declared sample rate", baseline.Identity.DeclaredSampleRate,
+        UShortChange(changes, "Identity", "Declared sample rate", baseline.Identity.DeclaredSampleRate,
             candidate.Identity.DeclaredSampleRate, SvEvidenceChangeSeverity.Warning, "Declared sample rate changed.");
-        AddNullableChange(changes, "Identity", "Declared sample mode", baseline.Identity.DeclaredSampleMode,
+        UShortChange(changes, "Identity", "Declared sample mode", baseline.Identity.DeclaredSampleMode,
             candidate.Identity.DeclaredSampleMode, SvEvidenceChangeSeverity.Warning, "Declared sample mode changed.");
 
-        CompareIssueCounter(changes, "Sequence gaps", baseline.Runtime.SequenceGapCount, candidate.Runtime.SequenceGapCount,
+        IssueCounter(changes, "Sequence gaps", baseline.Runtime.SequenceGapCount, candidate.Runtime.SequenceGapCount,
             SvEvidenceChangeSeverity.Warning);
-        CompareIssueCounter(changes, "Duplicates", baseline.Runtime.DuplicateCount, candidate.Runtime.DuplicateCount,
+        IssueCounter(changes, "Duplicates", baseline.Runtime.DuplicateCount, candidate.Runtime.DuplicateCount,
             SvEvidenceChangeSeverity.Warning);
-        CompareIssueCounter(changes, "Out-of-order", baseline.Runtime.OutOfOrderCount, candidate.Runtime.OutOfOrderCount,
+        IssueCounter(changes, "Out-of-order", baseline.Runtime.OutOfOrderCount, candidate.Runtime.OutOfOrderCount,
             SvEvidenceChangeSeverity.Error);
-        CompareIssueCounter(changes, "Payload issues", baseline.Runtime.PayloadIssueCount, candidate.Runtime.PayloadIssueCount,
+        IssueCounter(changes, "Payload issues", baseline.Runtime.PayloadIssueCount, candidate.Runtime.PayloadIssueCount,
             SvEvidenceChangeSeverity.Error);
-        CompareIssueCounter(changes, "SCL mismatches", baseline.Runtime.SclMismatchCount, candidate.Runtime.SclMismatchCount,
+        IssueCounter(changes, "SCL mismatches", baseline.Runtime.SclMismatchCount, candidate.Runtime.SclMismatchCount,
             SvEvidenceChangeSeverity.Warning);
-        CompareRate(changes, "Observed frames/s", baseline.Observation.Facts.ObservedFramesPerSecond,
+
+        RateChange(changes, "Observed frames/s", baseline.Observation.Facts.ObservedFramesPerSecond,
             candidate.Observation.Facts.ObservedFramesPerSecond);
-        CompareRate(changes, "Observed samples/s", baseline.Observation.Facts.ObservedSamplesPerSecond,
+        RateChange(changes, "Observed samples/s", baseline.Observation.Facts.ObservedSamplesPerSecond,
             candidate.Observation.Facts.ObservedSamplesPerSecond);
-        CompareWindow(changes, baseline.Observation, candidate.Observation);
-        CompareBinding(changes, baseline.Observation, candidate.Observation);
-        CompareProfile(changes, baseline.Observation.ProfileDetection, candidate.Observation.ProfileDetection);
-        CompareConfiguration(changes, baseline.Observation.ConfigurationComparison,
+        WindowChanges(changes, baseline.Observation, candidate.Observation);
+        BindingChanges(changes, baseline.Observation, candidate.Observation);
+        ProfileChanges(changes, baseline.Observation.ProfileDetection, candidate.Observation.ProfileDetection);
+        ConfigurationChanges(changes, baseline.Observation.ConfigurationComparison,
             candidate.Observation.ConfigurationComparison);
-        CompareFacts(changes, baseline.Observation.Facts, candidate.Observation.Facts);
-        CompareDiagnostics(changes, baseline.Diagnostics.Concat(baseline.Observation.Diagnostics),
+        FactChanges(changes, baseline.Observation.Facts, candidate.Observation.Facts);
+        DiagnosticChanges(changes,
+            baseline.Diagnostics.Concat(baseline.Observation.Diagnostics),
             candidate.Diagnostics.Concat(candidate.Observation.Diagnostics));
 
-        var kind = changes.Count == 0 ? SvEvidenceChangeKind.Unchanged : SvEvidenceChangeKind.Changed;
+        var logicalKey = LogicalKey(candidate);
         return new SvSubscriberStreamComparison
         {
-            ComparisonKey = LogicalKey(candidate),
-            Kind = kind,
-            Severity = MaximumSeverity(changes),
+            ComparisonKey = $"PAIR|{baseline.Key}|{candidate.Key}",
+            LogicalStreamKey = logicalKey,
+            Kind = changes.Count == 0 ? SvEvidenceChangeKind.Unchanged : SvEvidenceChangeKind.Changed,
+            Severity = changes.Select(change => change.Severity)
+                .DefaultIfEmpty(SvEvidenceChangeSeverity.Info).Max(),
             BaselineStreamKey = baseline.Key,
             CandidateStreamKey = candidate.Key,
             Identity = candidate.Identity,
@@ -282,7 +284,7 @@ private static SvSubscriberStreamComparison ComparePair(
         };
     }
 
-    private static void CompareWindow(
+    private static void WindowChanges(
         ICollection<SvEvidenceFieldChange> changes,
         SvSubscriberObservationEvidence baseline,
         SvSubscriberObservationEvidence candidate)
@@ -292,7 +294,7 @@ private static void CompareWindow(
             var severity = baseline.WindowSamples > 0 && candidate.WindowSamples < baseline.WindowSamples / 2
                 ? SvEvidenceChangeSeverity.Warning
                 : SvEvidenceChangeSeverity.Info;
-            Add(changes, "Observation window", "Samples", severity,
+            Change(changes, "Observation window", "Samples", severity,
                 baseline.WindowSamples.ToString(CultureInfo.InvariantCulture),
                 candidate.WindowSamples.ToString(CultureInfo.InvariantCulture),
                 severity == SvEvidenceChangeSeverity.Warning
@@ -300,15 +302,19 @@ private static void CompareWindow(
                     : "Observation-window sample count changed.");
         }
 
-        if (!ApproximatelyEqual(baseline.WindowDurationSeconds, candidate.WindowDurationSeconds, 0.01))
+        if (!WithinPercent(baseline.WindowDurationSeconds, candidate.WindowDurationSeconds, 0.01))
         {
-            Add(changes, "Observation window", "Duration", SvEvidenceChangeSeverity.Info,
+            Change(changes, "Observation window", "Duration", SvEvidenceChangeSeverity.Info,
                 Number(baseline.WindowDurationSeconds), Number(candidate.WindowDurationSeconds),
                 "Observation-window duration changed.");
         }
+
+        TextChange(changes, "Observation window", "Input kinds",
+            string.Join(", ", baseline.InputKinds), string.Join(", ", candidate.InputKinds),
+            SvEvidenceChangeSeverity.Info, "Observation input provenance changed.");
     }
 
-    private static void CompareBinding(
+    private static void BindingChanges(
         ICollection<SvEvidenceFieldChange> changes,
         SvSubscriberObservationEvidence baseline,
         SvSubscriberObservationEvidence candidate)
@@ -318,7 +324,7 @@ private static void CompareBinding(
             var severity = baseline.IsBoundToScl && !candidate.IsBoundToScl
                 ? SvEvidenceChangeSeverity.Warning
                 : SvEvidenceChangeSeverity.Info;
-            Add(changes, "SCL", "Binding", severity,
+            Change(changes, "SCL", "Binding", severity,
                 baseline.IsBoundToScl ? "bound" : "not bound",
                 candidate.IsBoundToScl ? "bound" : "not bound",
                 severity == SvEvidenceChangeSeverity.Warning
@@ -326,19 +332,18 @@ private static void CompareBinding(
                     : "Candidate stream gained an SCL binding.");
         }
 
-        AddTextChange(changes, "SCL", "Control block", baseline.ControlBlockReference,
+        TextChange(changes, "SCL", "Control block", baseline.ControlBlockReference,
             candidate.ControlBlockReference, SvEvidenceChangeSeverity.Info,
             "SCL control-block reference changed.");
     }
 
-    private static void CompareProfile(
+    private static void ProfileChanges(
         ICollection<SvEvidenceFieldChange> changes,
         SvProfileDetectionResult? baseline,
         SvProfileDetectionResult? candidate)
     {
-        AddTextChange(changes, "Profile", "Profile ID", baseline?.Profile.Id ?? string.Empty,
-            candidate?.Profile.Id ?? string.Empty, SvEvidenceChangeSeverity.Warning,
-            "Detected profile changed.");
+        TextChange(changes, "Profile", "Profile ID", baseline?.Profile.Id, candidate?.Profile.Id,
+            SvEvidenceChangeSeverity.Warning, "Detected profile changed.");
 
         var baselineConfidence = baseline?.Confidence ?? SvProfileConfidence.Unknown;
         var candidateConfidence = candidate?.Confidence ?? SvProfileConfidence.Unknown;
@@ -350,16 +355,16 @@ private static void CompareProfile(
             : ConfidenceRank(candidateConfidence) < ConfidenceRank(baselineConfidence)
                 ? SvEvidenceChangeSeverity.Warning
                 : SvEvidenceChangeSeverity.Info;
-        Add(changes, "Profile", "Confidence", severity, baselineConfidence.ToString(),
-            candidateConfidence.ToString(),
+        Change(changes, "Profile", "Confidence", severity,
+            baselineConfidence.ToString(), candidateConfidence.ToString(),
             severity == SvEvidenceChangeSeverity.Error
-                ? "Candidate profile classification is conflicting."
+                ? "Candidate profile classification conflicts with observed evidence."
                 : severity == SvEvidenceChangeSeverity.Warning
                     ? "Candidate profile confidence decreased."
                     : "Candidate profile confidence improved.");
     }
 
-    private static void CompareConfiguration(
+    private static void ConfigurationChanges(
         ICollection<SvEvidenceFieldChange> changes,
         SvConfigurationComparisonResult? baseline,
         SvConfigurationComparisonResult? candidate)
@@ -370,76 +375,75 @@ private static void CompareConfiguration(
             baseline?.Mode == candidate?.Mode)
             return;
 
-        var introducedBlocking = candidate?.HasBlockingErrors == true && baseline?.HasBlockingErrors != true;
-        var warningIncrease = (candidate?.WarningCount ?? 0) > (baseline?.WarningCount ?? 0);
-        var severity = introducedBlocking
+        var blockingIntroduced = candidate?.HasBlockingErrors == true && baseline?.HasBlockingErrors != true;
+        var warningsIncreased = (candidate?.WarningCount ?? 0) > (baseline?.WarningCount ?? 0);
+        var severity = blockingIntroduced
             ? SvEvidenceChangeSeverity.Error
-            : warningIncrease || (baseline is not null && candidate is null)
+            : warningsIncreased || (baseline is not null && candidate is null)
                 ? SvEvidenceChangeSeverity.Warning
                 : SvEvidenceChangeSeverity.Info;
-        Add(changes, "Configuration", "Comparison", severity, baselineSummary, candidateSummary,
-            introducedBlocking
+        Change(changes, "Configuration", "Comparison", severity, baselineSummary, candidateSummary,
+            blockingIntroduced
                 ? "Candidate introduced blocking configuration errors."
                 : severity == SvEvidenceChangeSeverity.Warning
                     ? "Candidate configuration evidence regressed."
                     : "Configuration comparison result changed.");
     }
 
-    private static void CompareFacts(
+    private static void FactChanges(
         ICollection<SvEvidenceFieldChange> changes,
         SvObservedStreamFacts baseline,
         SvObservedStreamFacts candidate)
     {
-        AddNullableChange(changes, "Observed facts", "Payload bytes per ASDU",
-            baseline.PayloadBytesPerAsdu, candidate.PayloadBytesPerAsdu,
-            SvEvidenceChangeSeverity.Warning, "Observed payload length changed.");
-        AddNullableChange(changes, "Observed facts", "Counter wrap", baseline.ObservedCounterWrap,
-            candidate.ObservedCounterWrap, SvEvidenceChangeSeverity.Warning,
-            "Observed sample-counter wrap changed.");
-        AddNullableChange(changes, "Observed facts", "Nominal frequency", baseline.NominalFrequencyHz,
-            candidate.NominalFrequencyHz, SvEvidenceChangeSeverity.Warning,
-            "Nominal-frequency context changed.");
-
-        var baselineSignature = Signature(baseline.DataSetSignature);
-        var candidateSignature = Signature(candidate.DataSetSignature);
-        AddTextChange(changes, "Observed facts", "Dataset signature", baselineSignature,
-            candidateSignature, SvEvidenceChangeSeverity.Error,
+        IntChange(changes, "Observed facts", "Payload bytes per ASDU", baseline.PayloadBytesPerAsdu,
+            candidate.PayloadBytesPerAsdu, SvEvidenceChangeSeverity.Warning, "Observed payload length changed.");
+        IntChange(changes, "Observed facts", "Counter wrap", baseline.ObservedCounterWrap,
+            candidate.ObservedCounterWrap, SvEvidenceChangeSeverity.Warning, "Observed sample-counter wrap changed.");
+        DoubleChange(changes, "Observed facts", "Nominal frequency", baseline.NominalFrequencyHz,
+            candidate.NominalFrequencyHz, SvEvidenceChangeSeverity.Warning, "Nominal-frequency context changed.");
+        TextChange(changes, "Observed facts", "Dataset signature", Signature(baseline.DataSetSignature),
+            Signature(candidate.DataSetSignature), SvEvidenceChangeSeverity.Error,
             "Observed dataset element order or types changed.");
 
-        var provenanceKeys = baseline.Provenance.Keys.Concat(candidate.Provenance.Keys)
-            .Distinct(StringComparer.Ordinal);
-        foreach (var key in provenanceKeys)
+        foreach (var key in baseline.Provenance.Keys.Concat(candidate.Provenance.Keys)
+                     .Distinct(StringComparer.Ordinal))
         {
             var baselineSource = baseline.Provenance.TryGetValue(key, out var b) ? b : SvFactSource.Unknown;
             var candidateSource = candidate.Provenance.TryGetValue(key, out var c) ? c : SvFactSource.Unknown;
             if (baselineSource != candidateSource)
             {
-                Add(changes, "Provenance", key, SvEvidenceChangeSeverity.Info,
-                    baselineSource.ToString(), candidateSource.ToString(),
-                    "Fact provenance changed.");
+                Change(changes, "Provenance", key, SvEvidenceChangeSeverity.Info,
+                    baselineSource.ToString(), candidateSource.ToString(), "Fact provenance changed.");
             }
         }
     }
 
-    private static void CompareDiagnostics(
+    private static void DiagnosticChanges(
         ICollection<SvEvidenceFieldChange> changes,
         IEnumerable<string> baseline,
         IEnumerable<string> candidate)
     {
-        var baselineSet = baseline.Where(item => !string.IsNullOrWhiteSpace(item))
+        var baselineSet = baseline.Where(value => !string.IsNullOrWhiteSpace(value))
             .ToHashSet(StringComparer.Ordinal);
-        var candidateSet = candidate.Where(item => !string.IsNullOrWhiteSpace(item))
+        var candidateSet = candidate.Where(value => !string.IsNullOrWhiteSpace(value))
             .ToHashSet(StringComparer.Ordinal);
 
-        foreach (var added in candidateSet.Except(baselineSet, StringComparer.Ordinal).Order(StringComparer.Ordinal))
-            Add(changes, "Diagnostics", "Added", SvEvidenceChangeSeverity.Warning, "-", added,
-                "Candidate introduced a diagnostic.");
-        foreach (var removed in baselineSet.Except(candidateSet, StringComparer.Ordinal).Order(StringComparer.Ordinal))
-            Add(changes, "Diagnostics", "Resolved", SvEvidenceChangeSeverity.Info, removed, "-",
-                "A baseline diagnostic is no longer present.");
+        foreach (var value in candidateSet.Except(baselineSet, StringComparer.Ordinal)
+                     .OrderBy(value => value, StringComparer.Ordinal))
+        {
+            Change(changes, "Diagnostics", "Added", SvEvidenceChangeSeverity.Warning,
+                "-", value, "Candidate introduced a diagnostic.");
+        }
+
+        foreach (var value in baselineSet.Except(candidateSet, StringComparer.Ordinal)
+                     .OrderBy(value => value, StringComparer.Ordinal))
+        {
+            Change(changes, "Diagnostics", "Resolved", SvEvidenceChangeSeverity.Info,
+                value, "-", "A baseline diagnostic is no longer present.");
+        }
     }
 
-    private static void CompareIssueCounter(
+    private static void IssueCounter(
         ICollection<SvEvidenceFieldChange> changes,
         string field,
         int baseline,
@@ -449,13 +453,12 @@ private static void CompareIssueCounter(
         if (baseline == candidate)
             return;
         var severity = candidate > baseline ? regressionSeverity : SvEvidenceChangeSeverity.Info;
-        Add(changes, "Runtime integrity", field, severity,
-            baseline.ToString(CultureInfo.InvariantCulture),
-            candidate.ToString(CultureInfo.InvariantCulture),
+        Change(changes, "Runtime integrity", field, severity,
+            baseline.ToString(CultureInfo.InvariantCulture), candidate.ToString(CultureInfo.InvariantCulture),
             candidate > baseline ? $"Candidate {field.ToLowerInvariant()} increased." : $"Candidate {field.ToLowerInvariant()} decreased.");
     }
 
-    private static void CompareRate(
+    private static void RateChange(
         ICollection<SvEvidenceFieldChange> changes,
         string field,
         double? baseline,
@@ -465,61 +468,100 @@ private static void CompareRate(
             return;
         if (!baseline.HasValue || !candidate.HasValue)
         {
-            Add(changes, "Observed rate", field, SvEvidenceChangeSeverity.Warning,
+            Change(changes, "Observed rate", field, SvEvidenceChangeSeverity.Warning,
                 Number(baseline), Number(candidate), "Observed rate availability changed.");
             return;
         }
-        if (ApproximatelyEqual(baseline.Value, candidate.Value, RateTolerancePercent))
+        if (WithinPercent(baseline.Value, candidate.Value, RateTolerancePercent))
             return;
 
-        Add(changes, "Observed rate", field, SvEvidenceChangeSeverity.Warning,
+        Change(changes, "Observed rate", field, SvEvidenceChangeSeverity.Warning,
             Number(baseline), Number(candidate),
             $"Observed rate changed by more than {RateTolerancePercent:0.###}%.");
     }
 
-    private static void AddHealthChange(
+    private static void HealthChange(
         ICollection<SvEvidenceFieldChange> changes,
         string category,
-        string baseline,
-        string candidate)
+        string? baseline,
+        string? candidate)
     {
         if (string.Equals(baseline, candidate, StringComparison.OrdinalIgnoreCase))
             return;
-        var severity = HealthRank(candidate) > HealthRank(baseline)
-            ? HealthRank(candidate) >= 2 ? SvEvidenceChangeSeverity.Error : SvEvidenceChangeSeverity.Warning
+        var candidateRank = HealthRank(candidate);
+        var severity = candidateRank > HealthRank(baseline)
+            ? candidateRank >= 2 ? SvEvidenceChangeSeverity.Error : SvEvidenceChangeSeverity.Warning
             : SvEvidenceChangeSeverity.Info;
-        Add(changes, category, "Health", severity, baseline, candidate,
+        Change(changes, category, "Health", severity, Text(baseline), Text(candidate),
             severity == SvEvidenceChangeSeverity.Info ? "Health improved or changed without regression." : "Health regressed.");
     }
 
-    private static void AddTextChange(
+    private static void TextChange(
         ICollection<SvEvidenceFieldChange> changes,
         string category,
         string field,
-        string baseline,
-        string candidate,
+        string? baseline,
+        string? candidate,
         SvEvidenceChangeSeverity severity,
         string message)
     {
         if (!string.Equals(baseline ?? string.Empty, candidate ?? string.Empty, StringComparison.Ordinal))
-            Add(changes, category, field, severity, Empty(baseline), Empty(candidate), message);
+            Change(changes, category, field, severity, Text(baseline), Text(candidate), message);
+    }
+
+    private static void IntChange(
+        ICollection<SvEvidenceFieldChange> changes,
+        string category,
+        string field,
+        int? baseline,
+        int? candidate,
+        SvEvidenceChangeSeverity severity,
+        string message)
+    {
+        if (baseline != candidate)
+            Change(changes, category, field, severity, Value(baseline), Value(candidate), message);
     }
 
-    private static void AddNullableChange<T>(
+    private static void UIntChange(
         ICollection<SvEvidenceFieldChange> changes,
         string category,
         string field,
-        T? baseline,
-        T? candidate,
+        uint? baseline,
+        uint? candidate,
         SvEvidenceChangeSeverity severity,
         string message)
-        where T : struct, IEquatable<T>
     {
-        if (!Nullable.Equals(baseline, candidate))
-            Add(changes, category, field, severity, Value(baseline), Value(candidate), message);
+        if (baseline != candidate)
+            Change(changes, category, field, severity, Value(baseline), Value(candidate), message);
     }
 
-    private static void Add(
+    private static void UShortChange(
+        ICollection<SvEvidenceFieldChange> changes,
+        string category,
+        string field,
+        ushort? baseline,
+        ushort? candidate,
+        SvEvidenceChangeSeverity severity,
+        string message)
+    {
+        if (baseline != candidate)
+            Change(changes, category, field, severity, Value(baseline), Value(candidate), message);
+    }
+
+    private static void DoubleChange(
+        ICollection<SvEvidenceFieldChange> changes,
+        string category,
+        string field,
+        double? baseline,
+        double? candidate,
+        SvEvidenceChangeSeverity severity,
+        string message)
+    {
+        if (baseline != candidate)
+            Change(changes, category, field, severity, Number(baseline), Number(candidate), message);
+    }
+
+    private static void Change(
         ICollection<SvEvidenceFieldChange> changes,
         string category,
         string field,
@@ -538,9 +580,12 @@ private static void Add(
         });
 
     private static SvSubscriberStreamComparison Added(SvSubscriberStreamEvidence stream)
-        => new()
+    {
+        var logicalKey = LogicalKey(stream);
+        return new SvSubscriberStreamComparison
         {
-            ComparisonKey = LogicalKey(stream),
+            ComparisonKey = $"ADD|{stream.Key}",
+            LogicalStreamKey = logicalKey,
             Kind = SvEvidenceChangeKind.Added,
             Severity = SvEvidenceChangeSeverity.Info,
             CandidateStreamKey = stream.Key,
@@ -558,11 +603,15 @@ private static SvSubscriberStreamComparison Added(SvSubscriberStreamEvidence str
                 }
             ]
         };
+    }
 
     private static SvSubscriberStreamComparison Removed(SvSubscriberStreamEvidence stream)
-        => new()
+    {
+        var logicalKey = LogicalKey(stream);
+        return new SvSubscriberStreamComparison
         {
-            ComparisonKey = LogicalKey(stream),
+            ComparisonKey = $"REMOVE|{stream.Key}",
+            LogicalStreamKey = logicalKey,
             Kind = SvEvidenceChangeKind.Removed,
             Severity = SvEvidenceChangeSeverity.Error,
             BaselineStreamKey = stream.Key,
@@ -580,8 +629,9 @@ private static SvSubscriberStreamComparison Removed(SvSubscriberStreamEvidence s
                 }
             ]
         };
+    }
 
-    private static SvEvidenceReportReference ToReference(SvSubscriberEvidenceReport report)
+    private static SvEvidenceReportReference Reference(SvSubscriberEvidenceReport report)
         => new()
         {
             SchemaVersion = report.SchemaVersion,
@@ -594,24 +644,21 @@ private static SvEvidenceReportReference ToReference(SvSubscriberEvidenceReport
             StreamCount = report.Streams.Count
         };
 
-    private static SvEvidenceChangeSeverity MaximumSeverity(IEnumerable<SvEvidenceFieldChange> changes)
-        => changes.Select(change => change.Severity).DefaultIfEmpty(SvEvidenceChangeSeverity.Info).Max();
-
     private static string LogicalKey(SvSubscriberStreamEvidence stream)
     {
         var identity = stream.Identity;
         var vlan = identity.VlanId?.ToString(CultureInfo.InvariantCulture) ?? "-";
         return $"SV|{identity.AppId:X4}|{NormalizeMac(identity.DestinationMac)}|{vlan}|" +
-               $"{NormalizeIdentifier(identity.SvId)}|{NormalizeIdentifier(identity.DataSetReference)}";
+               $"{NormalizeId(identity.SvId)}|{NormalizeId(identity.DataSetReference)}";
     }
 
-    private static string NormalizeMac(string value)
+    private static string NormalizeMac(string? value)
         => new((value ?? string.Empty).Where(Uri.IsHexDigit).Select(char.ToUpperInvariant).ToArray());
 
-    private static string NormalizeIdentifier(string value)
+    private static string NormalizeId(string? value)
         => (value ?? string.Empty).Trim().ToUpperInvariant();
 
-    private static int HealthRank(string value)
+    private static int HealthRank(string? value)
         => (value ?? string.Empty).Trim().ToUpperInvariant() switch
         {
             "GOOD" => 0,
@@ -634,7 +681,7 @@ private static int ConfidenceRank(SvProfileConfidence value)
             _ => 0
         };
 
-    private static bool ApproximatelyEqual(double baseline, double candidate, double tolerancePercent)
+    private static bool WithinPercent(double baseline, double candidate, double tolerancePercent)
     {
         if (baseline == 0)
             return candidate == 0;
@@ -656,172 +703,6 @@ private static string Number(double value)
     private static string Value<T>(T? value) where T : struct
         => value.HasValue ? Convert.ToString(value.Value, CultureInfo.InvariantCulture) ?? "unknown" : "unknown";
 
-    private static string Empty(string? value)
+    private static string Text(string? value)
         => string.IsNullOrWhiteSpace(value) ? "unknown" : value;
 }
-
-public static class SvSubscriberEvidenceComparisonSerializer
-{
-    private static readonly JsonSerializerOptions JsonOptions = CreateJsonOptions();
-
-    public static string ToJson(SvSubscriberEvidenceComparison comparison)
-    {
-        ArgumentNullException.ThrowIfNull(comparison);
-        comparison.Validate();
-        return JsonSerializer.Serialize(comparison, JsonOptions);
-    }
-
-    public static SvSubscriberEvidenceComparison FromJson(string json)
-    {
-        if (string.IsNullOrWhiteSpace(json))
-            throw new ArgumentException("SV comparison JSON cannot be empty.", nameof(json));
-        var comparison = JsonSerializer.Deserialize<SvSubscriberEvidenceComparison>(json, JsonOptions)
-            ?? throw new InvalidDataException("SV comparison JSON did not contain a comparison document.");
-        comparison.Validate();
-        return comparison;
-    }
-
-    public static string ToMarkdown(SvSubscriberEvidenceComparison comparison)
-    {
-        ArgumentNullException.ThrowIfNull(comparison);
-        comparison.Validate();
-
-        var builder = new StringBuilder();
-        builder.AppendLine("# ARSVIN Subscriber Evidence Comparison");
-        builder.AppendLine();
-        builder.AppendLine("> Baseline-versus-candidate engineering evidence. Warnings and errors identify regressions for review; this is not a formal IEC 61850 conformance certificate.");
-        builder.AppendLine();
-        builder.AppendLine("## Comparison metadata");
-        builder.AppendLine();
-        AppendKeyValueTable(builder,
-        [
-            ("Schema", comparison.SchemaVersion),
-            ("Generated", Timestamp(comparison.GeneratedAt)),
-            ("Baseline generated", Timestamp(comparison.Baseline.GeneratedAt)),
-            ("Baseline version", comparison.Baseline.Version),
-            ("Baseline commit", comparison.Baseline.Commit),
-            ("Baseline capture", comparison.Baseline.CaptureSource),
-            ("Candidate generated", Timestamp(comparison.Candidate.GeneratedAt)),
-            ("Candidate version", comparison.Candidate.Version),
-            ("Candidate commit", comparison.Candidate.Commit),
-            ("Candidate capture", comparison.Candidate.CaptureSource)
-        ]);
-
-        builder.AppendLine("## Summary");
-        builder.AppendLine();
-        AppendKeyValueTable(builder,
-        [
-            ("Baseline streams", comparison.Summary.BaselineStreamCount.ToString(CultureInfo.InvariantCulture)),
-            ("Candidate streams", comparison.Summary.CandidateStreamCount.ToString(CultureInfo.InvariantCulture)),
-            ("Added", comparison.Summary.AddedStreamCount.ToString(CultureInfo.InvariantCulture)),
-            ("Removed", comparison.Summary.RemovedStreamCount.ToString(CultureInfo.InvariantCulture)),
-            ("Changed", comparison.Summary.ChangedStreamCount.ToString(CultureInfo.InvariantCulture)),
-            ("Unchanged", comparison.Summary.UnchangedStreamCount.ToString(CultureInfo.InvariantCulture)),
-            ("Info changes", comparison.Summary.InfoChangeCount.ToString(CultureInfo.InvariantCulture)),
-            ("Warnings", comparison.Summary.WarningChangeCount.ToString(CultureInfo.InvariantCulture)),
-            ("Errors", comparison.Summary.ErrorChangeCount.ToString(CultureInfo.InvariantCulture)),
-            ("Regression status", comparison.Summary.HasRegressions ? "REVIEW REQUIRED" : "NO REGRESSION DETECTED")
-        ]);
-
-        AppendChanges(builder, "Report-level changes", comparison.ReportChanges);
-
-        builder.AppendLine("## Stream comparison");
-        builder.AppendLine();
-        builder.AppendLine("| Kind | Severity | APPID | svID | Dataset | Changes |");
-        builder.AppendLine("|---|---|---:|---|---|---:|");
-        foreach (var stream in comparison.Streams)
-        {
-            builder.Append("| ").Append(Cell(stream.Kind.ToString()))
-                .Append(" | ").Append(Cell(stream.Severity.ToString()))
-                .Append(" | 0x").Append(stream.Identity.AppId.ToString("X4", CultureInfo.InvariantCulture))
-                .Append(" | ").Append(Cell(stream.Identity.SvId))
-                .Append(" | ").Append(Cell(stream.Identity.DataSetReference))
-                .Append(" | ").Append(stream.Changes.Count.ToString(CultureInfo.InvariantCulture)).AppendLine(" |");
-        }
-        builder.AppendLine();
-
-        foreach (var stream in comparison.Streams.Where(stream => stream.Changes.Count > 0))
-        {
-            builder.Append("## 0x").Append(stream.Identity.AppId.ToString("X4", CultureInfo.InvariantCulture))
-                .Append(" — ").AppendLine(Heading(stream.Identity.SvId));
-            builder.AppendLine();
-            AppendKeyValueTable(builder,
-            [
-                ("Kind", stream.Kind.ToString()),
-                ("Severity", stream.Severity.ToString()),
-                ("Logical key", stream.ComparisonKey),
-                ("Baseline stream key", Empty(stream.BaselineStreamKey)),
-                ("Candidate stream key", Empty(stream.CandidateStreamKey)),
-                ("Destination MAC", stream.Identity.DestinationMac),
-                ("VLAN", stream.Identity.VlanId?.ToString(CultureInfo.InvariantCulture) ?? "untagged"),
-                ("Dataset", stream.Identity.DataSetReference)
-            ]);
-            AppendChanges(builder, "Changes", stream.Changes);
-        }
-
-        return builder.ToString();
-    }
-
-    private static void AppendChanges(
-        StringBuilder builder,
-        string title,
-        IReadOnlyList<SvEvidenceFieldChange> changes)
-    {
-        builder.Append("## ").AppendLine(title);
-        builder.AppendLine();
-        if (changes.Count == 0)
-        {
-            builder.AppendLine("- No changes.");
-            builder.AppendLine();
-            return;
-        }
-
-        builder.AppendLine("| Severity | Category | Field | Baseline | Candidate | Message |");
-        builder.AppendLine("|---|---|---|---|---|---|");
-        foreach (var change in changes)
-        {
-            builder.Append("| ").Append(Cell(change.Severity.ToString()))
-                .Append(" | ").Append(Cell(change.Category))
-                .Append(" | ").Append(Cell(change.Field))
-                .Append(" | ").Append(Cell(change.Baseline))
-                .Append(" | ").Append(Cell(change.Candidate))
-                .Append(" | ").Append(Cell(change.Message)).AppendLine(" |");
-        }
-        builder.AppendLine();
-    }
-
-    private static void AppendKeyValueTable(StringBuilder builder, IEnumerable<(string Key, string Value)> rows)
-    {
-        builder.AppendLine("| Field | Value |");
-        builder.AppendLine("|---|---|");
-        foreach (var row in rows)
-            builder.Append("| ").Append(Cell(row.Key)).Append(" | ").Append(Cell(Empty(row.Value))).AppendLine(" |");
-        builder.AppendLine();
-    }
-
-    private static JsonSerializerOptions CreateJsonOptions()
-    {
-        var options = new JsonSerializerOptions
-        {
-            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
-            WriteIndented = true
-        };
-        options.Converters.Add(new JsonStringEnumConverter(JsonNamingPolicy.CamelCase));
-        return options;
-    }
-
-    private static string Timestamp(DateTimeOffset value)
-        => value.ToString("yyyy-MM-dd HH:mm:ss.fff zzz", CultureInfo.InvariantCulture);
-
-    private static string Empty(string? value)
-        => string.IsNullOrWhiteSpace(value) ? "-" : value;
-
-    private static string Cell(string? value)
-        => Empty(value).Replace("|", "\\|", StringComparison.Ordinal)
-            .Replace("\r", " ", StringComparison.Ordinal)
-            .Replace("\n", " ", StringComparison.Ordinal);
-
-    private static string Heading(string? value)
-        => Empty(value).Replace("\r", " ", StringComparison.Ordinal)
-            .Replace("\n", " ", StringComparison.Ordinal);
-}

From 524a2983e00cfe31085245f2597a150e2a04c98b Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 04:50:56 +0700
Subject: [PATCH 35/39] Add P3F comparison serializers

---
 ...vSubscriberEvidenceComparisonSerializer.cs | 177 ++++++++++++++++++
 1 file changed, 177 insertions(+)
 create mode 100644 src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceComparisonSerializer.cs

diff --git a/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceComparisonSerializer.cs b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceComparisonSerializer.cs
new file mode 100644
index 0000000..7d75820
--- /dev/null
+++ b/src/ARSVIN.Engine/AR.Iec61850/SampledValues/Reporting/SvSubscriberEvidenceComparisonSerializer.cs
@@ -0,0 +1,177 @@
+using System.Globalization;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace AR.Iec61850.SampledValues.Reporting;
+
+public static class SvSubscriberEvidenceComparisonSerializer
+{
+    private static readonly JsonSerializerOptions JsonOptions = CreateJsonOptions();
+
+    public static string ToJson(SvSubscriberEvidenceComparison comparison)
+    {
+        ArgumentNullException.ThrowIfNull(comparison);
+        comparison.Validate();
+        return JsonSerializer.Serialize(comparison, JsonOptions);
+    }
+
+    public static SvSubscriberEvidenceComparison FromJson(string json)
+    {
+        if (string.IsNullOrWhiteSpace(json))
+            throw new ArgumentException("SV comparison JSON cannot be empty.", nameof(json));
+
+        var comparison = JsonSerializer.Deserialize<SvSubscriberEvidenceComparison>(json, JsonOptions)
+            ?? throw new InvalidDataException("SV comparison JSON did not contain a comparison document.");
+        comparison.Validate();
+        return comparison;
+    }
+
+    public static string ToMarkdown(SvSubscriberEvidenceComparison comparison)
+    {
+        ArgumentNullException.ThrowIfNull(comparison);
+        comparison.Validate();
+
+        var builder = new StringBuilder();
+        builder.AppendLine("# ARSVIN Subscriber Evidence Comparison");
+        builder.AppendLine();
+        builder.AppendLine("> Baseline-versus-candidate engineering evidence. Warnings and errors identify regressions for review; this is not a formal IEC 61850 conformance certificate.");
+        builder.AppendLine();
+        builder.AppendLine("## Comparison metadata");
+        builder.AppendLine();
+        KeyValueTable(builder,
+        [
+            ("Schema", comparison.SchemaVersion),
+            ("Generated", Timestamp(comparison.GeneratedAt)),
+            ("Baseline generated", Timestamp(comparison.Baseline.GeneratedAt)),
+            ("Baseline version", comparison.Baseline.Version),
+            ("Baseline commit", comparison.Baseline.Commit),
+            ("Baseline capture", comparison.Baseline.CaptureSource),
+            ("Candidate generated", Timestamp(comparison.Candidate.GeneratedAt)),
+            ("Candidate version", comparison.Candidate.Version),
+            ("Candidate commit", comparison.Candidate.Commit),
+            ("Candidate capture", comparison.Candidate.CaptureSource)
+        ]);
+
+        builder.AppendLine("## Summary");
+        builder.AppendLine();
+        KeyValueTable(builder,
+        [
+            ("Baseline streams", comparison.Summary.BaselineStreamCount.ToString(CultureInfo.InvariantCulture)),
+            ("Candidate streams", comparison.Summary.CandidateStreamCount.ToString(CultureInfo.InvariantCulture)),
+            ("Added", comparison.Summary.AddedStreamCount.ToString(CultureInfo.InvariantCulture)),
+            ("Removed", comparison.Summary.RemovedStreamCount.ToString(CultureInfo.InvariantCulture)),
+            ("Changed", comparison.Summary.ChangedStreamCount.ToString(CultureInfo.InvariantCulture)),
+            ("Unchanged", comparison.Summary.UnchangedStreamCount.ToString(CultureInfo.InvariantCulture)),
+            ("Info changes", comparison.Summary.InfoChangeCount.ToString(CultureInfo.InvariantCulture)),
+            ("Warnings", comparison.Summary.WarningChangeCount.ToString(CultureInfo.InvariantCulture)),
+            ("Errors", comparison.Summary.ErrorChangeCount.ToString(CultureInfo.InvariantCulture)),
+            ("Regression status", comparison.Summary.HasRegressions ? "REVIEW REQUIRED" : "NO REGRESSION DETECTED")
+        ]);
+
+        Changes(builder, "Report-level changes", comparison.ReportChanges);
+
+        builder.AppendLine("## Stream comparison");
+        builder.AppendLine();
+        builder.AppendLine("| Kind | Severity | APPID | svID | Dataset | Changes |");
+        builder.AppendLine("|---|---|---:|---|---|---:|");
+        foreach (var stream in comparison.Streams)
+        {
+            builder.Append("| ").Append(Cell(stream.Kind.ToString()))
+                .Append(" | ").Append(Cell(stream.Severity.ToString()))
+                .Append(" | 0x").Append(stream.Identity.AppId.ToString("X4", CultureInfo.InvariantCulture))
+                .Append(" | ").Append(Cell(stream.Identity.SvId))
+                .Append(" | ").Append(Cell(stream.Identity.DataSetReference))
+                .Append(" | ").Append(stream.Changes.Count.ToString(CultureInfo.InvariantCulture))
+                .AppendLine(" |");
+        }
+        builder.AppendLine();
+
+        foreach (var stream in comparison.Streams.Where(stream => stream.Changes.Count > 0))
+        {
+            builder.Append("## 0x").Append(stream.Identity.AppId.ToString("X4", CultureInfo.InvariantCulture))
+                .Append(" — ").AppendLine(Heading(stream.Identity.SvId));
+            builder.AppendLine();
+            KeyValueTable(builder,
+            [
+                ("Kind", stream.Kind.ToString()),
+                ("Severity", stream.Severity.ToString()),
+                ("Logical stream key", stream.LogicalStreamKey),
+                ("Comparison key", stream.ComparisonKey),
+                ("Baseline stream key", Empty(stream.BaselineStreamKey)),
+                ("Candidate stream key", Empty(stream.CandidateStreamKey)),
+                ("Destination MAC", stream.Identity.DestinationMac),
+                ("VLAN", stream.Identity.VlanId?.ToString(CultureInfo.InvariantCulture) ?? "untagged"),
+                ("Dataset", stream.Identity.DataSetReference)
+            ]);
+            Changes(builder, "Changes", stream.Changes);
+        }
+
+        return builder.ToString();
+    }
+
+    private static void Changes(
+        StringBuilder builder,
+        string title,
+        IReadOnlyList<SvEvidenceFieldChange> changes)
+    {
+        builder.Append("## ").AppendLine(title);
+        builder.AppendLine();
+        if (changes.Count == 0)
+        {
+            builder.AppendLine("- No changes.");
+            builder.AppendLine();
+            return;
+        }
+
+        builder.AppendLine("| Severity | Category | Field | Baseline | Candidate | Message |");
+        builder.AppendLine("|---|---|---|---|---|---|");
+        foreach (var change in changes)
+        {
+            builder.Append("| ").Append(Cell(change.Severity.ToString()))
+                .Append(" | ").Append(Cell(change.Category))
+                .Append(" | ").Append(Cell(change.Field))
+                .Append(" | ").Append(Cell(change.Baseline))
+                .Append(" | ").Append(Cell(change.Candidate))
+                .Append(" | ").Append(Cell(change.Message)).AppendLine(" |");
+        }
+        builder.AppendLine();
+    }
+
+    private static void KeyValueTable(
+        StringBuilder builder,
+        IEnumerable<(string Key, string Value)> rows)
+    {
+        builder.AppendLine("| Field | Value |");
+        builder.AppendLine("|---|---|");
+        foreach (var row in rows)
+            builder.Append("| ").Append(Cell(row.Key)).Append(" | ").Append(Cell(Empty(row.Value))).AppendLine(" |");
+        builder.AppendLine();
+    }
+
+    private static JsonSerializerOptions CreateJsonOptions()
+    {
+        var options = new JsonSerializerOptions
+        {
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+            WriteIndented = true
+        };
+        options.Converters.Add(new JsonStringEnumConverter(JsonNamingPolicy.CamelCase));
+        return options;
+    }
+
+    private static string Timestamp(DateTimeOffset value)
+        => value.ToString("yyyy-MM-dd HH:mm:ss.fff zzz", CultureInfo.InvariantCulture);
+
+    private static string Empty(string? value)
+        => string.IsNullOrWhiteSpace(value) ? "-" : value;
+
+    private static string Cell(string? value)
+        => Empty(value).Replace("|", "\\|", StringComparison.Ordinal)
+            .Replace("\r", " ", StringComparison.Ordinal)
+            .Replace("\n", " ", StringComparison.Ordinal);
+
+    private static string Heading(string? value)
+        => Empty(value).Replace("\r", " ", StringComparison.Ordinal)
+            .Replace("\n", " ", StringComparison.Ordinal);
+}

From cd881d5ed9a3a8561472d421c0aff9f9bfac71b9 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 04:52:55 +0700
Subject: [PATCH 36/39] Remove temporary P3F compile diagnostics

---
 .github/workflows/p3f-compile-diagnostic.yml | 62 --------------------
 1 file changed, 62 deletions(-)
 delete mode 100644 .github/workflows/p3f-compile-diagnostic.yml

diff --git a/.github/workflows/p3f-compile-diagnostic.yml b/.github/workflows/p3f-compile-diagnostic.yml
deleted file mode 100644
index 22ea03c..0000000
--- a/.github/workflows/p3f-compile-diagnostic.yml
+++ /dev/null
@@ -1,62 +0,0 @@
-name: P3F Compile Diagnostic
-
-on:
-  pull_request:
-    branches: [ main ]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  compile-log:
-    runs-on: windows-2025
-    steps:
-      - name: Checkout
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-
-      - name: Setup .NET
-        uses: actions/setup-dotnet@26b0ec14cb23fa6904739307f278c14f94c95bf1 # v5
-        with:
-          dotnet-version: 8.0.4xx
-
-      - name: Restore
-        run: dotnet restore ARSVIN.sln --locked-mode
-
-      - name: Prepare diagnostic output
-        shell: pwsh
-        run: New-Item -ItemType Directory -Force artifacts | Out-Null
-
-      - name: Capture Publisher build log
-        id: publisher
-        continue-on-error: true
-        shell: pwsh
-        run: |
-          $PSNativeCommandUseErrorActionPreference = $false
-          dotnet build src/ARSVIN/ARSVIN.csproj -c Release --no-restore -warnaserror *> artifacts/p3f-publisher-build.log
-          "exit_code=$LASTEXITCODE" >> $env:GITHUB_OUTPUT
-          exit 0
-
-      - name: Capture Subscriber build log
-        id: subscriber
-        continue-on-error: true
-        shell: pwsh
-        run: |
-          $PSNativeCommandUseErrorActionPreference = $false
-          dotnet build src/ARSVIN.Subscriber/ARSVIN.Subscriber.csproj -c Release --no-restore -warnaserror *> artifacts/p3f-subscriber-build.log
-          "exit_code=$LASTEXITCODE" >> $env:GITHUB_OUTPUT
-          exit 0
-
-      - name: Upload complete compiler logs
-        if: always()
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
-        with:
-          name: p3f-compiler-logs
-          path: artifacts/p3f-*-build.log
-          if-no-files-found: error
-          retention-days: 1
-
-      - name: Enforce compiler results
-        if: steps.publisher.outputs.exit_code != '0' || steps.subscriber.outputs.exit_code != '0'
-        shell: pwsh
-        run: exit 1

From a394de671aebfaca943ae86c1917f4bd5a7bf518 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 05:01:47 +0700
Subject: [PATCH 37/39] Add one-shot PR 39 review fix workflow

---
 .github/workflows/apply-pr39-review-fixes.yml | 68 +++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 .github/workflows/apply-pr39-review-fixes.yml

diff --git a/.github/workflows/apply-pr39-review-fixes.yml b/.github/workflows/apply-pr39-review-fixes.yml
new file mode 100644
index 0000000..43e933f
--- /dev/null
+++ b/.github/workflows/apply-pr39-review-fixes.yml
@@ -0,0 +1,68 @@
+name: Apply PR 39 Review Fixes
+
+on:
+  push:
+    branches:
+      - agent/p3c-scl-expected-configuration
+
+permissions:
+  contents: write
+
+jobs:
+  apply-fixes:
+    if: github.actor != 'github-actions[bot]'
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Checkout branch
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
+        with:
+          ref: agent/p3c-scl-expected-configuration
+          fetch-depth: 0
+
+      - name: Apply exact review fixes
+        shell: python
+        run: |
+          from pathlib import Path
+
+          def replace_exact(path: str, old: str, new: str) -> None:
+              file = Path(path)
+              text = file.read_text(encoding="utf-8")
+              count = text.count(old)
+              if count != 1:
+                  raise SystemExit(f"Expected exactly one match in {path}, found {count}")
+              file.write_text(text.replace(old, new), encoding="utf-8")
+
+          replace_exact(
+              "src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs",
+              "        return addressCandidates.Length == 1 ? addressCandidates[0] : null;\n",
+              "        return null;\n")
+
+          report_path = "src/ARSVIN.Subscriber/Reporting/SvSubscriberReportBuilder.cs"
+          replace_exact(
+              report_path,
+              "        var configurationComparison = observation?.ConfigurationComparison ?? stream.ConfigurationComparison;\n        var diagnostics = stream.Diagnostics.Concat(observationDiagnostics)",
+              "        var configurationComparison = observation?.ConfigurationComparison ?? stream.ConfigurationComparison;\n        var health = ResolveHealth(stream, observation, configurationComparison);\n        var healthDetail = ResolveHealthDetail(stream, observation, configurationComparison, health);\n        var diagnostics = stream.Diagnostics.Concat(observationDiagnostics)")
+          replace_exact(
+              report_path,
+              "            Health = stream.Health,\n            HealthDetail = stream.HealthDetail,",
+              "            Health = health,\n            HealthDetail = healthDetail,")
+          replace_exact(
+              report_path,
+              "                WindowSamples = stream.ObservationWindowSamples,",
+              "                WindowSamples = ResolveWindowSamples(facts, stream.ObservationWindowSamples),")
+
+          helpers = '''    private static int ResolveWindowSamples(SvObservedStreamFacts facts, int fallback)\n    {\n        if (facts.ObservationCount > 0)\n            return facts.ObservationCount * Math.Max(1, facts.AsduPerFrame ?? 1);\n        return Math.Max(0, fallback);\n    }\n\n    private static string ResolveHealth(\n        SvStreamSnapshot stream,\n        SvStreamObservationSnapshot? observation,\n        SvConfigurationComparisonResult? comparison)\n    {\n        var hasRuntimeError = stream.PayloadIssueCount > 0 || stream.OutOfOrderCount > 0;\n        var hasRuntimeWarning = stream.SequenceGapCount > 0 || stream.DuplicateCount > 0;\n        var isConfigured = observation?.IsBoundToScl ?? stream.IsBoundToScl;\n        if (hasRuntimeError || comparison?.HasBlockingErrors == true)\n            return "BAD";\n        if (hasRuntimeWarning || comparison?.WarningCount > 0 || !isConfigured)\n            return "WARN";\n        return "GOOD";\n    }\n\n    private static string ResolveHealthDetail(\n        SvStreamSnapshot stream,\n        SvStreamObservationSnapshot? observation,\n        SvConfigurationComparisonResult? comparison,\n        string health)\n    {\n        var blocking = comparison?.Findings\n            .FirstOrDefault(item => item.Severity == SvConfigurationFindingSeverity.Error);\n        if (blocking is not null)\n            return blocking.Message;\n        if (stream.PayloadIssueCount > 0 || stream.OutOfOrderCount > 0)\n            return stream.HealthDetail;\n\n        var warning = comparison?.Findings\n            .FirstOrDefault(item => item.Severity == SvConfigurationFindingSeverity.Warning);\n        if (warning is not null)\n            return warning.Message;\n        if (health == "GOOD")\n            return "SV stream is stable and matches the configured SCL expectation.";\n        if (observation?.IsBoundToScl != true)\n            return "SV stream is not bound to an SCL expectation.";\n        return stream.HealthDetail;\n    }\n\n'''
+          replace_exact(
+              report_path,
+              "    private static double ResolveWindowDuration(SvObservedStreamFacts facts, double fallback)\n",
+              helpers + "    private static double ResolveWindowDuration(SvObservedStreamFacts facts, double fallback)\n")
+
+      - name: Commit review fixes
+        shell: bash
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs src/ARSVIN.Subscriber/Reporting/SvSubscriberReportBuilder.cs
+          git diff --cached --check
+          git commit -m "Address PR 39 evidence binding and report review feedback"
+          git push origin HEAD:agent/p3c-scl-expected-configuration

From 142ab444a6d932a6d1b24b84d6b357b83528f559 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Wed, 15 Jul 2026 22:01:56 +0000
Subject: [PATCH 38/39] Address PR 39 evidence binding and report review
 feedback

---
 .../Reporting/SvSubscriberReportBuilder.cs    | 54 +++++++++++++++++--
 .../ViewModels/SvSubscriberViewModel.cs       |  2 +-
 2 files changed, 52 insertions(+), 4 deletions(-)

diff --git a/src/ARSVIN.Subscriber/Reporting/SvSubscriberReportBuilder.cs b/src/ARSVIN.Subscriber/Reporting/SvSubscriberReportBuilder.cs
index c392fad..5bdeb7d 100644
--- a/src/ARSVIN.Subscriber/Reporting/SvSubscriberReportBuilder.cs
+++ b/src/ARSVIN.Subscriber/Reporting/SvSubscriberReportBuilder.cs
@@ -87,6 +87,8 @@ private static SvSubscriberStreamEvidence BuildStream(
         var observationDiagnostics = observation?.Diagnostics ?? stream.ObservationDiagnostics;
         var profileDetection = observation?.ProfileDetection ?? stream.ProfileDetection;
         var configurationComparison = observation?.ConfigurationComparison ?? stream.ConfigurationComparison;
+        var health = ResolveHealth(stream, observation, configurationComparison);
+        var healthDetail = ResolveHealthDetail(stream, observation, configurationComparison, health);
         var diagnostics = stream.Diagnostics.Concat(observationDiagnostics)
             .Where(item => !string.IsNullOrWhiteSpace(item))
             .Distinct(StringComparer.Ordinal)
@@ -95,8 +97,8 @@ private static SvSubscriberStreamEvidence BuildStream(
         return new SvSubscriberStreamEvidence
         {
             Key = stream.Key,
-            Health = stream.Health,
-            HealthDetail = stream.HealthDetail,
+            Health = health,
+            HealthDetail = healthDetail,
             Identity = new SvSubscriberStreamIdentityEvidence
             {
                 AppId = stream.AppId,
@@ -140,7 +142,7 @@ private static SvSubscriberStreamEvidence BuildStream(
                 WindowFrames = facts.ObservationCount > 0
                     ? facts.ObservationCount
                     : stream.ObservationWindowFrames,
-                WindowSamples = stream.ObservationWindowSamples,
+                WindowSamples = ResolveWindowSamples(facts, stream.ObservationWindowSamples),
                 WindowDurationSeconds = ResolveWindowDuration(facts, stream.ObservationWindowDurationSeconds),
                 FirstTimestamp = facts.FirstTimestamp,
                 LastTimestamp = facts.LastTimestamp,
@@ -194,6 +196,52 @@ private static SvObservedStreamFacts BuildFallbackFacts(SvStreamSnapshot stream)
             Diagnostics = stream.ObservationDiagnostics
         };
 
+    private static int ResolveWindowSamples(SvObservedStreamFacts facts, int fallback)
+    {
+        if (facts.ObservationCount > 0)
+            return facts.ObservationCount * Math.Max(1, facts.AsduPerFrame ?? 1);
+        return Math.Max(0, fallback);
+    }
+
+    private static string ResolveHealth(
+        SvStreamSnapshot stream,
+        SvStreamObservationSnapshot? observation,
+        SvConfigurationComparisonResult? comparison)
+    {
+        var hasRuntimeError = stream.PayloadIssueCount > 0 || stream.OutOfOrderCount > 0;
+        var hasRuntimeWarning = stream.SequenceGapCount > 0 || stream.DuplicateCount > 0;
+        var isConfigured = observation?.IsBoundToScl ?? stream.IsBoundToScl;
+        if (hasRuntimeError || comparison?.HasBlockingErrors == true)
+            return "BAD";
+        if (hasRuntimeWarning || comparison?.WarningCount > 0 || !isConfigured)
+            return "WARN";
+        return "GOOD";
+    }
+
+    private static string ResolveHealthDetail(
+        SvStreamSnapshot stream,
+        SvStreamObservationSnapshot? observation,
+        SvConfigurationComparisonResult? comparison,
+        string health)
+    {
+        var blocking = comparison?.Findings
+            .FirstOrDefault(item => item.Severity == SvConfigurationFindingSeverity.Error);
+        if (blocking is not null)
+            return blocking.Message;
+        if (stream.PayloadIssueCount > 0 || stream.OutOfOrderCount > 0)
+            return stream.HealthDetail;
+
+        var warning = comparison?.Findings
+            .FirstOrDefault(item => item.Severity == SvConfigurationFindingSeverity.Warning);
+        if (warning is not null)
+            return warning.Message;
+        if (health == "GOOD")
+            return "SV stream is stable and matches the configured SCL expectation.";
+        if (observation?.IsBoundToScl != true)
+            return "SV stream is not bound to an SCL expectation.";
+        return stream.HealthDetail;
+    }
+
     private static double ResolveWindowDuration(SvObservedStreamFacts facts, double fallback)
     {
         if (facts.FirstTimestamp.HasValue && facts.LastTimestamp.HasValue)
diff --git a/src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs b/src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs
index 0330b63..7dc966a 100644
--- a/src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs
+++ b/src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs
@@ -374,7 +374,7 @@ private bool PassesUserFilter(SampledValuesFrame frame)
         if (dataSetMatches.Length == 1)
             return dataSetMatches[0];
 
-        return addressCandidates.Length == 1 ? addressCandidates[0] : null;
+        return null;
     }
 
     private void RefreshUiSnapshots()

From 2c1cb51979cb96723a46ee4b9b3a9b3702289134 Mon Sep 17 00:00:00 2001
From: masarray <ari.sulistiono@gmail.com>
Date: Thu, 16 Jul 2026 05:02:38 +0700
Subject: [PATCH 39/39] Remove one-shot PR 39 review fix workflow

---
 .github/workflows/apply-pr39-review-fixes.yml | 68 -------------------
 1 file changed, 68 deletions(-)
 delete mode 100644 .github/workflows/apply-pr39-review-fixes.yml

diff --git a/.github/workflows/apply-pr39-review-fixes.yml b/.github/workflows/apply-pr39-review-fixes.yml
deleted file mode 100644
index 43e933f..0000000
--- a/.github/workflows/apply-pr39-review-fixes.yml
+++ /dev/null
@@ -1,68 +0,0 @@
-name: Apply PR 39 Review Fixes
-
-on:
-  push:
-    branches:
-      - agent/p3c-scl-expected-configuration
-
-permissions:
-  contents: write
-
-jobs:
-  apply-fixes:
-    if: github.actor != 'github-actions[bot]'
-    runs-on: ubuntu-24.04
-    steps:
-      - name: Checkout branch
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
-        with:
-          ref: agent/p3c-scl-expected-configuration
-          fetch-depth: 0
-
-      - name: Apply exact review fixes
-        shell: python
-        run: |
-          from pathlib import Path
-
-          def replace_exact(path: str, old: str, new: str) -> None:
-              file = Path(path)
-              text = file.read_text(encoding="utf-8")
-              count = text.count(old)
-              if count != 1:
-                  raise SystemExit(f"Expected exactly one match in {path}, found {count}")
-              file.write_text(text.replace(old, new), encoding="utf-8")
-
-          replace_exact(
-              "src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs",
-              "        return addressCandidates.Length == 1 ? addressCandidates[0] : null;\n",
-              "        return null;\n")
-
-          report_path = "src/ARSVIN.Subscriber/Reporting/SvSubscriberReportBuilder.cs"
-          replace_exact(
-              report_path,
-              "        var configurationComparison = observation?.ConfigurationComparison ?? stream.ConfigurationComparison;\n        var diagnostics = stream.Diagnostics.Concat(observationDiagnostics)",
-              "        var configurationComparison = observation?.ConfigurationComparison ?? stream.ConfigurationComparison;\n        var health = ResolveHealth(stream, observation, configurationComparison);\n        var healthDetail = ResolveHealthDetail(stream, observation, configurationComparison, health);\n        var diagnostics = stream.Diagnostics.Concat(observationDiagnostics)")
-          replace_exact(
-              report_path,
-              "            Health = stream.Health,\n            HealthDetail = stream.HealthDetail,",
-              "            Health = health,\n            HealthDetail = healthDetail,")
-          replace_exact(
-              report_path,
-              "                WindowSamples = stream.ObservationWindowSamples,",
-              "                WindowSamples = ResolveWindowSamples(facts, stream.ObservationWindowSamples),")
-
-          helpers = '''    private static int ResolveWindowSamples(SvObservedStreamFacts facts, int fallback)\n    {\n        if (facts.ObservationCount > 0)\n            return facts.ObservationCount * Math.Max(1, facts.AsduPerFrame ?? 1);\n        return Math.Max(0, fallback);\n    }\n\n    private static string ResolveHealth(\n        SvStreamSnapshot stream,\n        SvStreamObservationSnapshot? observation,\n        SvConfigurationComparisonResult? comparison)\n    {\n        var hasRuntimeError = stream.PayloadIssueCount > 0 || stream.OutOfOrderCount > 0;\n        var hasRuntimeWarning = stream.SequenceGapCount > 0 || stream.DuplicateCount > 0;\n        var isConfigured = observation?.IsBoundToScl ?? stream.IsBoundToScl;\n        if (hasRuntimeError || comparison?.HasBlockingErrors == true)\n            return "BAD";\n        if (hasRuntimeWarning || comparison?.WarningCount > 0 || !isConfigured)\n            return "WARN";\n        return "GOOD";\n    }\n\n    private static string ResolveHealthDetail(\n        SvStreamSnapshot stream,\n        SvStreamObservationSnapshot? observation,\n        SvConfigurationComparisonResult? comparison,\n        string health)\n    {\n        var blocking = comparison?.Findings\n            .FirstOrDefault(item => item.Severity == SvConfigurationFindingSeverity.Error);\n        if (blocking is not null)\n            return blocking.Message;\n        if (stream.PayloadIssueCount > 0 || stream.OutOfOrderCount > 0)\n            return stream.HealthDetail;\n\n        var warning = comparison?.Findings\n            .FirstOrDefault(item => item.Severity == SvConfigurationFindingSeverity.Warning);\n        if (warning is not null)\n            return warning.Message;\n        if (health == "GOOD")\n            return "SV stream is stable and matches the configured SCL expectation.";\n        if (observation?.IsBoundToScl != true)\n            return "SV stream is not bound to an SCL expectation.";\n        return stream.HealthDetail;\n    }\n\n'''
-          replace_exact(
-              report_path,
-              "    private static double ResolveWindowDuration(SvObservedStreamFacts facts, double fallback)\n",
-              helpers + "    private static double ResolveWindowDuration(SvObservedStreamFacts facts, double fallback)\n")
-
-      - name: Commit review fixes
-        shell: bash
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
-          git add src/ARSVIN.Subscriber/ViewModels/SvSubscriberViewModel.cs src/ARSVIN.Subscriber/Reporting/SvSubscriberReportBuilder.cs
-          git diff --cached --check
-          git commit -m "Address PR 39 evidence binding and report review feedback"
-          git push origin HEAD:agent/p3c-scl-expected-configuration