Static DataSet report-only: exact membership + schema-safe report projection

IoListTestingWindow.ClockSyncUx.cs

@@ -7,10 +7,9 @@ namespace ArIED61850Tester;
 
 public partial class IoListTestingWindow
 {
-    private CheckBox? _clockSyncCheckBox;
+    private TextBlock? _clockSyncGlobalStatusText;
     private TextBlock? _clockSyncEvidenceText;
     private MainWindow? _clockSyncSnapshotOwner;
-    private bool _clockSyncCheckBoxRefreshing;
 
     protected override void OnInitialized(EventArgs e)
     {
@@ -21,9 +20,8 @@ protected override void OnInitialized(EventArgs e)
 
     private void ClockSyncUx_Loaded(object sender, RoutedEventArgs e)
     {
-        if (_clockSyncCheckBox != null)
+        if (_clockSyncGlobalStatusText != null)
         {
-            RefreshClockSyncCheckBox();
             AttachClockSyncSnapshotOwner();
             return;
         }
@@ -35,18 +33,17 @@ private void ClockSyncUx_Loaded(object sender, RoutedEventArgs e)
         if (previewIndex < 0)
             return;
 
-        var checkBox = new CheckBox
+        var globalStatus = new TextBlock
         {
-            Name = "ClockSyncEnabledCheckBox",
-            Content = "Clock Sync",
+            Name = "GlobalSntpStatusTextBlock",
             VerticalAlignment = VerticalAlignment.Center,
             Margin = new Thickness(0, 0, 8, 0),
             Padding = new Thickness(2, 0, 2, 0),
             FontSize = 11.2,
             FontWeight = FontWeights.SemiBold,
             Foreground = TryFindResource("Ink") as Brush ?? Brushes.DimGray,
-            Focusable = false,
-            ToolTip = "SNTP laptop → IED. Checked: ARSAS serves laptop time using normal UDP/123 when available, with an Npcap RAW fallback when Windows already owns UDP/123. Unchecked: ARSAS stops only its Clock Sync service. IEC 61850 remains unaffected."
+            Text = "Global SNTP",
+            ToolTip = "Global SNTP is controlled from the ARSAS header. It is not owned by FAT and continues running when the FAT window closes while the global server toggle remains enabled."
         };
 
         var evidence = new TextBlock
@@ -57,15 +54,12 @@ private void ClockSyncUx_Loaded(object sender, RoutedEventArgs e)
             FontSize = 10.4,
             FontWeight = FontWeights.Medium,
             Foreground = TryFindResource("MutedInk") as Brush ?? Brushes.SlateGray,
-            Text = "Clock: waiting"
+            Text = "SNTP: waiting"
         };
 
-        _clockSyncCheckBox = checkBox;
+        _clockSyncGlobalStatusText = globalStatus;
         _clockSyncEvidenceText = evidence;
-        RefreshClockSyncCheckBox();
-        checkBox.Checked += ClockSyncCheckBox_Changed;
-        checkBox.Unchecked += ClockSyncCheckBox_Changed;
-        actionPanel.Children.Insert(previewIndex + 1, checkBox);
+        actionPanel.Children.Insert(previewIndex + 1, globalStatus);
         actionPanel.Children.Insert(previewIndex + 2, evidence);
         AttachClockSyncSnapshotOwner();
     }
@@ -100,28 +94,40 @@ private void ClockSyncSnapshotChanged(SntpClockServiceSnapshot snapshot)
 
     private void RefreshClockSyncEvidence(SntpClockServiceSnapshot snapshot)
     {
-        if (_clockSyncEvidenceText == null)
+        if (_clockSyncEvidenceText == null || _clockSyncGlobalStatusText == null)
             return;
 
+        var enabled = _clockSyncSnapshotOwner?.IsClockSyncEnabled == true;
         var transport = snapshot.TransportMode switch
         {
             SntpClockTransportMode.NpcapRaw => "RAW",
             SntpClockTransportMode.UdpSocket => "UDP",
             _ => "—"
         };
-
-        _clockSyncEvidenceText.Text = snapshot.State switch
-        {
-            SntpClockServiceState.Serving =>
-                $"{transport} · B {snapshot.BroadcastCount} · Req {snapshot.ClientRequestCount} · Reply {snapshot.ReplyCount} · sync not proven",
-            SntpClockServiceState.Starting => "Clock: starting…",
-            SntpClockServiceState.Stopped => "Clock: off",
-            SntpClockServiceState.PortUnavailable => "Clock: unavailable",
-            SntpClockServiceState.Faulted => "Clock: fault",
-            _ => $"Clock: {snapshot.State}"
-        };
-
-        _clockSyncEvidenceText.ToolTip = BuildClockSyncEvidenceToolTip(snapshot, transport);
+        var localAddress = snapshot.Binding?.LocalAddress.ToString();
+
+        _clockSyncGlobalStatusText.Text = !enabled
+            ? "Global SNTP · Off"
+            : snapshot.State == SntpClockServiceState.Serving
+                ? $"Global SNTP · {localAddress ?? "Active"}"
+                : "Global SNTP · Enabled";
+
+        _clockSyncEvidenceText.Text = !enabled
+            ? "SNTP: off"
+            : snapshot.State switch
+            {
+                SntpClockServiceState.Serving =>
+                    $"{transport} · B {snapshot.BroadcastCount} · Req {snapshot.ClientRequestCount} · Reply {snapshot.ReplyCount} · sync not proven",
+                SntpClockServiceState.Starting => "SNTP: starting…",
+                SntpClockServiceState.Stopped => "SNTP: waiting for connected IED",
+                SntpClockServiceState.PortUnavailable => "SNTP: unavailable",
+                SntpClockServiceState.Faulted => "SNTP: fault",
+                _ => $"SNTP: {snapshot.State}"
+            };
+
+        var toolTip = BuildClockSyncEvidenceToolTip(snapshot, transport, enabled);
+        _clockSyncGlobalStatusText.ToolTip = toolTip;
+        _clockSyncEvidenceText.ToolTip = toolTip;
         _clockSyncEvidenceText.Foreground = snapshot.State switch
         {
             SntpClockServiceState.PortUnavailable or SntpClockServiceState.Faulted => Brushes.DarkOrange,
@@ -130,60 +136,28 @@ private void RefreshClockSyncEvidence(SntpClockServiceSnapshot snapshot)
         };
     }
 
-    private static string BuildClockSyncEvidenceToolTip(SntpClockServiceSnapshot snapshot, string transport)
+    private static string BuildClockSyncEvidenceToolTip(
+        SntpClockServiceSnapshot snapshot,
+        string transport,
+        bool enabled)
     {
         var binding = snapshot.Binding == null ? "—" : snapshot.Binding.Summary;
         var lastBroadcast = snapshot.LastBroadcastUtc?.ToLocalTime().ToString("HH:mm:ss.fff") ?? "—";
         var lastRequest = snapshot.LastRequestUtc?.ToLocalTime().ToString("HH:mm:ss.fff") ?? "—";
         var lastReply = snapshot.LastReplyUtc?.ToLocalTime().ToString("HH:mm:ss.fff") ?? "—";
-        return $"Clock Sync evidence\n" +
+        return $"Global ARSAS SNTP Server\n" +
+               $"Enabled: {enabled}\n" +
                $"State: {snapshot.State}\n" +
                $"Transport: {transport}\n" +
                $"Binding: {binding}\n" +
                $"Broadcast sent: {snapshot.BroadcastCount} (last {lastBroadcast})\n" +
                $"Client request seen: {snapshot.ClientRequestCount} (last {lastRequest})\n" +
                $"Mode 4 reply sent: {snapshot.ReplyCount} (last {lastReply})\n\n" +
+               "The global server is controlled from the ARSAS header and continues outside FAT while enabled. " +
                "These counters prove packet activity only. ARSAS does not claim that the relay clock is synchronized without device-side evidence.\n\n" +
                snapshot.Detail;
     }
 
-    private void RefreshClockSyncCheckBox()
-    {
-        if (_clockSyncCheckBox == null || Owner is not MainWindow mainWindow)
-            return;
-
-        _clockSyncCheckBoxRefreshing = true;
-        try
-        {
-            _clockSyncCheckBox.IsChecked = mainWindow.IsClockSyncEnabled;
-        }
-        finally
-        {
-            _clockSyncCheckBoxRefreshing = false;
-        }
-    }
-
-    private async void ClockSyncCheckBox_Changed(object sender, RoutedEventArgs e)
-    {
-        if (_clockSyncCheckBoxRefreshing ||
-            _clockSyncCheckBox == null ||
-            Owner is not MainWindow mainWindow)
-            return;
-
-        var requested = _clockSyncCheckBox.IsChecked == true;
-        _clockSyncCheckBox.IsEnabled = false;
-        try
-        {
-            await mainWindow.SetClockSyncEnabledAsync(requested);
-            RefreshClockSyncCheckBox();
-            RefreshClockSyncEvidence(mainWindow.ClockSyncSnapshot);
-        }
-        finally
-        {
-            _clockSyncCheckBox.IsEnabled = true;
-        }
-    }
-
     private void ClockSyncUx_Closed(object? sender, EventArgs e)
     {
         if (_clockSyncSnapshotOwner != null)

IoListTestingWindow.P0Lifecycle.cs

@@ -0,0 +1,148 @@
+using System.ComponentModel;
+using System.IO;
+using System.Windows;
+
+namespace ArIED61850Tester;
+
+/// <summary>
+/// P0 responsiveness guard for the FAT workspace lifecycle.
+///
+/// The legacy Closing handler flushed workspace persistence synchronously on the WPF
+/// Dispatcher. Keep confirmation and evidence-session state transitions on the Dispatcher
+/// (the session controllers publish UI-bound PropertyChanged notifications there), then move
+/// only the durable workspace save to a worker thread. Native IEC 61850 teardown is handled
+/// independently by the responsive runtime facade.
+/// </summary>
+public partial class IoListTestingWindow
+{
+    private static readonly bool P0LifecycleRegistered = RegisterP0Lifecycle();
+
+    private bool _p0LifecycleInstalled;
+    private bool _p0CloseInProgress;
+    private bool _p0AllowClose;
+
+    private static bool RegisterP0Lifecycle()
+    {
+        // Avoid another Window lifecycle override in this already heavily split partial class.
+        // Loaded is a routed event, so one class handler can install the P0 Closing handler on
+        // every FAT workspace instance after XAML has wired its legacy Window_Closing handler.
+        EventManager.RegisterClassHandler(
+            typeof(IoListTestingWindow),
+            FrameworkElement.LoadedEvent,
+            new RoutedEventHandler(P0Lifecycle_Loaded));
+        return true;
+    }
+
+    private static void P0Lifecycle_Loaded(object sender, RoutedEventArgs e)
+    {
+        if (sender is IoListTestingWindow window)
+            window.InstallP0Lifecycle();
+    }
+
+    private void InstallP0Lifecycle()
+    {
+        if (_p0LifecycleInstalled)
+            return;
+
+        _p0LifecycleInstalled = true;
+
+        // XAML wires Window_Closing during InitializeComponent. Replace only that lifecycle
+        // edge; all existing OnClosed cleanup remains intact.
+        Closing -= Window_Closing;
+        Closing += P0Window_Closing;
+    }
+
+    private async void P0Window_Closing(object? sender, CancelEventArgs e)
+    {
+        if (_p0AllowClose)
+            return;
+
+        e.Cancel = true;
+        if (_p0CloseInProgress)
+            return;
+
+        if (IsPreparingIed)
+        {
+            var activeNames = string.Join(", ", Project.Ieds
+                .Where(ied => ied.IsPreparing)
+                .Select(ied => ied.IedName));
+            MessageBox.Show(
+                this,
+                $"ARSAS is still preparing {activeNames}. You can inspect or connect other IEDs while these independent workflows run, but finish preparation before closing this workspace.",
+                "IED preparation in progress",
+                MessageBoxButton.OK,
+                MessageBoxImage.Information);
+            return;
+        }
+
+        if (Session.HasActiveSessions)
+        {
+            var activeCount = Session.ActiveSessionCount;
+            var answer = MessageBox.Show(
+                this,
+                $"{activeCount} FAT evidence session(s) are active. Returning to Engineering will stop every active IED session, seal each independent evidence journal, and save the current project progress.\n\nStop all sessions and return?",
+                "Stop active FAT sessions",
+                MessageBoxButton.YesNo,
+                MessageBoxImage.Warning,
+                MessageBoxResult.No);
+            if (answer != MessageBoxResult.Yes)
+                return;
+        }
+
+        _p0CloseInProgress = true;
+        IsEnabled = false;
+
+        try
+        {
+            if (Session.HasActiveSessions)
+            {
+                // Session.StopAll mutates controller/project state and raises UI-bound
+                // PropertyChanged notifications. Keep that state transition on Dispatcher;
+                // offloading the whole coordinator would create a cross-thread WPF defect.
+                var stopAll = Session.StopAll(
+                    "Workspace closed by operator; per-IED evidence journal sealed.");
+                if (!stopAll.Succeeded)
+                {
+                    MessageBox.Show(
+                        this,
+                        stopAll.Message,
+                        "Evidence journals could not be sealed",
+                        MessageBoxButton.OK,
+                        MessageBoxImage.Error);
+                    return;
+                }
+            }
+
+            // Persistence is pure durable I/O after the session state is sealed and is the
+            // portion that must not occupy the WPF Dispatcher.
+            if (Storage != null)
+                await Task.Run(Storage.SaveNow);
+
+            _p0AllowClose = true;
+            Close();
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidOperationException)
+        {
+            var answer = MessageBox.Show(
+                this,
+                $"ARSAS could not save the latest IO FAT progress.\n\n{ex.Message}\n\nClose the workspace anyway?",
+                "Progress save failed",
+                MessageBoxButton.YesNo,
+                MessageBoxImage.Error,
+                MessageBoxResult.No);
+            if (answer == MessageBoxResult.Yes)
+            {
+                _p0AllowClose = true;
+                Close();
+            }
+        }
+        finally
+        {
+            if (!_p0AllowClose)
+            {
+                _p0CloseInProgress = false;
+                IsEnabled = true;
+            }
+        }
+    }
+}

IpConnectWizardWindow.xaml

@@ -35,9 +35,9 @@
 
                 <StackPanel Grid.Row="0" Grid.Column="0">
                     <TextBlock Text="IED Runtime IP Address" FontSize="12.5" FontWeight="SemiBold" Foreground="{StaticResource Ink}" Margin="0,0,0,6"/>
-                    <ComboBox x:Name="RelayIpBox" IsEditable="True" IsTextSearchEnabled="True"
+                    <ComboBox x:Name="RelayIpBox" IsEditable="True" IsTextSearchEnabled="False"
                               ItemsSource="{Binding RecentRelayIps, RelativeSource={RelativeSource AncestorType=Window}}"
-                              Text="{Binding RelayIpAddress, RelativeSource={RelativeSource AncestorType=Window}, UpdateSourceTrigger=PropertyChanged}"/>
+                              Text="{Binding RelayIpAddress, RelativeSource={RelativeSource AncestorType=Window}, UpdateSourceTrigger=LostFocus}"/>
                 </StackPanel>
                 <StackPanel Grid.Row="0" Grid.Column="2">
                     <TextBlock Text="MMS Port" FontSize="12.5" FontWeight="SemiBold" Foreground="{StaticResource Ink}" Margin="0,0,0,6"/>