diff --git a/IoListTestingWindow.EmbeddedEngineeringHost.cs b/IoListTestingWindow.EmbeddedEngineeringHost.cs
new file mode 100644
index 000000000..39421b40c
--- /dev/null
+++ b/IoListTestingWindow.EmbeddedEngineeringHost.cs
@@ -0,0 +1,196 @@
+using System.Runtime.CompilerServices;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Threading;
+using ArIED61850Tester.Models;
+
+namespace ArIED61850Tester;
+
+///
+/// Hosts the proven IoListTestingWindow production workspace inside MainWindow's FAT tab.
+/// The production Window remains loaded-but-hidden so its existing session controller,
+/// auto-capture lifecycle, persistence and report-preview code stay the single FAT authority.
+/// Only its central workspace + FAT status footer are re-parented into Engineering.
+///
+public partial class IoListTestingWindow
+{
+ private bool _engineeringEmbeddedMountQueued;
+ private bool _engineeringEmbeddedMounted;
+ private FrameworkElement? _engineeringEmbeddedSurface;
+
+ [ModuleInitializer]
+ internal static void RegisterEmbeddedEngineeringFatHost()
+ {
+ EventManager.RegisterClassHandler(
+ typeof(IoListTestingWindow),
+ FrameworkElement.LoadedEvent,
+ new RoutedEventHandler(EmbeddedEngineeringFatHost_Loaded),
+ handledEventsToo: true);
+ }
+
+ internal void PrepareForEmbeddedEngineeringHost()
+ {
+ // WPF rejects Show() when a Window is both non-activating and Maximized.
+ // The donor only exists long enough to create the proven production visual tree,
+ // so normalize it before the hidden/off-screen bootstrap and let MainWindow own size.
+ if (WindowState == WindowState.Maximized)
+ WindowState = WindowState.Normal;
+
+ ShowActivated = false;
+ ShowInTaskbar = false;
+ Opacity = 0d;
+ WindowStartupLocation = WindowStartupLocation.Manual;
+ Left = -32000d;
+ Top = -32000d;
+ }
+
+ private static void EmbeddedEngineeringFatHost_Loaded(object sender, RoutedEventArgs e)
+ {
+ if (sender is not IoListTestingWindow window ||
+ !ReferenceEquals(e.OriginalSource, window) ||
+ window._engineeringEmbeddedMounted ||
+ window._engineeringEmbeddedMountQueued ||
+ window.Owner is not MainWindow owner ||
+ !owner.ProductionFatTabReady)
+ {
+ return;
+ }
+
+ window._engineeringEmbeddedMountQueued = true;
+
+ // MainWindow's legacy launcher still calls Show() on this Window. Make that bootstrap
+ // surface invisible immediately; the actual production visual is moved into Engineering
+ // on the next Loaded-priority dispatcher turn, before ContextIdle command-panel work.
+ window.PrepareForEmbeddedEngineeringHost();
+
+ window.Dispatcher.BeginInvoke(
+ DispatcherPriority.Loaded,
+ new Action(() => window.TryMountIntoEngineering(owner)));
+ }
+
+ private void TryMountIntoEngineering(MainWindow owner)
+ {
+ _engineeringEmbeddedMountQueued = false;
+ if (_engineeringEmbeddedMounted || !IsLoaded || !ReferenceEquals(Owner, owner) || !owner.ProductionFatTabReady)
+ return;
+
+ try
+ {
+ EnsureProductionFatPresentationForEmbeddedHost();
+ DisableLegacyEmbeddedCommandPanel();
+ var surface = DetachProductionFatCentralWorkspace();
+ if (surface == null)
+ return;
+
+ _engineeringEmbeddedSurface = surface;
+ _engineeringEmbeddedMounted = owner.MountProductionFatWorkspace(this, surface);
+ if (!_engineeringEmbeddedMounted)
+ return;
+
+ // The central FAT view now belongs to MainWindow. Keep this Window loaded and
+ // hidden because existing controller/session/event code is intentionally reused.
+ Hide();
+ }
+ catch (Exception ex)
+ {
+ Opacity = 1d;
+ ShowInTaskbar = true;
+ ShowActivated = true;
+ MessageBox.Show(
+ owner,
+ $"ARSAS could not embed the production FAT workspace. The standalone FAT window will remain available.\n\n{ex.Message}",
+ "FAT workspace host",
+ MessageBoxButton.OK,
+ MessageBoxImage.Warning);
+ }
+ }
+
+ private void EnsureProductionFatPresentationForEmbeddedHost()
+ {
+ // P1 normally installs this during Loaded. Calling it explicitly is safe/idempotent
+ // and guarantees the first embedded frame is the same V2 FAT grid as the old Window.
+ InstallFatV2WorkspaceUx();
+
+ // PrintPreview historically installs from OnContentRendered. The bootstrap Window is
+ // intentionally transparent, so install the exact same production preview explicitly
+ // before the central workspace is detached. This preserves full-center mode switching.
+ if (!_printPreviewInstalled)
+ {
+ InstallPerIedPrintPreview();
+ PropertyChanged += PrintPreviewWindow_PropertyChanged;
+ Session.PropertyChanged += PrintPreviewSession_PropertyChanged;
+ Closed += PrintPreviewWindow_Closed;
+ _printPreviewInstalled = true;
+ }
+
+ // The embedded center already declares WorkspacePreviewToggle in XAML. Make that
+ // visible button the production toggle authority instead of the hidden Window header.
+ if (WorkspacePreviewToggle != null)
+ _printPreviewToggle = WorkspacePreviewToggle;
+ }
+
+ private void DisableLegacyEmbeddedCommandPanel()
+ {
+ // Engineering already owns one shared Command Dock. Prevent the old FAT window's
+ // duplicate command panel from being created/refreshed while embedded. A non-null
+ // sentinel makes the queued legacy installer return immediately; null row/summary
+ // references make its queued refresh a no-op. No command runtime semantics change.
+ DetachFatCommandDevice();
+ if (_fatCommandPanelShell?.Parent is Grid existingHost)
+ {
+ var row = Grid.GetRow(_fatCommandPanelShell);
+ existingHost.Children.Remove(_fatCommandPanelShell);
+ if (row >= 0 && row < existingHost.RowDefinitions.Count)
+ existingHost.RowDefinitions[row].Height = new GridLength(0);
+ if (row - 1 >= 0 && row - 1 < existingHost.RowDefinitions.Count)
+ existingHost.RowDefinitions[row - 1].Height = new GridLength(0);
+ }
+
+ _fatCommandPanelShell ??= new Border { Visibility = Visibility.Collapsed };
+ _fatCommandRows = null;
+ _fatCommandSummary = null;
+ _fatCommandEmptyState = null;
+ }
+
+ private FrameworkElement? DetachProductionFatCentralWorkspace()
+ {
+ if (Content is not Grid root)
+ return null;
+
+ var middle = root.Children
+ .OfType()
+ .FirstOrDefault(child => Grid.GetRow(child) == 2);
+ var workspaceBorder = middle?.Children
+ .OfType()
+ .FirstOrDefault(child => Grid.GetColumn(child) == 2);
+ if (middle == null || workspaceBorder == null)
+ return null;
+
+ var footer = root.Children
+ .OfType()
+ .FirstOrDefault(child => Grid.GetRow(child) == 4);
+
+ middle.Children.Remove(workspaceBorder);
+ if (footer != null)
+ root.Children.Remove(footer);
+
+ var host = new Grid
+ {
+ DataContext = this,
+ Margin = new Thickness(0)
+ };
+ host.RowDefinitions.Add(new RowDefinition { Height = new GridLength(1, GridUnitType.Star) });
+ if (footer != null)
+ host.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+
+ Grid.SetRow(workspaceBorder, 0);
+ host.Children.Add(workspaceBorder);
+ if (footer != null)
+ {
+ Grid.SetRow(footer, 1);
+ host.Children.Add(footer);
+ }
+
+ return host;
+ }
+}
diff --git a/IoListTestingWindow.xaml.cs b/IoListTestingWindow.xaml.cs
index 84f37fb94..c1ec2bcea 100644
--- a/IoListTestingWindow.xaml.cs
+++ b/IoListTestingWindow.xaml.cs
@@ -119,18 +119,28 @@ private void SetAddingFatIeds(bool value)
private async void StartSession_Click(object sender, RoutedEventArgs e)
{
- var selectedIed = SelectedIed;
- if (selectedIed?.IsPreparing == true)
+ // M4 freezes both the IED owner and exact evidence scope before any asynchronous
+ // Engineering preparation. Explorer navigation may continue, but it cannot redirect
+ // this transaction or silently widen the production capture scope.
+ var requestedIed = SelectedIed;
+ if (requestedIed?.IsPreparing == true)
return;
- var preflight = IoTestSessionPreflight.Validate(selectedIed);
- if (!preflight.Succeeded)
+ IoFatCaptureTargetLease captureLease;
+ try
+ {
+ captureLease = IoFatProductionControllerAdapter.LatchStartTarget(Project, requestedIed);
+ }
+ catch (InvalidOperationException ex)
{
- ShowActionResult(preflight, "FAT session scope is not ready");
+ ShowActionResult(
+ IoTestSessionActionResult.Failure(ex.Message),
+ "FAT session scope is not ready");
return;
}
- PreparationStatusText = $"Connecting {selectedIed!.IedName} · {selectedIed.IpAddress}:102";
+ var selectedIed = captureLease.Ied;
+ PreparationStatusText = $"Connecting {selectedIed.IedName} · {selectedIed.IpAddress}:102";
RaisePreparationProperties();
try
{
@@ -155,7 +165,10 @@ private async void StartSession_Click(object sender, RoutedEventArgs e)
}
}
- var result = Session.Start(selectedIed);
+ // Revalidate the frozen identity/configuration only after Engineering has
+ // completed connection preparation. The adapter delegates to the unchanged
+ // production session controller, which remains the sole evidence writer.
+ var result = IoFatProductionControllerAdapter.StartLatched(Project, Session, captureLease);
ShowActionResult(result, "FAT evidence session could not start");
RaiseStatusProperties();
if (result.Succeeded)
@@ -187,7 +200,8 @@ private async void StartSession_Click(object sender, RoutedEventArgs e)
private void PauseSession_Click(object sender, RoutedEventArgs e)
{
- var result = Session.Pause();
+ var targetIed = SelectedIed;
+ var result = Session.Pause(targetIed);
ShowActionResult(result, "FAT session could not pause");
if (result.Succeeded)
Storage?.SaveNow();
@@ -195,7 +209,10 @@ private void PauseSession_Click(object sender, RoutedEventArgs e)
private void ResumeSession_Click(object sender, RoutedEventArgs e)
{
- var result = Session.Resume();
+ // Continue is explicitly IED-targeted. A later Explorer change cannot make the
+ // production controller rebind this active evidence session to another device.
+ var targetIed = SelectedIed;
+ var result = Session.Resume(targetIed);
ShowActionResult(result, "FAT session could not resume");
if (result.Succeeded)
Storage?.ScheduleSave();
@@ -203,7 +220,8 @@ private void ResumeSession_Click(object sender, RoutedEventArgs e)
private void StopSession_Click(object sender, RoutedEventArgs e)
{
- var result = Session.Stop();
+ var targetIed = SelectedIed;
+ var result = Session.Stop(targetIed);
ShowActionResult(result, "FAT session could not stop");
if (result.Succeeded)
Storage?.SaveNow();
diff --git a/MainWindow.IoTesting.cs b/MainWindow.IoTesting.cs
index 52f1cfc91..69acfa89f 100644
--- a/MainWindow.IoTesting.cs
+++ b/MainWindow.IoTesting.cs
@@ -494,6 +494,8 @@ private Task ShowIoTestingWorkspaceAsync(IoTestWorkspaceLaunchResult launch, int
var controller = launch.Session;
var persistence = launch.Workspace;
var window = new IoListTestingWindow(launch.Project, controller, persistence) { Owner = this };
+ if (ProductionFatTabReady)
+ window.PrepareForEmbeddedEngineeringHost();
RegisterLoadedIoFatWindow(window);
_activeIoTestSessionController = controller;
Interlocked.Exchange(ref _ioTestObservationSequence, DateTime.UtcNow.Ticks);
@@ -525,7 +527,8 @@ void WindowClosed(object? sender, EventArgs args)
}
window.Closed += WindowClosed;
- Hide();
+ if (!ProductionFatTabReady)
+ Hide();
window.Show();
return Task.CompletedTask;
}
diff --git a/MainWindow.NativeFatWorkspace.cs b/MainWindow.NativeFatWorkspace.cs
new file mode 100644
index 000000000..e5d4f545e
--- /dev/null
+++ b/MainWindow.NativeFatWorkspace.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Windows.Threading;
+
+namespace ArIED61850Tester;
+
+///
+/// M7 compatibility bridge for the canonical seventh Engineering destination.
+///
+/// MainWindow.xaml owns the FAT tab and navigation button. Production FAT is mounted
+/// into that permanent XAML slot by MainWindow.ProductionFatTab.cs. This file deliberately
+/// owns no FAT rows, capture commands, evidence state, persistence, preview, export, or timers.
+/// It retains only the shared slot index and a deferred navigation-geometry refresh used by
+/// the canonical MainWindow shell.
+///
+public partial class MainWindow
+{
+ private const int NativeFatWorkspaceIndex = 6;
+
+ private void QueueNativeFatNavigationGeometry()
+ {
+ if (!IsLoaded)
+ return;
+
+ Dispatcher.BeginInvoke(
+ DispatcherPriority.ApplicationIdle,
+ new Action(() => UpdateNavigationVisuals(MainTabs.SelectedIndex, animate: false)));
+ }
+}
diff --git a/MainWindow.NavigationLayoutFix.cs b/MainWindow.NavigationLayoutFix.cs
index fe2e8325f..55e5b0f0b 100644
--- a/MainWindow.NavigationLayoutFix.cs
+++ b/MainWindow.NavigationLayoutFix.cs
@@ -10,7 +10,7 @@ namespace ArIED61850Tester;
///
/// Owns the responsive geometry of the MainWindow workflow header.
///
-/// The original XAML used a 760 px shell split into six equal columns while the
+/// The original XAML used a 760 px shell split into seven equal columns while the
/// selection pill moved in hard-coded 150 px steps. That was barely large enough for
/// short labels and clipped "IEC 61850 Explorer" / "GOOSE Subscriber" once the center
/// workspace switch and live connection/status chips were also present. This behavior
@@ -93,7 +93,7 @@ private static void OnMainWindowButtonClick(object sender, RoutedEventArgs e)
if (sender is not MainWindow window || e.Source is not Button button)
return;
- if (button.Name is not ("NavExplorerButton" or "NavLiveButton" or "NavEventsButton" or "NavAlarmButton" or "NavGooseButton" or "NavDiagnosticsButton"))
+ if (button.Name is not ("NavExplorerButton" or "NavLiveButton" or "NavEventsButton" or "NavAlarmButton" or "NavGooseButton" or "NavDiagnosticsButton" or "NavNativeFatButton"))
return;
// A repeated click on the already-selected tab does not raise SelectionChanged,
@@ -195,7 +195,8 @@ private static void ApplyResponsiveLayout(MainWindow window)
window.FindName("NavEventsButton") as Button,
window.FindName("NavAlarmButton") as Button,
window.FindName("NavGooseButton") as Button,
- window.FindName("NavDiagnosticsButton") as Button
+ window.FindName("NavDiagnosticsButton") as Button,
+ window.FindName("NavNativeFatButton") as Button
];
private static void UpdatePillGeometry(MainWindow window, double shellWidth)
@@ -204,9 +205,9 @@ private static void UpdatePillGeometry(MainWindow window, double shellWidth)
return;
// Border padding owns 10 px horizontally. The nav grid itself is divided into
- // six equal star columns, so this is the exact width used by each button cell.
+ // seven equal star columns, so this is the exact width used by each button cell.
var contentWidth = Math.Max(0d, shellWidth - 10d);
- var cellWidth = contentWidth / 6d;
+ var cellWidth = contentWidth / 7d;
pill.Width = Math.Max(1d, cellWidth - 2d);
pill.Height = 36;
pill.HorizontalAlignment = HorizontalAlignment.Left;
@@ -279,8 +280,8 @@ private static void PositionPill(MainWindow window, bool animate)
if (contentWidth <= 0d)
contentWidth = Math.Max(0d, shell.Width - shell.Padding.Left - shell.Padding.Right);
- var cellWidth = contentWidth / 6d;
- var target = Math.Clamp(tabs.SelectedIndex, 0, 5) * cellWidth;
+ var cellWidth = contentWidth / 7d;
+ var target = Math.Clamp(tabs.SelectedIndex, 0, 6) * cellWidth;
pill.Width = Math.Max(1d, cellWidth - 2d);
translate.BeginAnimation(TranslateTransform.XProperty, null);
diff --git a/MainWindow.ProductionFatEngineeringBootstrap.cs b/MainWindow.ProductionFatEngineeringBootstrap.cs
new file mode 100644
index 000000000..72238ad5d
--- /dev/null
+++ b/MainWindow.ProductionFatEngineeringBootstrap.cs
@@ -0,0 +1,190 @@
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Threading;
+using ArIED61850Tester.Services.IoTesting;
+
+namespace ArIED61850Tester;
+
+///
+/// Makes the embedded production FAT workspace a projection of the Engineering workspace.
+/// Opening SCL in Explorer is sufficient; the expensive FAT projection is created only when
+/// the operator actually enters FAT so normal Engineering acquisition remains untouched.
+///
+public partial class MainWindow
+{
+ private bool _productionFatEngineeringBootstrapInstalled;
+ private bool _productionFatEngineeringBootstrapBusy;
+ private CancellationTokenSource? _productionFatEngineeringBootstrapCts;
+
+ [ModuleInitializer]
+ internal static void RegisterProductionFatEngineeringBootstrap()
+ {
+ EventManager.RegisterClassHandler(
+ typeof(MainWindow),
+ FrameworkElement.LoadedEvent,
+ new RoutedEventHandler(ProductionFatEngineeringBootstrap_Loaded),
+ handledEventsToo: true);
+ }
+
+ private static void ProductionFatEngineeringBootstrap_Loaded(object sender, RoutedEventArgs e)
+ {
+ if (sender is not MainWindow window || window._productionFatEngineeringBootstrapInstalled)
+ return;
+
+ window._productionFatEngineeringBootstrapInstalled = true;
+ window.MainTabs.SelectionChanged += window.ProductionFatEngineeringBootstrap_SelectionChanged;
+ window.PropertyChanged += window.ProductionFatEngineeringBootstrap_PropertyChanged;
+ window.Closed += window.ProductionFatEngineeringBootstrap_Closed;
+ }
+
+ private void ProductionFatEngineeringBootstrap_SelectionChanged(object sender, SelectionChangedEventArgs e)
+ {
+ if (!ReferenceEquals(e.Source, MainTabs) || MainTabs.SelectedIndex != NativeFatWorkspaceIndex)
+ return;
+ QueueProductionFatEngineeringBootstrap();
+ }
+
+ private void ProductionFatEngineeringBootstrap_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+ {
+ if (e.PropertyName != nameof(SelectedDevice) || MainTabs.SelectedIndex != NativeFatWorkspaceIndex)
+ return;
+
+ // A running production FAT session owns its latched IED. The normal embedded-host
+ // selection bridge handles idle retargeting. Bootstrap is only needed before a FAT
+ // workspace exists.
+ if (_productionFatWindow == null && _loadedIoFatWindow == null)
+ QueueProductionFatEngineeringBootstrap();
+ }
+
+ private void QueueProductionFatEngineeringBootstrap()
+ {
+ // Never prewarm FAT while the operator is in Explorer/Live Monitor/etc. Creating the
+ // production FAT projection off-tab caused field regressions by mutating acquisition
+ // authority and adding UI/runtime work during ordinary Engineering operation.
+ if (!_productionFatEngineeringBootstrapInstalled || MainTabs.SelectedIndex != NativeFatWorkspaceIndex)
+ return;
+
+ Dispatcher.BeginInvoke(
+ DispatcherPriority.ContextIdle,
+ new Action(async () => await EnsureProductionFatFromEngineeringAsync()));
+ }
+
+ private async Task EnsureProductionFatFromEngineeringAsync()
+ {
+ if (_productionFatEngineeringBootstrapBusy ||
+ MainTabs.SelectedIndex != NativeFatWorkspaceIndex ||
+ !ProductionFatTabReady)
+ {
+ return;
+ }
+
+ if (_productionFatWindow is { IsLoaded: true } || _loadedIoFatWindow is { IsLoaded: true })
+ {
+ SynchronizeProductionFatSelectedIed();
+ return;
+ }
+
+ var selected = SelectedDevice;
+ if (selected?.SclWorkspace == null ||
+ selected.SclWorkspace.DesignModel.DataSets.Sum(dataSet => dataSet.Members.Count) == 0)
+ {
+ SetStatus(selected == null
+ ? "FAT · select an Engineering IED with a static DataSet."
+ : $"FAT · {selected.Name} has no static DataSet scope in the Engineering SCL model.");
+ return;
+ }
+
+ var engineeringDevices = Devices
+ .Where(device => device.SclWorkspace != null)
+ .Where(device => device.SclWorkspace!.DesignModel.DataSets.Sum(dataSet => dataSet.Members.Count) > 0)
+ .Where(device => !string.IsNullOrWhiteSpace(device.SclSourcePath))
+ .ToArray();
+ if (engineeringDevices.All(device => !ReferenceEquals(device, selected)))
+ {
+ SetStatus($"FAT · Engineering source provenance for {selected.Name} is unavailable; use Open SCL to restore the source authority.");
+ return;
+ }
+
+ _productionFatEngineeringBootstrapBusy = true;
+ _productionFatEngineeringBootstrapCts?.Cancel();
+ _productionFatEngineeringBootstrapCts?.Dispose();
+ _productionFatEngineeringBootstrapCts = CancellationTokenSource.CreateLinkedTokenSource(_applicationCancellation.Token);
+ var token = _productionFatEngineeringBootstrapCts.Token;
+ SetStatus($"FAT · preparing {selected.Name} from the Engineering static DataSet…");
+
+ try
+ {
+ var projection = await IoFatEngineeringWorkspaceProjectionService.BuildAsync(
+ engineeringDevices,
+ token);
+ token.ThrowIfCancellationRequested();
+
+ // Register the exact same ARIEC workspace instances already owned by Explorer.
+ // Production FAT preparation can therefore prove shared SCL authority without
+ // reparsing XML or starting a second model/acquisition stack.
+ _ioFatSclProjectImportService.AdoptEngineeringRuntimeWorkspaces(projection.RuntimeWorkspaces);
+
+ var launch = await IoTestWorkspaceBootstrapService.OpenSourcesAsync(
+ projection.Project,
+ projection.SourceInputs,
+ IoTestingProjectsRoot(),
+ IoTestingEvidenceRoot(),
+ CreateIoTestSession,
+ token);
+ token.ThrowIfCancellationRequested();
+
+ SynchronizeImportedSclFatWithEngineering(launch.Project);
+
+ var retiredManualRows = launch.Project.Ieds.Sum(
+ IoFatEngineeringSelectionBridge.RetireManualWorkspaceRowsForStaticDataSetMode);
+ if (retiredManualRows > 0)
+ {
+ AddLog(
+ "INFO",
+ "FAT",
+ $"Automatic Static DataSet scope retired {retiredManualRows} manual SCL workspace overlay(s); static membership remains authoritative.");
+ }
+
+ RegisterSharedSclSourcePaths(launch.Project, launch.Project.Ieds, projection.SourceInputs);
+ foreach (var ied in launch.Project.Ieds)
+ {
+ var device = ResolveIoTestDevice(ied.LiveDeviceId)
+ ?? ResolveIoTestDevice(ied.IpAddress)
+ ?? ResolveIoTestDevice(ied.IedName);
+ if (device is not null)
+ MarkSharedSelectionAuthority(device);
+ }
+
+ launch.Workspace.ScheduleSave();
+ await ShowIoTestingWorkspaceAsync(launch, importWarningCount: 0);
+ SynchronizeProductionFatSelectedIed();
+ SetStatus($"FAT ready · {selected.Name} · Engineering static DataSet authority reused · no SCL re-import.");
+ }
+ catch (OperationCanceledException)
+ {
+ // Fast navigation/close is normal. No modal interruption is appropriate here.
+ }
+ catch (Exception ex) when (ex is IOException or JsonException or InvalidDataException or UnauthorizedAccessException or ArgumentException or InvalidOperationException)
+ {
+ AddLog("WARN", "FAT", $"Automatic Engineering FAT bootstrap unavailable: {ex.Message}");
+ SetStatus($"FAT · could not reuse the Engineering static DataSet automatically: {ex.Message}");
+ }
+ finally
+ {
+ _productionFatEngineeringBootstrapBusy = false;
+ }
+ }
+
+ private void ProductionFatEngineeringBootstrap_Closed(object? sender, EventArgs e)
+ {
+ MainTabs.SelectionChanged -= ProductionFatEngineeringBootstrap_SelectionChanged;
+ PropertyChanged -= ProductionFatEngineeringBootstrap_PropertyChanged;
+ Closed -= ProductionFatEngineeringBootstrap_Closed;
+ _productionFatEngineeringBootstrapCts?.Cancel();
+ _productionFatEngineeringBootstrapCts?.Dispose();
+ _productionFatEngineeringBootstrapCts = null;
+ }
+}
diff --git a/MainWindow.ProductionFatNoFlicker.cs b/MainWindow.ProductionFatNoFlicker.cs
new file mode 100644
index 000000000..f346e68f2
--- /dev/null
+++ b/MainWindow.ProductionFatNoFlicker.cs
@@ -0,0 +1,28 @@
+using System.Windows;
+
+namespace ArIED61850Tester;
+
+///
+/// P0 field fix for the embedded Engineering FAT transition.
+///
+/// The legacy production FAT launcher owns a historical MainWindow.Hide() / child Show()
+/// hand-off. That is still required by standalone compatibility flows, but it is wrong for
+/// the automatic Engineering -> embedded FAT path because the FAT tab is already visible
+/// and the child Window exists only as a hidden controller/lifecycle owner. Suppress that
+/// single hide while the automatic embedded bootstrap is in flight so the user never sees
+/// the desktop/black frame between two WPF windows.
+///
+public partial class MainWindow
+{
+ public new void Hide()
+ {
+ if (ShouldKeepEngineeringVisibleDuringProductionFatBootstrap())
+ return;
+
+ base.Hide();
+ }
+
+ private bool ShouldKeepEngineeringVisibleDuringProductionFatBootstrap()
+ => _productionFatEngineeringBootstrapBusy &&
+ ProductionFatTabReady;
+}
diff --git a/MainWindow.ProductionFatTab.cs b/MainWindow.ProductionFatTab.cs
new file mode 100644
index 000000000..bc464d5d2
--- /dev/null
+++ b/MainWindow.ProductionFatTab.cs
@@ -0,0 +1,185 @@
+using System.Runtime.CompilerServices;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Threading;
+using ArIED61850Tester.Models;
+
+namespace ArIED61850Tester;
+
+///
+/// Engineering FAT pivot: the permanent XAML FAT tab hosts the proven production
+/// IoListTestingWindow workspace rather than a second/manual FAT implementation.
+/// The global Engineering IED Explorer and shared Command Dock remain authoritative.
+///
+public partial class MainWindow
+{
+ private bool _productionFatTabInstalled;
+ private IoListTestingWindow? _productionFatWindow;
+ private FrameworkElement? _productionFatSurface;
+ private DispatcherTimer? _productionFatInstallRetry;
+
+ internal bool ProductionFatTabReady => _productionFatTabInstalled && NativeFatTab != null;
+
+ [ModuleInitializer]
+ internal static void RegisterProductionFatTabPivot()
+ {
+ EventManager.RegisterClassHandler(
+ typeof(MainWindow),
+ FrameworkElement.LoadedEvent,
+ new RoutedEventHandler(ProductionFatTab_MainWindowLoaded),
+ handledEventsToo: true);
+ }
+
+ private static void ProductionFatTab_MainWindowLoaded(object sender, RoutedEventArgs e)
+ {
+ if (sender is not MainWindow window || window._productionFatTabInstalled)
+ return;
+
+ window.Dispatcher.BeginInvoke(
+ DispatcherPriority.ApplicationIdle,
+ new Action(window.TryInstallProductionFatTabPivot));
+ }
+
+ private void TryInstallProductionFatTabPivot()
+ {
+ if (_productionFatTabInstalled || !IsLoaded)
+ return;
+
+ // M7: MainWindow.xaml is the sole owner of the seventh destination. Wait only
+ // until the canonical XAML tab is present; there is no native FAT runtime to install.
+ if (MainTabs.Items.Count <= NativeFatWorkspaceIndex ||
+ !ReferenceEquals(MainTabs.Items[NativeFatWorkspaceIndex], NativeFatTab))
+ {
+ _productionFatInstallRetry ??= new DispatcherTimer(DispatcherPriority.ApplicationIdle)
+ {
+ Interval = TimeSpan.FromMilliseconds(120)
+ };
+ _productionFatInstallRetry.Tick -= ProductionFatInstallRetry_Tick;
+ _productionFatInstallRetry.Tick += ProductionFatInstallRetry_Tick;
+ _productionFatInstallRetry.Start();
+ return;
+ }
+
+ _productionFatInstallRetry?.Stop();
+ _productionFatTabInstalled = true;
+ NativeFatTab.Content = BuildProductionFatPermanentHost();
+
+ // Prewarm as soon as the canonical host exists. A valid Engineering SCL/DataSet
+ // can prepare the exact production surface before the operator first opens FAT.
+ QueueProductionFatEngineeringBootstrap();
+
+ // MainWindow.xaml owns both style and click routing for the seventh nav button.
+ NavNativeFatButton.ToolTip = "Production FAT workspace · automatic Value 1 / Value 2 evidence capture";
+
+ PropertyChanged += ProductionFat_MainWindowPropertyChanged;
+ MainTabs.SelectionChanged += ProductionFat_MainTabsSelectionChanged;
+ Closed += ProductionFat_MainWindowClosed;
+
+ QueueNativeFatNavigationGeometry();
+ }
+
+ private void ProductionFatInstallRetry_Tick(object? sender, EventArgs e)
+ {
+ _productionFatInstallRetry?.Stop();
+ TryInstallProductionFatTabPivot();
+ }
+
+ private FrameworkElement BuildProductionFatPermanentHost()
+ {
+ // Stable shell slot, never a launcher or alternate FAT workflow. With a valid
+ // Engineering static DataSet this is replaced by the exact production FAT surface.
+ var root = new Grid { Margin = new Thickness(0) };
+ root.Children.Add(new TextBlock
+ {
+ Text = "FAT · awaiting an Engineering IED with static DataSet scope",
+ FontSize = 12,
+ Foreground = TryFindResource("Muted") as Brush ?? Brushes.DimGray,
+ HorizontalAlignment = HorizontalAlignment.Center,
+ VerticalAlignment = VerticalAlignment.Center
+ });
+ return root;
+ }
+
+ private void ProductionFat_MainTabsSelectionChanged(object sender, SelectionChangedEventArgs e)
+ {
+ if (!ReferenceEquals(e.Source, MainTabs))
+ return;
+
+ QueueNativeFatNavigationGeometry();
+ if (MainTabs.SelectedIndex == NativeFatWorkspaceIndex)
+ {
+ SynchronizeProductionFatSelectedIed();
+ _productionFatWindow?.NotifyEmbeddedHostActivated();
+ }
+ else
+ {
+ _productionFatWindow?.Storage?.ScheduleSave();
+ }
+ }
+
+ private void ProductionFat_MainWindowPropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
+ {
+ if (e.PropertyName == nameof(SelectedDevice))
+ SynchronizeProductionFatSelectedIed();
+ }
+
+ private void SynchronizeProductionFatSelectedIed()
+ => _productionFatWindow?.SelectEngineeringDeviceForEmbeddedFat(SelectedDevice);
+
+ internal bool MountProductionFatWorkspace(IoListTestingWindow window, FrameworkElement surface)
+ {
+ ArgumentNullException.ThrowIfNull(window);
+ ArgumentNullException.ThrowIfNull(surface);
+ if (!ProductionFatTabReady)
+ return false;
+
+ _productionFatWindow = window;
+ _productionFatSurface = surface;
+ surface.DataContext = window;
+ NativeFatTab.Content = surface;
+ if (_persistentWorkbench != null)
+ _persistentWorkbench.DockExpandedByWorkspace[NativeFatWorkspaceIndex] = true;
+
+ window.Closed -= ProductionFatWindow_Closed;
+ window.Closed += ProductionFatWindow_Closed;
+ SynchronizeProductionFatSelectedIed();
+
+ // Passive mount: prewarming must never navigate, hide/show, activate, or steal
+ // focus from the operator's current Engineering destination.
+ window.RegisterEmbeddedHostCloseCleanup();
+ QueueNativeFatNavigationGeometry();
+
+ if (MainTabs.SelectedIndex == NativeFatWorkspaceIndex)
+ SetStatus($"FAT ready in Engineering tab · {window.Project.Ieds.Count} IED · production auto-capture workflow.");
+ return true;
+ }
+
+ internal void UnmountProductionFatWorkspace(IoListTestingWindow window)
+ {
+ if (!ReferenceEquals(_productionFatWindow, window))
+ return;
+
+ window.Closed -= ProductionFatWindow_Closed;
+ _productionFatWindow = null;
+ _productionFatSurface = null;
+ NativeFatTab.Content = BuildProductionFatPermanentHost();
+ }
+
+ private void ProductionFatWindow_Closed(object? sender, EventArgs e)
+ {
+ if (sender is IoListTestingWindow window)
+ UnmountProductionFatWorkspace(window);
+ }
+
+ private void ProductionFat_MainWindowClosed(object? sender, EventArgs e)
+ {
+ PropertyChanged -= ProductionFat_MainWindowPropertyChanged;
+ MainTabs.SelectionChanged -= ProductionFat_MainTabsSelectionChanged;
+ Closed -= ProductionFat_MainWindowClosed;
+ _productionFatInstallRetry?.Stop();
+ _productionFatInstallRetry = null;
+ _productionFatWindow = null;
+ _productionFatSurface = null;
+ }
+}
diff --git a/MainWindow.SharedSclWorkspace.cs b/MainWindow.SharedSclWorkspace.cs
index a7a0ef71b..929a57fa6 100644
--- a/MainWindow.SharedSclWorkspace.cs
+++ b/MainWindow.SharedSclWorkspace.cs
@@ -98,6 +98,10 @@ private void ApplyStaticDataSetSelection(Iec61850MonitorDevice device)
// shared monitor to start and never changes acquisition method.
LogStaticDataSetReportFeasibility(device);
_ = ObserveInitialStaticReportEvidenceAsync(device);
+
+ // FAT is built lazily. Queueing here is harmless because the bootstrap guard only
+ // runs while the operator is actually on the FAT destination.
+ QueueProductionFatEngineeringBootstrap();
}
private void ClearSharedSignalSelection(Iec61850MonitorDevice device)
@@ -116,16 +120,26 @@ private void ClearSharedSignalSelection(Iec61850MonitorDevice device)
private void MarkSharedSelectionAuthority(Iec61850MonitorDevice device)
{
- // The initial FAT import historically reached this helper for both branches. If the
- // immediately preceding operator decision was Static DataSet, preserve that explicit
- // report-only authority instead of silently demoting it to Hybrid.
+ // Initial explicit Static DataSet assignment still needs the full materialization path.
if (_pendingSharedStaticSelectionAssignments > 0)
{
ApplyStaticDataSetSelection(device);
return;
}
- // Manual selection restores the normal Smart/Hybrid acquisition contract.
+ // IMPORTANT: automatic FAT bootstrap revisits already-connected Engineering devices.
+ // If that device already owns Static DataSet report-only authority, merely register
+ // the shared selection authority. Never demote it to Hybrid/MMS as a side effect of
+ // opening FAT; the Engineering acquisition mode is the protocol authority.
+ if (IsSharedStaticDataSetAuthority(device))
+ {
+ _sharedSclSelectionAuthorityDeviceIds.Add(device.DeviceId);
+ _sharedSclStaticDataSetAuthorityDeviceIds.Add(device.DeviceId);
+ SaveSignalSelectionMemory(device);
+ return;
+ }
+
+ // Only an explicit/manual selection path restores normal Smart/Hybrid acquisition.
_sharedSclStaticDataSetAuthorityDeviceIds.Remove(device.DeviceId);
Iec61850MonitoringModeRegistry.UseHybrid(device);
_sharedSclSelectionAuthorityDeviceIds.Add(device.DeviceId);
@@ -219,10 +233,6 @@ await OpenSignalSelectionWizardAsync(
autoStartAfterSave: false,
ownerOverride: owner);
- // The FAT window is not yet attached during an initial FAT import, so perform
- // the same bridge operation explicitly. Selected non-DataSet SCL signals are
- // materialized here as persistent FAT rows; existing FAT TEST/disposition state
- // is never rewritten by Engineering selection.
foreach (var signal in device.Signals)
{
IoFatEngineeringSelectionBridge.ApplyEngineeringSignalSelection(
@@ -235,4 +245,4 @@ await OpenSignalSelectionWizardAsync(
MarkSharedSelectionAuthority(device);
}
}
-}
\ No newline at end of file
+}
diff --git a/MainWindow.xaml b/MainWindow.xaml
index 205519e97..af057d89c 100644
--- a/MainWindow.xaml
+++ b/MainWindow.xaml
@@ -121,8 +121,9 @@
+
-
@@ -151,6 +152,7 @@
+
@@ -1684,7 +1686,12 @@
-
+
+
+
+
+
+
diff --git a/MainWindow.xaml.cs b/MainWindow.xaml.cs
index 4f55a7528..00ae66f8a 100644
--- a/MainWindow.xaml.cs
+++ b/MainWindow.xaml.cs
@@ -620,7 +620,7 @@ private void NavButton_Click(object sender, RoutedEventArgs e)
{
if (sender is not Button button || !int.TryParse(button.Tag?.ToString(), out var index))
return;
- index = Math.Clamp(index, 0, 5);
+ index = Math.Clamp(index, 0, NativeFatWorkspaceIndex);
MainTabs.SelectedIndex = index;
UpdateNavigationVisuals(index, animate: true);
}
@@ -654,7 +654,21 @@ private void UpdateNavigationVisuals(int index, bool animate)
if (WorkflowPillTranslate == null)
return;
- var target = Math.Clamp(index, 0, 5) * 150d;
+ index = Math.Clamp(index, 0, NativeFatWorkspaceIndex);
+
+ // MainWindow is the single owner of all seven Engineering destinations.
+ // Keep the same density used by the proven workstation shell while allowing
+ // enough width for the Explorer label and the new canonical FAT sibling.
+ var availableWidth = ActualWidth > 0d ? ActualWidth : 1480d;
+ var shellWidth = availableWidth >= 1700d ? 1085d : availableWidth >= 1380d ? 995d : 805d;
+ WorkflowNavShell.Width = shellWidth;
+ WorkflowNavShell.MinWidth = shellWidth;
+
+ var contentWidth = Math.Max(0d, shellWidth - WorkflowNavShell.Padding.Left - WorkflowNavShell.Padding.Right);
+ var cellWidth = contentWidth / 7d;
+ WorkflowPill.Width = Math.Max(1d, cellWidth - 2d);
+ var target = index * cellWidth;
+
if (animate)
{
var animation = new DoubleAnimation(target, TimeSpan.FromMilliseconds(190))
@@ -669,7 +683,16 @@ private void UpdateNavigationVisuals(int index, bool animate)
WorkflowPillTranslate.X = target;
}
- var buttons = new[] { NavExplorerButton, NavLiveButton, NavEventsButton, NavAlarmButton, NavGooseButton, NavDiagnosticsButton };
+ var buttons = new[]
+ {
+ NavExplorerButton,
+ NavLiveButton,
+ NavEventsButton,
+ NavAlarmButton,
+ NavGooseButton,
+ NavDiagnosticsButton,
+ NavNativeFatButton
+ };
for (var i = 0; i < buttons.Length; i++)
buttons[i].Foreground = i == index ? Brushes.White : new SolidColorBrush(Color.FromRgb(71, 84, 103));
}
diff --git a/Models/NativeFatModels.cs b/Models/NativeFatModels.cs
new file mode 100644
index 000000000..f94d7b3a3
--- /dev/null
+++ b/Models/NativeFatModels.cs
@@ -0,0 +1,326 @@
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+
+namespace ArIED61850Tester.Models;
+
+///
+/// Persistent, acquisition-independent FAT state layered on top of the canonical
+/// Engineering/IED Explorer signal model. Nothing here owns MMS, report-control,
+/// polling, or command runtime state.
+///
+public sealed class NativeFatDeviceState
+{
+ public int SchemaVersion { get; set; } = 1;
+ public string DeviceId { get; set; } = string.Empty;
+ public string IedName { get; set; } = string.Empty;
+ public DateTimeOffset CreatedUtc { get; set; } = DateTimeOffset.UtcNow;
+ public DateTimeOffset UpdatedUtc { get; set; } = DateTimeOffset.UtcNow;
+ public List Signals { get; set; } = new();
+
+ [System.Text.Json.Serialization.JsonIgnore]
+ public string StoragePath { get; set; } = string.Empty;
+}
+
+public sealed class NativeFatSignalState
+{
+ ///
+ /// Stable per-IED identity: normalized IEC object reference + FC. Display labels
+ /// are deliberately excluded so a signal rename does not erase commissioning work.
+ ///
+ public string Key { get; set; } = string.Empty;
+ public string SignalName { get; set; } = string.Empty;
+ public string IecReference { get; set; } = string.Empty;
+ public string FunctionalConstraint { get; set; } = string.Empty;
+ public string DataType { get; set; } = string.Empty;
+ public DateTimeOffset FirstSeenUtc { get; set; } = DateTimeOffset.UtcNow;
+ public DateTimeOffset LastSeenUtc { get; set; } = DateTimeOffset.UtcNow;
+ public bool IsHistorical { get; set; }
+ public NativeFatCapture? Value1 { get; set; }
+ public NativeFatCapture? Value2 { get; set; }
+ public string Result { get; set; } = NativeFatResult.Untested;
+ public List History { get; set; } = new();
+}
+
+public sealed class NativeFatCapture
+{
+ public string Value { get; set; } = "-";
+ public string Quality { get; set; } = "Unknown";
+ public string DeviceTimestamp { get; set; } = "-";
+ public string SourceMode { get; set; } = "Unknown";
+ public long Sequence { get; set; }
+ public DateTimeOffset CapturedUtc { get; set; } = DateTimeOffset.UtcNow;
+}
+
+public sealed class NativeFatHistoryEntry
+{
+ public DateTimeOffset TimestampUtc { get; set; } = DateTimeOffset.UtcNow;
+ public string Action { get; set; } = string.Empty;
+ public string Result { get; set; } = string.Empty;
+ public NativeFatCapture? Value1 { get; set; }
+ public NativeFatCapture? Value2 { get; set; }
+ public string Note { get; set; } = string.Empty;
+}
+
+public static class NativeFatResult
+{
+ public const string Untested = "UNTESTED";
+ public const string Pass = "PASS";
+ public const string Review = "REVIEW";
+ public const string Fail = "FAIL";
+}
+
+public static class NativeFatIdentity
+{
+ public static string BuildKey(SignalDefinition signal)
+ => BuildKey(signal.ObjectReference, signal.FunctionalConstraint);
+
+ public static string BuildKey(Iec61850MonitorPoint point)
+ => BuildKey(point.IecReference, point.FunctionalConstraint);
+
+ public static string BuildKey(string? reference, string? functionalConstraint)
+ {
+ var normalized = NormalizeReference(reference);
+ var fc = (functionalConstraint ?? string.Empty).Trim().ToUpperInvariant();
+ return string.IsNullOrWhiteSpace(fc) ? normalized : $"{normalized}|{fc}";
+ }
+
+ public static string NormalizeReference(string? reference)
+ {
+ var value = (reference ?? string.Empty)
+ .Trim()
+ .Replace('$', '.')
+ .Replace("..", ".", StringComparison.Ordinal);
+ return value.ToUpperInvariant();
+ }
+}
+
+///
+/// Lightweight FAT projection. Engineering identity and current value come directly
+/// from the Explorer's SignalDefinition, with a monitor point used when available for
+/// the richer IEC telegram/acquisition metadata. FAT captures/results remain separate.
+/// Historical rows intentionally have neither live source.
+///
+public sealed class NativeFatSignalRow : INotifyPropertyChanged, IDisposable
+{
+ private SignalDefinition? _sourceSignal;
+ private Iec61850MonitorPoint? _sourcePoint;
+
+ public NativeFatSignalRow(
+ NativeFatSignalState state,
+ SignalDefinition? sourceSignal,
+ Iec61850MonitorPoint? sourcePoint)
+ {
+ State = state ?? throw new ArgumentNullException(nameof(state));
+ AttachSources(sourceSignal, sourcePoint);
+ }
+
+ public NativeFatSignalState State { get; }
+ public SignalDefinition? SourceSignal => _sourceSignal;
+ public Iec61850MonitorPoint? SourcePoint => _sourcePoint;
+ public string Key => State.Key;
+ public string SignalName => _sourceSignal?.Name ?? _sourcePoint?.SignalName ?? State.SignalName;
+ public string IecReference => _sourceSignal?.ObjectReference ?? _sourcePoint?.IecReference ?? State.IecReference;
+ public string IecTelegram => _sourcePoint?.IecTelegram ?? _sourceSignal?.DisplayReference ?? State.IecReference;
+ public string DataType => _sourceSignal?.DataType ?? _sourcePoint?.IecDataType ?? State.DataType;
+ public string FunctionalConstraint => _sourceSignal?.FunctionalConstraint ?? _sourcePoint?.FunctionalConstraint ?? State.FunctionalConstraint;
+ public string LiveValue => _sourcePoint?.DisplayValue ?? _sourceSignal?.Value ?? "-";
+ public string Quality => _sourcePoint?.Quality ?? _sourceSignal?.Quality ?? (IsHistorical ? "Historical" : "Unknown");
+ public string DeviceTimestamp => _sourcePoint?.DeviceTimestamp ?? _sourceSignal?.DeviceTimestamp ?? "-";
+ public string Value1Text => State.Value1?.Value ?? "-";
+ public string Value2Text => State.Value2?.Value ?? "-";
+ public string Result => string.IsNullOrWhiteSpace(State.Result) ? NativeFatResult.Untested : State.Result;
+ public bool IsHistorical => _sourceSignal == null && _sourcePoint == null || State.IsHistorical;
+ public string StatusText => IsHistorical ? "HISTORICAL" : State.Value1 == null && State.Value2 == null ? "READY" : "CAPTURED";
+ public int HistoryCount => State.History?.Count ?? 0;
+ public string HistoryText => HistoryCount == 0 ? "—" : $"{HistoryCount} record{(HistoryCount == 1 ? string.Empty : "s")}";
+ public bool CanCapture => _sourceSignal != null || _sourcePoint != null;
+
+ public event PropertyChangedEventHandler? PropertyChanged;
+ public event EventHandler? StateChanged;
+
+ public void AttachSources(SignalDefinition? signal, Iec61850MonitorPoint? point)
+ {
+ if (!ReferenceEquals(_sourceSignal, signal))
+ {
+ if (_sourceSignal != null)
+ _sourceSignal.PropertyChanged -= SourceSignal_PropertyChanged;
+ _sourceSignal = signal;
+ if (_sourceSignal != null)
+ _sourceSignal.PropertyChanged += SourceSignal_PropertyChanged;
+ }
+
+ if (!ReferenceEquals(_sourcePoint, point))
+ {
+ if (_sourcePoint != null)
+ _sourcePoint.PropertyChanged -= SourcePoint_PropertyChanged;
+ _sourcePoint = point;
+ if (_sourcePoint != null)
+ _sourcePoint.PropertyChanged += SourcePoint_PropertyChanged;
+ }
+
+ RaiseAll();
+ }
+
+ public bool CaptureValue(int slot)
+ {
+ if (!CanCapture || slot is < 1 or > 2)
+ return false;
+
+ var capture = CaptureCurrent();
+ if (slot == 1)
+ State.Value1 = capture;
+ else
+ State.Value2 = capture;
+
+ State.LastSeenUtc = DateTimeOffset.UtcNow;
+ AppendHistory($"Capture Value {slot}");
+ Raise(nameof(Value1Text));
+ Raise(nameof(Value2Text));
+ Raise(nameof(StatusText));
+ Raise(nameof(HistoryCount));
+ Raise(nameof(HistoryText));
+ StateChanged?.Invoke(this, EventArgs.Empty);
+ return true;
+ }
+
+ public void SetResult(string result)
+ {
+ result = result switch
+ {
+ NativeFatResult.Pass => NativeFatResult.Pass,
+ NativeFatResult.Fail => NativeFatResult.Fail,
+ NativeFatResult.Review => NativeFatResult.Review,
+ _ => NativeFatResult.Untested
+ };
+ if (State.Result.Equals(result, StringComparison.OrdinalIgnoreCase))
+ return;
+
+ State.Result = result;
+ State.LastSeenUtc = DateTimeOffset.UtcNow;
+ AppendHistory($"Result {result}");
+ Raise(nameof(Result));
+ Raise(nameof(HistoryCount));
+ Raise(nameof(HistoryText));
+ StateChanged?.Invoke(this, EventArgs.Empty);
+ }
+
+ public void ResetCurrentResult()
+ {
+ if (State.Value1 == null && State.Value2 == null &&
+ State.Result.Equals(NativeFatResult.Untested, StringComparison.OrdinalIgnoreCase))
+ return;
+
+ AppendHistory("Reset current FAT state");
+ State.Value1 = null;
+ State.Value2 = null;
+ State.Result = NativeFatResult.Untested;
+ State.LastSeenUtc = DateTimeOffset.UtcNow;
+ Raise(nameof(Value1Text));
+ Raise(nameof(Value2Text));
+ Raise(nameof(Result));
+ Raise(nameof(StatusText));
+ Raise(nameof(HistoryCount));
+ Raise(nameof(HistoryText));
+ StateChanged?.Invoke(this, EventArgs.Empty);
+ }
+
+ private NativeFatCapture CaptureCurrent()
+ => new()
+ {
+ Value = LiveValue,
+ Quality = Quality,
+ DeviceTimestamp = DeviceTimestamp,
+ SourceMode = _sourcePoint?.SourceMode ?? _sourceSignal?.ReportPlan ?? "Explorer",
+ Sequence = _sourcePoint?.Sequence ?? 0,
+ CapturedUtc = DateTimeOffset.UtcNow
+ };
+
+ private void AppendHistory(string action)
+ {
+ State.History ??= new List();
+ State.History.Add(new NativeFatHistoryEntry
+ {
+ TimestampUtc = DateTimeOffset.UtcNow,
+ Action = action,
+ Result = Result,
+ Value1 = Clone(State.Value1),
+ Value2 = Clone(State.Value2)
+ });
+ }
+
+ private static NativeFatCapture? Clone(NativeFatCapture? source)
+ => source == null ? null : new NativeFatCapture
+ {
+ Value = source.Value,
+ Quality = source.Quality,
+ DeviceTimestamp = source.DeviceTimestamp,
+ SourceMode = source.SourceMode,
+ Sequence = source.Sequence,
+ CapturedUtc = source.CapturedUtc
+ };
+
+ private void SourceSignal_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+ {
+ switch (e.PropertyName)
+ {
+ case nameof(SignalDefinition.Value):
+ if (_sourcePoint == null) Raise(nameof(LiveValue));
+ break;
+ case nameof(SignalDefinition.Quality):
+ if (_sourcePoint == null) Raise(nameof(Quality));
+ break;
+ case nameof(SignalDefinition.DeviceTimestamp):
+ if (_sourcePoint == null) Raise(nameof(DeviceTimestamp));
+ break;
+ default:
+ return;
+ }
+ }
+
+ private void SourcePoint_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+ {
+ switch (e.PropertyName)
+ {
+ case nameof(Iec61850MonitorPoint.Value):
+ case nameof(Iec61850MonitorPoint.DisplayValue):
+ Raise(nameof(LiveValue));
+ break;
+ case nameof(Iec61850MonitorPoint.Quality):
+ Raise(nameof(Quality));
+ break;
+ case nameof(Iec61850MonitorPoint.DeviceTimestamp):
+ Raise(nameof(DeviceTimestamp));
+ break;
+ default:
+ return;
+ }
+ }
+
+ private void RaiseAll()
+ {
+ Raise(nameof(SignalName));
+ Raise(nameof(IecReference));
+ Raise(nameof(IecTelegram));
+ Raise(nameof(DataType));
+ Raise(nameof(FunctionalConstraint));
+ Raise(nameof(LiveValue));
+ Raise(nameof(Quality));
+ Raise(nameof(DeviceTimestamp));
+ Raise(nameof(IsHistorical));
+ Raise(nameof(StatusText));
+ Raise(nameof(CanCapture));
+ }
+
+ private void Raise([CallerMemberName] string? propertyName = null)
+ => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+
+ public void Dispose()
+ {
+ if (_sourceSignal != null)
+ _sourceSignal.PropertyChanged -= SourceSignal_PropertyChanged;
+ if (_sourcePoint != null)
+ _sourcePoint.PropertyChanged -= SourcePoint_PropertyChanged;
+ _sourceSignal = null;
+ _sourcePoint = null;
+ }
+}
diff --git a/Models/NativeFatReportModels.cs b/Models/NativeFatReportModels.cs
new file mode 100644
index 000000000..0433088e8
--- /dev/null
+++ b/Models/NativeFatReportModels.cs
@@ -0,0 +1,63 @@
+namespace ArIED61850Tester.Models;
+
+///
+/// Immutable report-time projection of one native FAT device. The snapshot deliberately
+/// copies persisted evidence instead of binding a report directly to live Explorer rows,
+/// so preview/export content cannot drift while acquisition continues in the background.
+///
+public sealed record NativeFatReportSnapshot(
+ string DeviceId,
+ string IedName,
+ string IpAddress,
+ int Port,
+ DateTimeOffset GeneratedUtc,
+ IReadOnlyList Rows)
+{
+ public int CurrentCount => Rows.Count(row => !row.IsHistorical);
+ public int HistoricalCount => Rows.Count(row => row.IsHistorical);
+ public int PassCount => Rows.Count(row => !row.IsHistorical && row.Result == NativeFatResult.Pass);
+ public int ReviewCount => Rows.Count(row => !row.IsHistorical && row.Result == NativeFatResult.Review);
+ public int FailCount => Rows.Count(row => !row.IsHistorical && row.Result == NativeFatResult.Fail);
+ public int UntestedCount => Math.Max(0, CurrentCount - PassCount - ReviewCount - FailCount);
+
+ public string SummaryText =>
+ $"Current {CurrentCount} · PASS {PassCount} · REVIEW {ReviewCount} · FAIL {FailCount} · UNTESTED {UntestedCount} · historical {HistoricalCount}";
+}
+
+public sealed record NativeFatReportRow(
+ string SignalName,
+ string IecReference,
+ string FunctionalConstraint,
+ string DataType,
+ bool IsHistorical,
+ string Result,
+ int HistoryCount,
+ string Value1Text,
+ string Value1Quality,
+ string Value1DeviceTimestamp,
+ string Value1SourceMode,
+ DateTimeOffset? Value1CapturedUtc,
+ string Value2Text,
+ string Value2Quality,
+ string Value2DeviceTimestamp,
+ string Value2SourceMode,
+ DateTimeOffset? Value2CapturedUtc)
+{
+ public string ScopeText => IsHistorical ? "HISTORICAL" : "CURRENT";
+ public string HistoryText => HistoryCount == 0 ? "—" : $"{HistoryCount} record{(HistoryCount == 1 ? string.Empty : "s")}";
+
+ public string Value1CapturedText => Value1CapturedUtc?.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss.fff") ?? "—";
+ public string Value2CapturedText => Value2CapturedUtc?.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss.fff") ?? "—";
+
+ public string EvidenceSummaryText =>
+ $"{IecReference} [{FunctionalConstraint}] · {DataType}\n" +
+ $"V1: {Value1Text} · q={Value1Quality} · IED={NormalizeTimestamp(Value1DeviceTimestamp)} · capture={Value1CapturedText} · {NormalizeSource(Value1SourceMode)}\n" +
+ $"V2: {Value2Text} · q={Value2Quality} · IED={NormalizeTimestamp(Value2DeviceTimestamp)} · capture={Value2CapturedText} · {NormalizeSource(Value2SourceMode)}\n" +
+ $"{ScopeText} · {Result} · history {HistoryText}";
+
+ private static string NormalizeTimestamp(string value)
+ => string.IsNullOrWhiteSpace(value) ? "—" : value.Trim();
+
+ private static string NormalizeSource(string value)
+ => string.IsNullOrWhiteSpace(value) ? "Unknown" : value.Trim();
+}
diff --git a/SasOperationalUiPolicy.cs b/SasOperationalUiPolicy.cs
index cd9cd10d7..8c63dbce2 100644
--- a/SasOperationalUiPolicy.cs
+++ b/SasOperationalUiPolicy.cs
@@ -24,7 +24,7 @@ internal static class SasOperationalUiPolicy
private static readonly ConditionalWeakTable FilteredViews = new();
private static readonly string[] NavigationButtonNames =
{
- "NavExplorerButton", "NavLiveButton", "NavEventsButton", "NavAlarmButton", "NavGooseButton", "NavDiagnosticsButton"
+ "NavExplorerButton", "NavLiveButton", "NavEventsButton", "NavAlarmButton", "NavGooseButton", "NavDiagnosticsButton", "NavNativeFatButton"
};
[ModuleInitializer]
diff --git a/Services/IoTesting/IoFatEngineeringSelectionBridge.cs b/Services/IoTesting/IoFatEngineeringSelectionBridge.cs
index 49d830dcd..785bd8213 100644
--- a/Services/IoTesting/IoFatEngineeringSelectionBridge.cs
+++ b/Services/IoTesting/IoFatEngineeringSelectionBridge.cs
@@ -306,6 +306,32 @@ internal static int RetireRedundantManualWorkspaceRows(IoTestIedPlan ied)
return changed;
}
+ ///
+ /// Automatic Engineering -> FAT bootstrap is a Static DataSet workflow. Static FCDA/FCD
+ /// membership is therefore the complete FAT workspace authority for that bootstrap.
+ /// Persisted/manual SCL rows are retained for audit/evidence continuity but are removed
+ /// from the shared active workspace so they cannot shadow an authoritative static member
+ /// after both references resolve to the same primary live leaf.
+ ///
+ internal static int RetireManualWorkspaceRowsForStaticDataSetMode(IoTestIedPlan ied)
+ {
+ ArgumentNullException.ThrowIfNull(ied);
+ if (!ied.TestPoints.Any(IoTestSignalSelectionService.IsSclDataSetAuthority))
+ return 0;
+
+ var changed = 0;
+ foreach (var point in ied.TestPoints.Where(IoTestSignalSelectionService.IsSclWorkspaceAuthority))
+ {
+ if (!point.WorkspaceSelected)
+ continue;
+
+ point.WorkspaceSelected = false;
+ changed++;
+ }
+
+ return changed;
+ }
+
private static HashSet FindRedundantManualWorkspacePoints(IoTestIedPlan ied)
=> ied.TestPoints
.Where(IoTestSignalSelectionService.IsSclWorkspaceAuthority)
diff --git a/Services/IoTesting/IoFatEngineeringWorkspaceProjectionService.cs b/Services/IoTesting/IoFatEngineeringWorkspaceProjectionService.cs
new file mode 100644
index 000000000..d6c9bc89c
--- /dev/null
+++ b/Services/IoTesting/IoFatEngineeringWorkspaceProjectionService.cs
@@ -0,0 +1,219 @@
+using AR.Iec61850.Scl.Workspace;
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Models.IoTesting;
+
+namespace ArIED61850Tester.Services.IoTesting;
+
+public sealed record IoFatEngineeringWorkspaceProjection(
+ IoTestProject Project,
+ IReadOnlyList SourceInputs,
+ IReadOnlyList RuntimeWorkspaces);
+
+///
+/// Builds the production FAT project directly from the already-parsed Engineering SCL
+/// workspaces. This is deliberately not an SCL importer: it never opens/parses XML and it
+/// never creates a second IEC 61850 model. Engineering remains the static DataSet/live-value
+/// authority; FAT adds only its production evidence/session lifecycle on top.
+///
+public static class IoFatEngineeringWorkspaceProjectionService
+{
+ public static async Task BuildAsync(
+ IReadOnlyCollection devices,
+ CancellationToken cancellationToken = default)
+ {
+ ArgumentNullException.ThrowIfNull(devices);
+
+ var usable = devices
+ .Where(device => device.SclWorkspace != null)
+ .Where(device => device.SclWorkspace!.DesignModel.DataSets.Sum(dataSet => dataSet.Members.Count) > 0)
+ .Where(device => !string.IsNullOrWhiteSpace(device.SclSourcePath))
+ .GroupBy(device => device.DeviceId, StringComparer.OrdinalIgnoreCase)
+ .Select(group => group.Last())
+ .ToArray();
+ if (usable.Length == 0)
+ {
+ throw new InvalidDataException(
+ "No Engineering IED has an already-parsed SCL workspace with static DataSet members and source provenance.");
+ }
+
+ var sourceInputs = usable
+ .Select(device => Path.GetFullPath(device.SclSourcePath))
+ .Distinct(StringComparer.OrdinalIgnoreCase)
+ .Select(path => new IoFatSourceInput(path, IoFatSourceKinds.Scl))
+ .ToArray();
+ var described = await IoFatSourceWorkspaceService.DescribeAsync(sourceInputs, cancellationToken)
+ .ConfigureAwait(false);
+ var descriptorByPath = described.ToDictionary(
+ item => Path.GetFullPath(item.OriginalPath),
+ item => item.Source,
+ StringComparer.OrdinalIgnoreCase);
+
+ foreach (var device in usable)
+ {
+ cancellationToken.ThrowIfCancellationRequested();
+ var path = Path.GetFullPath(device.SclSourcePath);
+ if (!descriptorByPath.TryGetValue(path, out var descriptor))
+ throw new InvalidDataException($"Engineering SCL provenance is unavailable for '{device.Name}'.");
+ if (!string.IsNullOrWhiteSpace(device.SclSourceSha256) &&
+ !descriptor.Sha256.Equals(device.SclSourceSha256, StringComparison.OrdinalIgnoreCase))
+ {
+ throw new InvalidDataException(
+ $"The Engineering SCL source for '{device.Name}' changed on disk after it was parsed. FAT will not bind a stale in-memory model to different source bytes.");
+ }
+ }
+
+ var workspaceSources = usable
+ .Select(device =>
+ {
+ var descriptor = descriptorByPath[Path.GetFullPath(device.SclSourcePath)];
+ return new FatSclWorkspaceSource(
+ descriptor.FileName,
+ descriptor.Sha256,
+ device.SclWorkspace!);
+ })
+ .ToArray();
+ var verification = FatSclWorkspaceImportService.Import(workspaceSources).Project;
+
+ var deviceByWorkspace = usable
+ .GroupBy(device => WorkspaceIdentity(device.SclWorkspace!), StringComparer.OrdinalIgnoreCase)
+ .ToDictionary(group => group.Key, group => group.First(), StringComparer.OrdinalIgnoreCase);
+ var descriptorByWorkspace = usable
+ .GroupBy(device => WorkspaceIdentity(device.SclWorkspace!), StringComparer.OrdinalIgnoreCase)
+ .ToDictionary(
+ group => group.Key,
+ group => descriptorByPath[Path.GetFullPath(group.First().SclSourcePath)],
+ StringComparer.OrdinalIgnoreCase);
+
+ var plans = new List();
+ foreach (var workspaceGroup in workspaceSources
+ .GroupBy(source => WorkspaceIdentity(source.Workspace), StringComparer.OrdinalIgnoreCase)
+ .OrderBy(group => group.Key, StringComparer.OrdinalIgnoreCase))
+ {
+ var workspace = workspaceGroup.First().Workspace;
+ var key = WorkspaceIdentity(workspace);
+ var device = deviceByWorkspace[key];
+ var descriptor = descriptorByWorkspace[key];
+ var signals = verification.Signals
+ .Where(signal => WorkspaceIdentity(signal.IedName, signal.AccessPointName)
+ .Equals(key, StringComparison.OrdinalIgnoreCase))
+ .OrderBy(signal => signal.DataSetReference, StringComparer.OrdinalIgnoreCase)
+ .ThenBy(signal => signal.DataSetMemberIndex)
+ .ToArray();
+
+ var endpoint = !string.IsNullOrWhiteSpace(device.IpAddress)
+ ? device.IpAddress
+ : workspace.PreferredEndpoint?.HasUsableAddress == true
+ ? workspace.PreferredEndpoint.IpAddress
+ : string.Empty;
+ var plan = new IoTestIedPlan
+ {
+ IedName = workspace.IedName,
+ IpAddress = endpoint,
+ IedRole = FirstNonEmpty(workspace.IedType, workspace.Manufacturer),
+ TestPoints = signals.Select(signal => ToPointPlan(signal, descriptor, workspace, endpoint)).ToList()
+ };
+ plan.ApplyLiveDeviceBinding(
+ device.DeviceId,
+ device.IsMonitoring ? "Engineering acquisition active" : device.IsConnected ? "Engineering association ready" : "Engineering SCL model ready",
+ device.IsConnected,
+ device.IsMonitoring);
+ plans.Add(plan);
+ }
+
+ var sourceDescriptors = described
+ .Select(item => item.Source)
+ .GroupBy(source => source.SourceId, StringComparer.OrdinalIgnoreCase)
+ .Select(group => group.First())
+ .OrderBy(source => source.SourceId, StringComparer.Ordinal)
+ .ToArray();
+ var sourceFingerprint = IoFatSourceIdentity.ComputeSetFingerprint(sourceDescriptors);
+ var project = new IoTestProject
+ {
+ ProjectId = "FAT-SCL-" + sourceFingerprint[..16],
+ SchemaVersion = "ARSAS-FAT-SCL-1.0",
+ ProjectName = sourceDescriptors.Length == 1
+ ? Path.GetFileNameWithoutExtension(sourceDescriptors[0].FileName) + " FAT"
+ : $"IEC 61850 SCL FAT ({sourceDescriptors.Length} sources)",
+ DocumentControl = new IoFatDocumentControl
+ {
+ DocumentTitle = "IEC 61850 FAT",
+ SourceDocumentName = string.Join("; ", sourceDescriptors.Select(source => source.FileName))
+ },
+ Ieds = plans
+ };
+ project.SetSources(sourceDescriptors, sourceFingerprint);
+ project.InitializeRuntimeNotifications();
+
+ var staticMemberCount = usable.Sum(device =>
+ device.SclWorkspace!.DesignModel.DataSets.Sum(dataSet => dataSet.Members.Count));
+ if (project.SignalCount != verification.Signals.Count || project.SignalCount != staticMemberCount)
+ {
+ throw new InvalidDataException(
+ $"Engineering FAT projection produced {project.SignalCount} row(s), but the authoritative static DataSet scope contains {staticMemberCount}. FAT refuses a partial projection.");
+ }
+
+ return new IoFatEngineeringWorkspaceProjection(
+ project,
+ sourceInputs,
+ usable.Select(device => device.SclWorkspace!).ToArray());
+ }
+
+ private static IoTestPointPlan ToPointPlan(
+ FatVerificationSignal signal,
+ IoFatSourceDescriptor source,
+ SclIedWorkspace workspace,
+ string endpoint)
+ {
+ var discrete = signal.SignalKind == FatSignalKind.Discrete;
+ return new IoTestPointPlan
+ {
+ TestPointId = $"scl-{source.SourceId}-{signal.SignalId}",
+ IedName = signal.IedName,
+ IpAddress = endpoint,
+ SignalName = signal.SignalName,
+ ObjectReference = FirstNonEmpty(signal.RuntimeReference, signal.StaticMemberReference),
+ FunctionalConstraint = signal.FunctionalConstraint,
+ ExpectedOnText = discrete ? "TRUE" : "Value 1",
+ ExpectedOffText = discrete ? "FALSE" : "Value 2",
+ ExpectedOnRaw = 1,
+ ExpectedOffRaw = 0,
+ DataType = signal.DataType,
+ SignalAddress = source.SourceId,
+ DataSetName = signal.DataSetReference,
+ SourceIecReference = signal.StaticMemberReference,
+ ReportDisplayReference = signal.StaticMemberReference,
+ EventLogSearchReference = signal.StaticMemberReference,
+ EvidenceExpected = signal.CaptureMode == FatCaptureMode.AutomaticTransition
+ ? "Automatic Value 1 / Value 2 transition capture"
+ : "Operator Value 1 / Value 2 snapshot capture",
+ SourceSheet = source.FileName,
+ SourceRow = signal.DataSetMemberIndex + 1,
+ SignalKind = signal.SignalKind,
+ CaptureMode = signal.CaptureMode,
+ TestEnabled = true,
+ ImportReady = true,
+ BindingStatus = "ENGINEERING_SCL_DATASET_AUTHORITY",
+ BindingEvidence = string.Join(" • ", new[]
+ {
+ "shared Engineering ARIEC static DataSet authority",
+ $"sourceId={source.SourceId}",
+ $"sourceSha256={source.Sha256}",
+ $"workspace={workspace.WorkspaceKey}",
+ $"dataset={signal.DataSetReference}",
+ $"memberIndex={signal.DataSetMemberIndex}",
+ $"static={signal.StaticMemberReference}",
+ $"kind={signal.SignalKind}",
+ $"capture={signal.CaptureMode}"
+ })
+ };
+ }
+
+ private static string WorkspaceIdentity(SclIedWorkspace workspace)
+ => WorkspaceIdentity(workspace.IedName, workspace.AccessPointName);
+
+ private static string WorkspaceIdentity(string? iedName, string? accessPointName)
+ => $"{(iedName ?? string.Empty).Trim()}|{(accessPointName ?? string.Empty).Trim()}";
+
+ private static string FirstNonEmpty(params string?[] values)
+ => values.FirstOrDefault(value => !string.IsNullOrWhiteSpace(value))?.Trim() ?? string.Empty;
+}
diff --git a/Services/IoTesting/IoFatProductionControllerAdapter.cs b/Services/IoTesting/IoFatProductionControllerAdapter.cs
new file mode 100644
index 000000000..d501009ed
--- /dev/null
+++ b/Services/IoTesting/IoFatProductionControllerAdapter.cs
@@ -0,0 +1,137 @@
+using ArIED61850Tester.Models.IoTesting;
+
+namespace ArIED61850Tester.Services.IoTesting;
+
+///
+/// M4 transaction boundary between Engineering's mutable view context and the existing
+/// production FAT evidence engine. It freezes the operator-selected IED and exact capture
+/// scope before asynchronous connection preparation, then revalidates that lease before
+/// delegating to .
+///
+/// This class deliberately does not parse SCL, discover/connect an IED, evaluate transitions,
+/// or write evidence. Those authorities remain with Engineering and IoTestSessionController.
+///
+public static class IoFatProductionControllerAdapter
+{
+ public static IoFatCaptureTargetLease LatchStartTarget(
+ IoTestProject project,
+ IoTestIedPlan? ied)
+ {
+ ArgumentNullException.ThrowIfNull(project);
+ if (ied == null)
+ throw new InvalidOperationException("Select an imported IED first.");
+ if (!project.Ieds.Contains(ied))
+ throw new InvalidOperationException("The selected IED is no longer part of this FAT project.");
+
+ var preflight = IoTestSessionPreflight.Validate(ied);
+ if (!preflight.Succeeded)
+ throw new InvalidOperationException(preflight.Message);
+
+ var points = ied.TestPoints
+ .Where(point =>
+ point.WorkspaceSelected &&
+ point.IsIncludedInFat &&
+ point.TestEnabled &&
+ point.ImportReady)
+ .Distinct()
+ .Select(point => new IoFatCapturePointLease(
+ point,
+ IoTestPerIedProgressIdentity.PointConfigurationFingerprint(point)))
+ .ToArray();
+ if (points.Length == 0)
+ {
+ throw new InvalidOperationException(
+ "No import-ready operator-selected signal is available in the requested FAT capture scope.");
+ }
+
+ return new IoFatCaptureTargetLease(
+ ied,
+ IoTestPerIedProgressIdentity.IedKey(ied),
+ ied.LiveDeviceId?.Trim() ?? string.Empty,
+ points);
+ }
+
+ public static IoTestSessionActionResult StartLatched(
+ IoTestProject project,
+ IoTestMultiSessionCoordinator sessions,
+ IoFatCaptureTargetLease lease)
+ {
+ ArgumentNullException.ThrowIfNull(project);
+ ArgumentNullException.ThrowIfNull(sessions);
+ ArgumentNullException.ThrowIfNull(lease);
+
+ var validation = ValidateLease(project, lease);
+ if (!validation.Succeeded)
+ return validation;
+
+ // The existing production controller remains the only evidence writer. Passing the
+ // frozen scope prevents an async Engineering prepare from silently broadening or
+ // redirecting the session when Explorer selection/workspace membership changes.
+ return sessions.Start(lease.Ied, lease.CaptureScope);
+ }
+
+ public static IoTestSessionActionResult ValidateLease(
+ IoTestProject project,
+ IoFatCaptureTargetLease lease)
+ {
+ ArgumentNullException.ThrowIfNull(project);
+ ArgumentNullException.ThrowIfNull(lease);
+
+ if (!project.Ieds.Contains(lease.Ied))
+ return IoTestSessionActionResult.Failure("The latched FAT IED left the project while connection preparation was running. No evidence session was started.");
+
+ var currentIedIdentity = IoTestPerIedProgressIdentity.IedKey(lease.Ied);
+ if (!currentIedIdentity.Equals(lease.IedIdentity, StringComparison.OrdinalIgnoreCase))
+ {
+ return IoTestSessionActionResult.Failure(
+ "The latched IEC IED identity or endpoint changed during connection preparation. No evidence session was started.");
+ }
+
+ var currentDeviceId = lease.Ied.LiveDeviceId?.Trim() ?? string.Empty;
+ if (!string.IsNullOrWhiteSpace(lease.DeviceId) &&
+ !currentDeviceId.Equals(lease.DeviceId, StringComparison.OrdinalIgnoreCase))
+ {
+ return IoTestSessionActionResult.Failure(
+ "The Engineering DeviceId bound to the latched FAT IED changed during connection preparation. No evidence session was started.");
+ }
+
+ foreach (var pointLease in lease.Points)
+ {
+ var point = pointLease.Point;
+ if (!lease.Ied.TestPoints.Contains(point))
+ {
+ return IoTestSessionActionResult.Failure(
+ "A latched FAT row left its owning IED during connection preparation. No evidence session was started.");
+ }
+ if (!point.WorkspaceSelected || !point.IsIncludedInFat || !point.TestEnabled || !point.ImportReady)
+ {
+ return IoTestSessionActionResult.Failure(
+ $"The latched FAT row '{point.SignalName}' changed eligibility during connection preparation. Review the scope and press Start FAT again.");
+ }
+
+ var fingerprint = IoTestPerIedProgressIdentity.PointConfigurationFingerprint(point);
+ if (!fingerprint.Equals(pointLease.ConfigurationFingerprint, StringComparison.OrdinalIgnoreCase))
+ {
+ return IoTestSessionActionResult.Failure(
+ $"The IEC/evidence configuration of latched FAT row '{point.SignalName}' changed during connection preparation. No evidence session was started.");
+ }
+ }
+
+ return IoTestSessionActionResult.Success(
+ $"Latched FAT target verified: {lease.Ied.IedName} · {lease.Points.Count} point(s).");
+ }
+}
+
+public sealed record IoFatCapturePointLease(
+ IoTestPointPlan Point,
+ string ConfigurationFingerprint);
+
+public sealed record IoFatCaptureTargetLease(
+ IoTestIedPlan Ied,
+ string IedIdentity,
+ string DeviceId,
+ IReadOnlyList Points)
+{
+ public IReadOnlyList CaptureScope { get; } =
+ Points.Select(point => point.Point).ToArray();
+}
diff --git a/Services/IoTesting/IoFatSclProjectImportService.cs b/Services/IoTesting/IoFatSclProjectImportService.cs
index 398915baf..da208b075 100644
--- a/Services/IoTesting/IoFatSclProjectImportService.cs
+++ b/Services/IoTesting/IoFatSclProjectImportService.cs
@@ -67,6 +67,22 @@ internal bool TryGetRuntimeWorkspace(
}
}
+ ///
+ /// Registers ARIEC workspaces that are already owned by Engineering. This is the
+ /// zero-reparse bridge used by the embedded FAT tab: the exact SclIedWorkspace objects
+ /// already attached to Explorer devices become the production FAT runtime authority.
+ ///
+ internal void AdoptEngineeringRuntimeWorkspaces(IEnumerable workspaces)
+ {
+ ArgumentNullException.ThrowIfNull(workspaces);
+ var stable = workspaces
+ .Where(workspace => workspace != null)
+ .GroupBy(workspace => workspace.WorkspaceKey, StringComparer.OrdinalIgnoreCase)
+ .Select(group => group.Last())
+ .ToArray();
+ SetRuntimeWorkspaces(stable);
+ }
+
public Task ImportAsync(
IReadOnlyCollection sclPaths,
string? projectName = null,
diff --git a/Services/IoTesting/IoTestMultiSessionCoordinator.cs b/Services/IoTesting/IoTestMultiSessionCoordinator.cs
index 12037ac36..9c1d6236d 100644
--- a/Services/IoTesting/IoTestMultiSessionCoordinator.cs
+++ b/Services/IoTesting/IoTestMultiSessionCoordinator.cs
@@ -133,7 +133,9 @@ public IoTestSessionActionResult Start(
if (ied == null)
return IoTestSessionActionResult.Failure("Select an imported IED first.");
- SelectContext(ied);
+ // M3: the caller latches the capture target before any asynchronous IED
+ // preparation. Starting that target must never steal the Explorer/view context
+ // if the operator selected another IED while preparation was in flight.
IoTestSessionController controller;
try
{
@@ -154,16 +156,34 @@ public IoTestSessionActionResult Pause(string reason = "Paused by operator")
controller => controller.Pause(reason),
"No FAT evidence session is active for the selected IED.");
+ public IoTestSessionActionResult Pause(IoTestIedPlan? ied, string reason = "Paused by operator")
+ => TargetAction(
+ ied,
+ controller => controller.Pause(reason),
+ "No FAT evidence session is active for the latched IED.");
+
public IoTestSessionActionResult Resume()
=> SelectedAction(
controller => controller.Resume(),
"No paused or interrupted FAT evidence session belongs to the selected IED.");
+ public IoTestSessionActionResult Resume(IoTestIedPlan? ied)
+ => TargetAction(
+ ied,
+ controller => controller.Resume(),
+ "No paused or interrupted FAT evidence session belongs to the latched IED.");
+
public IoTestSessionActionResult Stop(string reason = "Stopped by operator")
=> SelectedAction(
controller => controller.Stop(reason),
"No FAT evidence session is active for the selected IED.");
+ public IoTestSessionActionResult Stop(IoTestIedPlan? ied, string reason = "Stopped by operator")
+ => TargetAction(
+ ied,
+ controller => controller.Stop(reason),
+ "No FAT evidence session is active for the latched IED.");
+
public IoTestSessionActionResult StopAll(string reason = "Stopped by operator")
{
ThrowIfDisposed();
@@ -342,6 +362,26 @@ private IoTestSessionController GetOrCreateController(IoTestIedPlan ied)
}
}
+ private IoTestSessionActionResult TargetAction(
+ IoTestIedPlan? ied,
+ Func action,
+ string missingMessage)
+ {
+ ThrowIfDisposed();
+ if (ied == null)
+ return IoTestSessionActionResult.Failure(missingMessage);
+
+ IoTestSessionController? controller;
+ lock (_sync)
+ _controllers.TryGetValue(ied, out controller);
+ if (controller == null)
+ return IoTestSessionActionResult.Failure(missingMessage);
+
+ var result = action(controller);
+ RaiseProjectionProperties();
+ return result;
+ }
+
private IoTestSessionActionResult SelectedAction(
Func action,
string missingMessage)
diff --git a/Services/IoTesting/IoTestPerIedProgressIdentity.cs b/Services/IoTesting/IoTestPerIedProgressIdentity.cs
index 62f220e5c..bb6511531 100644
--- a/Services/IoTesting/IoTestPerIedProgressIdentity.cs
+++ b/Services/IoTesting/IoTestPerIedProgressIdentity.cs
@@ -7,8 +7,9 @@ namespace ArIED61850Tester.Services.IoTesting;
///
/// Stable identity contract for restoring persisted FAT progress onto a freshly imported plan.
-/// IED ownership is technical-key + IP scoped; point progress is accepted only when the
-/// evidence-critical configuration fingerprint still matches.
+/// IED ownership is IEC technical identity + endpoint scoped and, when both sides know it,
+/// additionally bound to the Engineering live DeviceId. Point progress is accepted only when
+/// the evidence-critical configuration fingerprint still matches.
///
public static class IoTestPerIedProgressIdentity
{
@@ -21,6 +22,44 @@ public static string IedKey(IoTestIedPlan ied)
public static string IedKey(string? iedName, string? ipAddress)
=> $"{NormalizeIdentity(iedName)}|{NormalizeIp(ipAddress)}";
+ ///
+ /// Strong persisted-owner key for new snapshots. DeviceId is deliberately additive:
+ /// legacy snapshots did not persist it, so endpoint + IEC identity remains the migration
+ /// fallback only when either side does not yet know a DeviceId. Once both sides know it,
+ /// a mismatch is a hard fail-closed ownership boundary.
+ ///
+ public static string IedPersistenceAuthorityKey(IoTestIedPlan ied)
+ {
+ ArgumentNullException.ThrowIfNull(ied);
+ return IedPersistenceAuthorityKey(ied.LiveDeviceId, ied.IedName, ied.IpAddress);
+ }
+
+ public static string IedPersistenceAuthorityKey(
+ string? deviceId,
+ string? iedName,
+ string? ipAddress)
+ => $"{NormalizeIdentity(deviceId)}|{NormalizeIdentity(iedName)}|{NormalizeIp(ipAddress)}";
+
+ public static bool PersistedIedOwnershipMatches(IoTestIedPlan currentIed, JsonElement savedIed)
+ {
+ ArgumentNullException.ThrowIfNull(currentIed);
+
+ var savedName = OptionalString(savedIed, "iedName", string.Empty);
+ var savedIp = OptionalString(savedIed, "ipAddress", string.Empty);
+ if (!IedKey(currentIed).Equals(IedKey(savedName, savedIp), StringComparison.Ordinal))
+ return false;
+
+ var currentDeviceId = NormalizeIdentity(currentIed.LiveDeviceId);
+ var savedDeviceId = NormalizeIdentity(OptionalString(savedIed, "liveDeviceId", string.Empty));
+
+ // Backward compatibility is intentionally one-way: old snapshots without DeviceId
+ // may still restore through exact IEC identity + IP + point fingerprints. As soon as
+ // both snapshots/current Engineering context carry DeviceId, it becomes mandatory.
+ return currentDeviceId.Length == 0 ||
+ savedDeviceId.Length == 0 ||
+ currentDeviceId.Equals(savedDeviceId, StringComparison.Ordinal);
+ }
+
public static string PointConfigurationFingerprint(IoTestPointPlan point)
=> PointConfigurationFingerprintCore(point, includeSignalAddress: true);
diff --git a/Services/IoTesting/IoTestProjectPersistenceService.cs b/Services/IoTesting/IoTestProjectPersistenceService.cs
index 9bfd1e55f..7599f14e0 100644
--- a/Services/IoTesting/IoTestProjectPersistenceService.cs
+++ b/Services/IoTesting/IoTestProjectPersistenceService.cs
@@ -572,6 +572,9 @@ private void SaveFromTimer()
ReviewerComment = point.ReviewerComment
}).ToList())
{
+ // M5: persist the stable Engineering DeviceId when available. Older snapshots
+ // omit this field and continue through the exact IEC identity + endpoint fallback.
+ LiveDeviceId = ied.LiveDeviceId,
LatestComtradeFiles = ied.LatestComtradeFiles,
LatestComtradeRemotePath = ied.LatestComtradeRemotePath,
LatestComtradeCompleteness = ied.LatestComtradeCompleteness,
@@ -987,6 +990,7 @@ private sealed record IoTestIedData(
string Switchgear,
List TestPoints)
{
+ public string LiveDeviceId { get; init; } = string.Empty;
public string LatestComtradeFiles { get; init; } = string.Empty;
public string LatestComtradeRemotePath { get; init; } = string.Empty;
public string LatestComtradeCompleteness { get; init; } = string.Empty;
diff --git a/Services/IoTesting/IoTestWorkspaceBootstrapService.cs b/Services/IoTesting/IoTestWorkspaceBootstrapService.cs
index 72d02b943..25f7d3b55 100644
--- a/Services/IoTesting/IoTestWorkspaceBootstrapService.cs
+++ b/Services/IoTesting/IoTestWorkspaceBootstrapService.cs
@@ -61,21 +61,23 @@ public static async Task OpenSourcesAsync(
{
if (!string.IsNullOrWhiteSpace(restoreSnapshotPath) && File.Exists(restoreSnapshotPath))
{
+ // Isolate the canonical persisted snapshot BEFORE attempting selective restore.
+ // Otherwise a rejected/invalid partial restore could fall through to
+ // IoTestWorkspacePersistence.OpenSourcesAsync(), which is allowed to restore a
+ // matching snapshot wholesale. Engineering is the fresh plan authority here:
+ // the old snapshot is read-only evidence input, never a replacement project.
+ if (restoreSnapshotPath.Equals(snapshotPath, StringComparison.OrdinalIgnoreCase))
+ {
+ Directory.CreateDirectory(localDirectory);
+ File.Move(snapshotPath, backupPath, true);
+ movedSnapshot = true;
+ restoreSnapshotPath = backupPath;
+ }
+
try
{
ApplySnapshotProgress(importedProject, restoreSnapshotPath);
restored = true;
-
- // The snapshot at the canonical current path is temporarily moved so
- // persistence cannot replace the freshly imported IEC model wholesale.
- // A compatible SCL snapshot discovered under an older staging/project
- // identity is read-only input; the new current path is saved normally.
- if (restoreSnapshotPath.Equals(snapshotPath, StringComparison.OrdinalIgnoreCase))
- {
- Directory.CreateDirectory(localDirectory);
- File.Move(snapshotPath, backupPath, true);
- movedSnapshot = true;
- }
}
catch (Exception ex) when (ex is IOException or JsonException or InvalidDataException)
{
@@ -248,7 +250,8 @@ private static void ApplySnapshotProgress(IoTestProject project, string snapshot
var iedKey = IoTestPerIedProgressIdentity.IedKey(ied);
if (!currentIedIdentityCounts.TryGetValue(iedKey, out var currentIdentityCount) ||
currentIdentityCount != 1 ||
- !savedIedsByIdentity.TryGetValue(iedKey, out var savedIed))
+ !savedIedsByIdentity.TryGetValue(iedKey, out var savedIed) ||
+ !IoTestPerIedProgressIdentity.PersistedIedOwnershipMatches(ied, savedIed))
{
continue;
}
@@ -443,8 +446,11 @@ private static void RestoreMissingManualWorkspaceRows(
var savedIed = savedIeds.FirstOrDefault(candidate =>
OptionalString(candidate, "iedName", string.Empty).Equals(ied.IedName, StringComparison.OrdinalIgnoreCase) &&
OptionalString(candidate, "ipAddress", string.Empty).Equals(ied.IpAddress, StringComparison.OrdinalIgnoreCase));
- if (savedIed.ValueKind != JsonValueKind.Object)
+ if (savedIed.ValueKind != JsonValueKind.Object ||
+ !IoTestPerIedProgressIdentity.PersistedIedOwnershipMatches(ied, savedIed))
+ {
continue;
+ }
var existingIds = ied.TestPoints
.Select(point => point.TestPointId)
@@ -541,8 +547,11 @@ private static void RestoreIedLevelEvidence(IoTestProject project, IReadOnlyList
var saved = savedIeds.FirstOrDefault(candidate =>
OptionalString(candidate, "iedName", string.Empty).Equals(ied.IedName, StringComparison.OrdinalIgnoreCase) &&
OptionalString(candidate, "ipAddress", string.Empty).Equals(ied.IpAddress, StringComparison.OrdinalIgnoreCase));
- if (saved.ValueKind != JsonValueKind.Object)
+ if (saved.ValueKind != JsonValueKind.Object ||
+ !IoTestPerIedProgressIdentity.PersistedIedOwnershipMatches(ied, saved))
+ {
continue;
+ }
ied.LatestComtradeFiles = OptionalString(saved, "latestComtradeFiles", string.Empty);
ied.LatestComtradeRemotePath = OptionalString(saved, "latestComtradeRemotePath", string.Empty);
diff --git a/Services/NativeFatPdfReportService.cs b/Services/NativeFatPdfReportService.cs
new file mode 100644
index 000000000..7c7fbf768
--- /dev/null
+++ b/Services/NativeFatPdfReportService.cs
@@ -0,0 +1,386 @@
+using System.Text;
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Models.IoTesting;
+using ArIED61850Tester.Services.IoTesting;
+
+namespace ArIED61850Tester.Services;
+
+///
+/// Native FAT PDF export driven by the same immutable snapshot used by the integrated
+/// preview. It reuses ARSAS' existing embedded-font PDF serializer, but does not convert
+/// the native state into the legacy IoTest evidence runtime or start another acquisition.
+///
+public static class NativeFatPdfReportService
+{
+ private const double PageWidth = 842d;
+ private const double PageHeight = 595d;
+ private const double Margin = 30d;
+ private const double HeaderBottom = 500d;
+ private const double ContentTop = 484d;
+ private const double ContentBottom = 54d;
+ private const double ContentWidth = PageWidth - (Margin * 2d);
+
+ private static readonly IoFatReportColor Navy = IoFatReportColor.FromHex("0F172A");
+ private static readonly IoFatReportColor Blue = IoFatReportColor.FromHex("2563EB");
+ private static readonly IoFatReportColor Muted = IoFatReportColor.FromHex("64748B");
+ private static readonly IoFatReportColor Border = IoFatReportColor.FromHex("DDE7F3");
+ private static readonly IoFatReportColor SoftLine = IoFatReportColor.FromHex("EEF2F7");
+ private static readonly IoFatReportColor SoftBlue = IoFatReportColor.FromHex("EFF6FF");
+ private static readonly IoFatReportColor White = IoFatReportColor.FromHex("FFFFFF");
+ private static readonly IoFatReportColor Pass = IoFatReportColor.FromHex("15803D");
+ private static readonly IoFatReportColor Review = IoFatReportColor.FromHex("B45309");
+ private static readonly IoFatReportColor Fail = IoFatReportColor.FromHex("B91C1C");
+ private static readonly IoFatReportColor SoftPass = IoFatReportColor.FromHex("F0FDF4");
+ private static readonly IoFatReportColor SoftReview = IoFatReportColor.FromHex("FFFBEB");
+ private static readonly IoFatReportColor SoftFail = IoFatReportColor.FromHex("FEF2F2");
+
+ public static byte[] Generate(NativeFatReportSnapshot snapshot, bool includeHistorical = false)
+ {
+ ArgumentNullException.ThrowIfNull(snapshot);
+ var layout = BuildLayout(snapshot, includeHistorical);
+
+ // IoFatNativePdfWriter only reads this project object for PDF document metadata.
+ // The report command stream itself comes entirely from NativeFatReportSnapshot.
+ var metadataProject = new IoTestProject
+ {
+ ProjectId = string.IsNullOrWhiteSpace(snapshot.DeviceId) ? snapshot.IedName : snapshot.DeviceId,
+ SchemaVersion = "ARSAS-NATIVE-FAT-1",
+ ProjectName = $"ARSAS Native FAT - {snapshot.IedName}"
+ };
+ return IoFatNativePdfWriter.Build(layout, metadataProject);
+ }
+
+ public static void Save(
+ string fileName,
+ NativeFatReportSnapshot snapshot,
+ bool includeHistorical = false)
+ {
+ ArgumentException.ThrowIfNullOrWhiteSpace(fileName);
+ var bytes = Generate(snapshot, includeHistorical);
+ var fullPath = Path.GetFullPath(fileName);
+ Directory.CreateDirectory(Path.GetDirectoryName(fullPath)!);
+ var temporary = fullPath + ".tmp-" + Guid.NewGuid().ToString("N");
+ try
+ {
+ using (var stream = new FileStream(
+ temporary,
+ FileMode.CreateNew,
+ FileAccess.Write,
+ FileShare.None,
+ 16 * 1024,
+ FileOptions.WriteThrough))
+ {
+ stream.Write(bytes);
+ stream.Flush(flushToDisk: true);
+ }
+ File.Move(temporary, fullPath, overwrite: true);
+ }
+ finally
+ {
+ if (File.Exists(temporary))
+ File.Delete(temporary);
+ }
+ }
+
+ internal static IoFatReportLayoutPlan BuildLayout(
+ NativeFatReportSnapshot snapshot,
+ bool includeHistorical)
+ {
+ var rows = snapshot.Rows
+ .Where(row => includeHistorical || !row.IsHistorical)
+ .ToArray();
+ var pages = new List();
+ var page = NewPage(pages);
+ var cursorY = ContentTop;
+
+ DrawTableHeader(page, ref cursorY);
+ var rowNumber = 0;
+ foreach (var row in rows)
+ {
+ rowNumber++;
+ var cells = BuildCells(row, rowNumber);
+ var rowHeight = EstimateRowHeight(cells);
+ if (cursorY - rowHeight < ContentBottom)
+ {
+ page = NewPage(pages);
+ cursorY = ContentTop;
+ DrawTableHeader(page, ref cursorY);
+ }
+ DrawRow(page, cells, rowHeight, ref cursorY);
+ }
+
+ if (rows.Length == 0)
+ {
+ page.Rect(Margin, cursorY, ContentWidth, 38d, 5d, SoftReview, Border, 0.7d);
+ page.Text(Margin + 12d, cursorY - 23d, ContentWidth - 24d,
+ "No current native FAT signal is available for this export scope.",
+ IoFatReportFontKind.Regular, 8d, Review);
+ }
+
+ var totalPages = pages.Count;
+ for (var index = 0; index < pages.Count; index++)
+ DrawPageChrome(pages[index], snapshot, includeHistorical, index + 1, totalPages);
+
+ return new IoFatReportLayoutPlan(
+ string.IsNullOrWhiteSpace(snapshot.DeviceId) ? snapshot.IedName : snapshot.DeviceId,
+ snapshot.GeneratedUtc.ToLocalTime(),
+ Draft: false,
+ pages.Select((item, index) => new IoFatReportPagePlan(
+ index + 1,
+ PageWidth,
+ PageHeight,
+ item.Commands.ToArray()))
+ .ToArray());
+ }
+
+ private static PageBuilder NewPage(List pages)
+ {
+ var page = new PageBuilder();
+ pages.Add(page);
+ return page;
+ }
+
+ private static void DrawPageChrome(
+ PageBuilder page,
+ NativeFatReportSnapshot snapshot,
+ bool includeHistorical,
+ int pageNumber,
+ int totalPages)
+ {
+ var tone = ResolveTone(snapshot);
+ var toneColor = ToneColor(tone);
+ var toneBackground = ToneBackground(tone);
+
+ page.Line(Margin, HeaderBottom, PageWidth - Margin, HeaderBottom, Border, 0.8d);
+ page.Text(Margin, 562d, 440d, "ARSAS | IEC 61850 FAT", IoFatReportFontKind.Bold, 7.4d, Muted);
+ page.Text(Margin, 540d, 520d, "Native FAT Evidence Report", IoFatReportFontKind.Bold, 20.4d, Navy);
+ page.Text(Margin, 520d, 590d,
+ $"{Clean(snapshot.IedName)} | {Clean(snapshot.IpAddress)}:{snapshot.Port} | immutable capture snapshot",
+ IoFatReportFontKind.Regular, 7.7d, Muted);
+
+ const double cardWidth = 184d;
+ const double cardHeight = 62d;
+ var cardX = PageWidth - Margin - cardWidth;
+ const double cardTop = 568d;
+ page.Rect(cardX, cardTop, cardWidth, cardHeight, 6d, toneBackground, toneColor, 0.9d);
+ page.Text(cardX + 11d, cardTop - 15d, cardWidth - 22d, "CURRENT SCOPE", IoFatReportFontKind.Bold, 6.2d, Muted);
+ page.Text(cardX + 11d, cardTop - 34d, cardWidth - 22d, tone, IoFatReportFontKind.Bold, 14.2d, toneColor);
+ page.Text(cardX + 11d, cardTop - 50d, cardWidth - 22d,
+ $"P {snapshot.PassCount} | R {snapshot.ReviewCount} | F {snapshot.FailCount} | U {snapshot.UntestedCount}",
+ IoFatReportFontKind.Regular, 6.3d, Muted);
+
+ page.Line(Margin, 42d, PageWidth - Margin, 42d, Border, 0.6d);
+ var historyText = includeHistorical
+ ? $" | historical included: {snapshot.HistoricalCount}"
+ : snapshot.HistoricalCount > 0 ? $" | historical omitted: {snapshot.HistoricalCount}" : string.Empty;
+ page.Text(Margin, 24d, 650d,
+ $"Generated {snapshot.GeneratedUtc.ToLocalTime():yyyy-MM-dd HH:mm:ss zzz}{historyText} | DeviceId {Clean(snapshot.DeviceId)}",
+ IoFatReportFontKind.Regular, 6.1d, Muted);
+ page.Text(PageWidth - Margin - 80d, 24d, 80d,
+ $"Page {pageNumber} / {totalPages}", IoFatReportFontKind.Regular, 6.1d, Muted);
+ }
+
+ private static void DrawTableHeader(PageBuilder page, ref double cursorY)
+ {
+ var widths = ColumnWidths();
+ var headers = new[] { "#", "Signal / IEC identity", "Value 1 evidence", "Value 2 evidence", "Result" };
+ var x = Margin;
+ const double height = 23d;
+ for (var index = 0; index < headers.Length; index++)
+ {
+ page.Rect(x, cursorY, widths[index], height, 0d, SoftBlue, Border, 0.45d);
+ page.Text(x + 5d, cursorY - 15d, widths[index] - 10d,
+ headers[index], IoFatReportFontKind.Bold, 6.2d, Blue);
+ x += widths[index];
+ }
+ cursorY -= height;
+ }
+
+ private static ReportCell[] BuildCells(NativeFatReportRow row, int rowNumber)
+ {
+ var scope = row.IsHistorical ? "HISTORICAL" : "CURRENT";
+ var signal = $"{row.SignalName}\n{row.IecReference} [{row.FunctionalConstraint}] | {row.DataType}\n{scope}";
+ var v1 = BuildEvidenceCell(
+ row.Value1Text,
+ row.Value1Quality,
+ row.Value1DeviceTimestamp,
+ row.Value1CapturedText,
+ row.Value1SourceMode);
+ var v2 = BuildEvidenceCell(
+ row.Value2Text,
+ row.Value2Quality,
+ row.Value2DeviceTimestamp,
+ row.Value2CapturedText,
+ row.Value2SourceMode);
+ var resultColor = ResultColor(row.Result, row.IsHistorical);
+ var result = $"{row.Result}\nhistory {row.HistoryText}";
+
+ return
+ [
+ new ReportCell(rowNumber.ToString(), 6.4d, IoFatReportFontKind.Regular, Muted),
+ new ReportCell(signal, 6.25d, IoFatReportFontKind.Regular, Navy),
+ new ReportCell(v1, 6.0d, IoFatReportFontKind.Regular, Navy),
+ new ReportCell(v2, 6.0d, IoFatReportFontKind.Regular, Navy),
+ new ReportCell(result, 6.4d, IoFatReportFontKind.Bold, resultColor)
+ ];
+ }
+
+ private static string BuildEvidenceCell(
+ string value,
+ string quality,
+ string iedTimestamp,
+ string captured,
+ string source)
+ {
+ var cleanValue = Clean(value);
+ if (cleanValue is "-" or "—")
+ return "Not captured";
+
+ return $"{cleanValue}\nq={Clean(quality)} | {Clean(source)}\nIED {Clean(iedTimestamp)}\nARSAS {Clean(captured)}";
+ }
+
+ private static double EstimateRowHeight(IReadOnlyList cells)
+ {
+ var widths = ColumnWidths();
+ var maxLines = 1;
+ for (var index = 0; index < cells.Count; index++)
+ maxLines = Math.Max(maxLines, WrapText(cells[index].Text, widths[index] - 10d, cells[index].FontSize).Count);
+ return Math.Max(38d, 9d + (maxLines * 8.0d));
+ }
+
+ private static void DrawRow(
+ PageBuilder page,
+ IReadOnlyList cells,
+ double rowHeight,
+ ref double cursorY)
+ {
+ var widths = ColumnWidths();
+ var x = Margin;
+ for (var index = 0; index < cells.Count; index++)
+ {
+ var cell = cells[index];
+ page.Rect(x, cursorY, widths[index], rowHeight, 0d, White, SoftLine, 0.35d);
+ var lines = WrapText(cell.Text, widths[index] - 10d, cell.FontSize);
+ var y = cursorY - 10d;
+ foreach (var line in lines)
+ {
+ page.Text(x + 5d, y, widths[index] - 10d,
+ line, cell.Font, cell.FontSize, cell.Color);
+ y -= 8.0d;
+ }
+ x += widths[index];
+ }
+ cursorY -= rowHeight;
+ }
+
+ private static double[] ColumnWidths()
+ => [28d, 260d, 180d, 180d, 134d];
+
+ private static IReadOnlyList WrapText(string? value, double width, double fontSize)
+ {
+ var input = (value ?? string.Empty)
+ .Replace("\r\n", "\n", StringComparison.Ordinal)
+ .Replace('\r', '\n');
+ if (string.IsNullOrWhiteSpace(input))
+ return ["-"];
+
+ var charsPerLine = Math.Max(7, (int)Math.Floor(width / Math.Max(2.4d, fontSize * 0.49d)));
+ var lines = new List();
+ foreach (var paragraphValue in input.Split('\n'))
+ {
+ var paragraph = IoFatReportLayoutEngine.SanitizeReportText(paragraphValue);
+ if (paragraph.Length == 0)
+ {
+ lines.Add("-");
+ continue;
+ }
+
+ var words = paragraph.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+ var current = new StringBuilder();
+ foreach (var originalWord in words)
+ {
+ var word = originalWord;
+ while (word.Length > charsPerLine)
+ {
+ if (current.Length > 0)
+ {
+ lines.Add(current.ToString());
+ current.Clear();
+ }
+ lines.Add(word[..charsPerLine]);
+ word = word[charsPerLine..];
+ }
+ if (word.Length == 0)
+ continue;
+ if (current.Length == 0)
+ current.Append(word);
+ else if (current.Length + 1 + word.Length <= charsPerLine)
+ current.Append(' ').Append(word);
+ else
+ {
+ lines.Add(current.ToString());
+ current.Clear().Append(word);
+ }
+ }
+ if (current.Length > 0)
+ lines.Add(current.ToString());
+ }
+ return lines.Count == 0 ? ["-"] : lines;
+ }
+
+ private static string ResolveTone(NativeFatReportSnapshot snapshot)
+ {
+ if (snapshot.CurrentCount == 0)
+ return "NO CURRENT SIGNALS";
+ if (snapshot.FailCount > 0)
+ return "FAIL";
+ if (snapshot.ReviewCount > 0 || snapshot.UntestedCount > 0)
+ return "REVIEW";
+ return snapshot.PassCount == snapshot.CurrentCount ? "PASS" : "REVIEW";
+ }
+
+ private static IoFatReportColor ToneColor(string tone)
+ => tone == "PASS" ? Pass : tone == "FAIL" ? Fail : Review;
+
+ private static IoFatReportColor ToneBackground(string tone)
+ => tone == "PASS" ? SoftPass : tone == "FAIL" ? SoftFail : SoftReview;
+
+ private static IoFatReportColor ResultColor(string result, bool historical)
+ {
+ if (historical)
+ return Muted;
+ return result switch
+ {
+ NativeFatResult.Pass => Pass,
+ NativeFatResult.Fail => Fail,
+ NativeFatResult.Review => Review,
+ _ => Muted
+ };
+ }
+
+ private static string Clean(string? value)
+ {
+ var clean = IoFatReportLayoutEngine.SanitizeReportText(value);
+ return string.IsNullOrWhiteSpace(clean) ? "-" : clean;
+ }
+
+ private sealed record ReportCell(
+ string Text,
+ double FontSize,
+ IoFatReportFontKind Font,
+ IoFatReportColor Color);
+
+ private sealed class PageBuilder
+ {
+ public List Commands { get; } = new();
+
+ public void Text(double x, double y, double width, string text, IoFatReportFontKind font, double size, IoFatReportColor color)
+ => Commands.Add(new IoFatReportTextCommand(x, y, width, Clean(text), font, size, color));
+
+ public void Line(double x1, double y1, double x2, double y2, IoFatReportColor stroke, double thickness)
+ => Commands.Add(new IoFatReportLineCommand(x1, y1, x2, y2, stroke, thickness));
+
+ public void Rect(double x, double topY, double width, double height, double radius, IoFatReportColor fill, IoFatReportColor stroke, double thickness)
+ => Commands.Add(new IoFatReportRectCommand(x, topY, width, height, radius, fill, stroke, thickness));
+ }
+}
diff --git a/Services/NativeFatReportSnapshotBuilder.cs b/Services/NativeFatReportSnapshotBuilder.cs
new file mode 100644
index 000000000..38523be5c
--- /dev/null
+++ b/Services/NativeFatReportSnapshotBuilder.cs
@@ -0,0 +1,63 @@
+using ArIED61850Tester.Models;
+
+namespace ArIED61850Tester.Services;
+
+///
+/// Converts the persisted native FAT state into an immutable report snapshot. This is a
+/// presentation/evidence boundary only; it never starts acquisition, changes command
+/// state, or mutates the persisted FAT result.
+///
+public static class NativeFatReportSnapshotBuilder
+{
+ public static NativeFatReportSnapshot Build(
+ Iec61850MonitorDevice device,
+ NativeFatDeviceState state,
+ DateTimeOffset? generatedUtc = null)
+ {
+ ArgumentNullException.ThrowIfNull(device);
+ ArgumentNullException.ThrowIfNull(state);
+
+ var rows = (state.Signals ?? new List())
+ .Select(BuildRow)
+ .OrderBy(row => row.IsHistorical)
+ .ThenBy(row => row.SignalName, StringComparer.OrdinalIgnoreCase)
+ .ThenBy(row => row.IecReference, StringComparer.OrdinalIgnoreCase)
+ .ToArray();
+
+ return new NativeFatReportSnapshot(
+ device.DeviceId,
+ device.Name,
+ device.IpAddress,
+ device.Port,
+ generatedUtc ?? DateTimeOffset.UtcNow,
+ rows);
+ }
+
+ private static NativeFatReportRow BuildRow(NativeFatSignalState state)
+ {
+ var value1 = state.Value1;
+ var value2 = state.Value2;
+ var result = string.IsNullOrWhiteSpace(state.Result)
+ ? NativeFatResult.Untested
+ : state.Result.Trim().ToUpperInvariant();
+
+ return new NativeFatReportRow(
+ SignalName: state.SignalName,
+ IecReference: state.IecReference,
+ FunctionalConstraint: state.FunctionalConstraint,
+ DataType: state.DataType,
+ IsHistorical: state.IsHistorical,
+ Result: result,
+ HistoryCount: state.History?.Count ?? 0,
+ Value1Text: value1?.Value ?? "—",
+ Value1Quality: value1?.Quality ?? "—",
+ Value1DeviceTimestamp: value1?.DeviceTimestamp ?? "—",
+ Value1SourceMode: value1?.SourceMode ?? "—",
+ Value1CapturedUtc: value1?.CapturedUtc,
+ Value2Text: value2?.Value ?? "—",
+ Value2Quality: value2?.Quality ?? "—",
+ Value2DeviceTimestamp: value2?.DeviceTimestamp ?? "—",
+ Value2SourceMode: value2?.SourceMode ?? "—",
+ Value2CapturedUtc: value2?.CapturedUtc);
+ }
+}
diff --git a/Services/NativeFatStateStore.cs b/Services/NativeFatStateStore.cs
new file mode 100644
index 000000000..be77a0def
--- /dev/null
+++ b/Services/NativeFatStateStore.cs
@@ -0,0 +1,407 @@
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using ArIED61850Tester.Models;
+
+namespace ArIED61850Tester.Services;
+
+///
+/// Non-destructive, per-IED FAT persistence. The store never deletes unmatched signal
+/// records during reconciliation; removed/changed engineering therefore remains visible
+/// as historical commissioning evidence instead of becoming a load error or data loss.
+///
+public sealed class NativeFatStateStore
+{
+ private static readonly JsonSerializerOptions JsonOptions = new()
+ {
+ WriteIndented = true,
+ PropertyNameCaseInsensitive = true
+ };
+
+ private readonly string _rootDirectory;
+
+ public NativeFatStateStore(string? rootDirectory = null)
+ {
+ _rootDirectory = string.IsNullOrWhiteSpace(rootDirectory)
+ ? Path.Combine(
+ Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+ "ARSAS",
+ "FAT",
+ "NativeState")
+ : rootDirectory;
+ }
+
+ public string RootDirectory => _rootDirectory;
+
+ public async Task LoadAndReconcileAsync(
+ Iec61850MonitorDevice device,
+ CancellationToken cancellationToken = default)
+ {
+ ArgumentNullException.ThrowIfNull(device);
+ var state = await LoadAsync(device, cancellationToken).ConfigureAwait(false);
+ Reconcile(state, device);
+ return state;
+ }
+
+ public async Task LoadAsync(
+ Iec61850MonitorDevice device,
+ CancellationToken cancellationToken = default)
+ {
+ ArgumentNullException.ThrowIfNull(device);
+ Directory.CreateDirectory(_rootDirectory);
+
+ // New native FAT files include a short deterministic hash of stable DeviceId.
+ // Two relays may legitimately share the same display IEDName, so a name-only
+ // filename is not a safe multi-IED persistence identity.
+ var preferredPath = GetPreferredPath(device.Name, device.DeviceId);
+ var candidate = await TryReadAsync(preferredPath, cancellationToken).ConfigureAwait(false);
+ if (IsForDevice(candidate, device))
+ {
+ candidate!.StoragePath = preferredPath;
+ Normalize(candidate, device);
+ return candidate;
+ }
+ var preferredPathOccupied = File.Exists(preferredPath);
+
+ // P2 preview builds used name-only filenames. Read them once for compatibility,
+ // but migrate the next save to the collision-safe preferred path. The old file is
+ // intentionally left untouched as recoverable commissioning evidence.
+ var legacyPath = GetLegacyPath(device.Name);
+ if (!legacyPath.Equals(preferredPath, StringComparison.OrdinalIgnoreCase))
+ {
+ var legacy = await TryReadAsync(legacyPath, cancellationToken).ConfigureAwait(false);
+ if (IsForDevice(legacy, device))
+ {
+ legacy!.StoragePath = preferredPathOccupied
+ ? GetNonDestructiveRecoveryPath(preferredPath)
+ : preferredPath;
+ Normalize(legacy, device);
+ return legacy;
+ }
+ }
+
+ // IED display names can change. Resolve by stable DeviceId before creating a new
+ // state so a harmless rename cannot strand the operator's previous FAT evidence.
+ foreach (var path in Directory.EnumerateFiles(_rootDirectory, "*.json", SearchOption.TopDirectoryOnly))
+ {
+ cancellationToken.ThrowIfCancellationRequested();
+ if (path.Equals(preferredPath, StringComparison.OrdinalIgnoreCase) ||
+ path.Equals(legacyPath, StringComparison.OrdinalIgnoreCase))
+ {
+ continue;
+ }
+
+ var probed = await TryReadAsync(path, cancellationToken).ConfigureAwait(false);
+ if (!IsForDevice(probed, device))
+ continue;
+
+ // Preserve an already collision-safe file across display-name changes rather
+ // than creating a duplicate file every time the user renames an IED card.
+ probed!.StoragePath = path;
+ Normalize(probed, device);
+ return probed;
+ }
+
+ // An occupied preferred path that is unreadable or belongs to a different device
+ // is evidence, not scratch space. Start a recovery state beside it; never overwrite
+ // the original simply because deserialization failed.
+ var storagePath = preferredPathOccupied
+ ? GetNonDestructiveRecoveryPath(preferredPath)
+ : preferredPath;
+ return new NativeFatDeviceState
+ {
+ DeviceId = device.DeviceId,
+ IedName = device.Name,
+ CreatedUtc = DateTimeOffset.UtcNow,
+ UpdatedUtc = DateTimeOffset.UtcNow,
+ StoragePath = storagePath
+ };
+ }
+
+ public async Task SaveAsync(NativeFatDeviceState state, CancellationToken cancellationToken = default)
+ {
+ ArgumentNullException.ThrowIfNull(state);
+ Directory.CreateDirectory(_rootDirectory);
+ state.UpdatedUtc = DateTimeOffset.UtcNow;
+ state.SchemaVersion = Math.Max(1, state.SchemaVersion);
+
+ var path = string.IsNullOrWhiteSpace(state.StoragePath)
+ ? GetPreferredPath(state.IedName, state.DeviceId)
+ : state.StoragePath;
+ var tempPath = path + ".tmp-" + Guid.NewGuid().ToString("N");
+
+ try
+ {
+ await using (var stream = new FileStream(
+ tempPath,
+ FileMode.CreateNew,
+ FileAccess.Write,
+ FileShare.None,
+ 64 * 1024,
+ useAsync: true))
+ {
+ await JsonSerializer.SerializeAsync(stream, state, JsonOptions, cancellationToken)
+ .ConfigureAwait(false);
+ await stream.FlushAsync(cancellationToken).ConfigureAwait(false);
+ }
+
+ File.Move(tempPath, path, overwrite: true);
+ state.StoragePath = path;
+ }
+ finally
+ {
+ try
+ {
+ if (File.Exists(tempPath))
+ File.Delete(tempPath);
+ }
+ catch
+ {
+ // A stale temp file is harmless; never turn cleanup into evidence loss.
+ }
+ }
+ }
+
+ ///
+ /// Reconcile saved FAT evidence against the same signal scope owned by IED Explorer.
+ /// Selected Explorer signals win; if no explicit selection exists, already-materialized
+ /// live points define the active scope; only an entirely fresh/offline device falls back
+ /// to all publishable process signals.
+ ///
+ public static void Reconcile(NativeFatDeviceState state, Iec61850MonitorDevice device)
+ {
+ ArgumentNullException.ThrowIfNull(state);
+ ArgumentNullException.ThrowIfNull(device);
+
+ state.DeviceId = device.DeviceId;
+ state.IedName = device.Name;
+ state.Signals ??= new List();
+
+ var now = DateTimeOffset.UtcNow;
+ var byKey = state.Signals
+ .Where(item => !string.IsNullOrWhiteSpace(item.Key))
+ .GroupBy(item => item.Key, StringComparer.OrdinalIgnoreCase)
+ .ToDictionary(group => group.Key, group => group.First(), StringComparer.OrdinalIgnoreCase);
+ var currentKeys = new HashSet(StringComparer.OrdinalIgnoreCase);
+
+ foreach (var signal in GetCurrentExplorerSignals(device))
+ {
+ var key = NativeFatIdentity.BuildKey(signal);
+ if (string.IsNullOrWhiteSpace(key))
+ continue;
+
+ currentKeys.Add(key);
+ if (!byKey.TryGetValue(key, out var saved))
+ {
+ saved = new NativeFatSignalState
+ {
+ Key = key,
+ SignalName = signal.Name,
+ IecReference = signal.ObjectReference,
+ FunctionalConstraint = signal.FunctionalConstraint,
+ DataType = signal.DataType,
+ FirstSeenUtc = now,
+ LastSeenUtc = now,
+ Result = NativeFatResult.Untested,
+ IsHistorical = false
+ };
+ state.Signals.Add(saved);
+ byKey[key] = saved;
+ }
+ else
+ {
+ // Current engineering metadata is refreshed while captures/history are
+ // untouched. A display-name change is therefore a rename, not a new test.
+ saved.SignalName = signal.Name;
+ saved.IecReference = signal.ObjectReference;
+ saved.FunctionalConstraint = signal.FunctionalConstraint;
+ saved.DataType = signal.DataType;
+ saved.LastSeenUtc = now;
+ saved.IsHistorical = false;
+ saved.History ??= new List();
+ if (string.IsNullOrWhiteSpace(saved.Result))
+ saved.Result = NativeFatResult.Untested;
+ }
+ }
+
+ // Never delete. When a signal leaves the current Explorer scope or SCL, preserve it
+ // as historical evidence. Re-adding the same IEC identity automatically restores it.
+ foreach (var saved in state.Signals)
+ {
+ if (!currentKeys.Contains(saved.Key))
+ saved.IsHistorical = true;
+ }
+
+ state.UpdatedUtc = now;
+ }
+
+ public static IReadOnlyList BuildRows(
+ NativeFatDeviceState state,
+ Iec61850MonitorDevice device)
+ {
+ ArgumentNullException.ThrowIfNull(state);
+ ArgumentNullException.ThrowIfNull(device);
+
+ var signals = GetCurrentExplorerSignals(device)
+ .GroupBy(NativeFatIdentity.BuildKey, StringComparer.OrdinalIgnoreCase)
+ .ToDictionary(group => group.Key, group => group.First(), StringComparer.OrdinalIgnoreCase);
+ var points = device.Points
+ .GroupBy(NativeFatIdentity.BuildKey, StringComparer.OrdinalIgnoreCase)
+ .ToDictionary(group => group.Key, group => group.First(), StringComparer.OrdinalIgnoreCase);
+
+ return state.Signals
+ .Select(saved => new NativeFatSignalRow(
+ saved,
+ signals.TryGetValue(saved.Key, out var signal) ? signal : null,
+ points.TryGetValue(saved.Key, out var point) ? point : FindPointByReference(device, saved)))
+ .OrderBy(row => row.IsHistorical)
+ .ThenBy(row => row.SignalName, StringComparer.OrdinalIgnoreCase)
+ .ThenBy(row => row.IecReference, StringComparer.OrdinalIgnoreCase)
+ .ToArray();
+ }
+
+ public static IReadOnlyList GetCurrentExplorerSignals(Iec61850MonitorDevice device)
+ {
+ ArgumentNullException.ThrowIfNull(device);
+
+ var publishable = device.Signals
+ .Where(signal => signal.CanPublishAsSignal)
+ .ToArray();
+ if (publishable.Length == 0)
+ return Array.Empty();
+
+ var selected = publishable.Where(signal => signal.IsSelected).ToArray();
+ if (selected.Length > 0)
+ return selected;
+
+ if (device.Points.Count > 0)
+ {
+ var activeKeys = device.Points
+ .Select(NativeFatIdentity.BuildKey)
+ .Where(key => !string.IsNullOrWhiteSpace(key))
+ .ToHashSet(StringComparer.OrdinalIgnoreCase);
+ var materialized = publishable
+ .Where(signal => activeKeys.Contains(NativeFatIdentity.BuildKey(signal)))
+ .ToArray();
+ if (materialized.Length > 0)
+ return materialized;
+ }
+
+ return publishable;
+ }
+
+ private static Iec61850MonitorPoint? FindPointByReference(
+ Iec61850MonitorDevice device,
+ NativeFatSignalState saved)
+ {
+ var reference = NativeFatIdentity.NormalizeReference(saved.IecReference);
+ if (string.IsNullOrWhiteSpace(reference))
+ return null;
+
+ return device.Points.FirstOrDefault(point =>
+ NativeFatIdentity.NormalizeReference(point.IecReference)
+ .Equals(reference, StringComparison.OrdinalIgnoreCase));
+ }
+
+ private async Task TryReadAsync(string path, CancellationToken cancellationToken)
+ {
+ if (!File.Exists(path))
+ return null;
+
+ try
+ {
+ await using var stream = new FileStream(
+ path,
+ FileMode.Open,
+ FileAccess.Read,
+ FileShare.Read,
+ 64 * 1024,
+ useAsync: true);
+ return await JsonSerializer.DeserializeAsync(stream, JsonOptions, cancellationToken)
+ .ConfigureAwait(false);
+ }
+ catch (OperationCanceledException)
+ {
+ throw;
+ }
+ catch
+ {
+ // Tolerant by design: a damaged old file must not block engineering. Leave
+ // the original file untouched so it can still be recovered manually.
+ return null;
+ }
+ }
+
+ private static bool IsForDevice(NativeFatDeviceState? state, Iec61850MonitorDevice device)
+ {
+ if (state == null)
+ return false;
+ if (!string.IsNullOrWhiteSpace(state.DeviceId) &&
+ state.DeviceId.Equals(device.DeviceId, StringComparison.OrdinalIgnoreCase))
+ return true;
+
+ return string.IsNullOrWhiteSpace(state.DeviceId) &&
+ state.IedName.Equals(device.Name, StringComparison.OrdinalIgnoreCase);
+ }
+
+ private static void Normalize(NativeFatDeviceState state, Iec61850MonitorDevice device)
+ {
+ state.SchemaVersion = Math.Max(1, state.SchemaVersion);
+ state.DeviceId = device.DeviceId;
+ state.IedName = device.Name;
+ state.Signals ??= new List();
+ foreach (var signal in state.Signals)
+ {
+ signal.History ??= new List();
+ if (string.IsNullOrWhiteSpace(signal.Key))
+ signal.Key = NativeFatIdentity.BuildKey(signal.IecReference, signal.FunctionalConstraint);
+ if (string.IsNullOrWhiteSpace(signal.Result))
+ signal.Result = NativeFatResult.Untested;
+ }
+ }
+
+ private string GetPreferredPath(string? iedName, string? deviceId)
+ {
+ var stem = SanitizeFileStem(iedName);
+ var deviceHash = StableDeviceHash(deviceId);
+ var fileStem = string.IsNullOrWhiteSpace(deviceHash) ? stem : $"{stem}__{deviceHash}";
+ return Path.Combine(_rootDirectory, fileStem + ".json");
+ }
+
+ private string GetLegacyPath(string? iedName)
+ => Path.Combine(_rootDirectory, SanitizeFileStem(iedName) + ".json");
+
+ private static string GetNonDestructiveRecoveryPath(string preferredPath)
+ {
+ var directory = Path.GetDirectoryName(preferredPath) ?? string.Empty;
+ var stem = Path.GetFileNameWithoutExtension(preferredPath);
+ var extension = Path.GetExtension(preferredPath);
+ for (var index = 1; index <= 999; index++)
+ {
+ var candidate = Path.Combine(directory, $"{stem}__RECOVERY_{index:000}{extension}");
+ if (!File.Exists(candidate))
+ return candidate;
+ }
+
+ return Path.Combine(directory, $"{stem}__RECOVERY_{Guid.NewGuid():N}{extension}");
+ }
+
+ private static string StableDeviceHash(string? deviceId)
+ {
+ if (string.IsNullOrWhiteSpace(deviceId))
+ return string.Empty;
+
+ var bytes = SHA256.HashData(Encoding.UTF8.GetBytes(deviceId.Trim()));
+ return Convert.ToHexString(bytes.AsSpan(0, 6));
+ }
+
+ private static string SanitizeFileStem(string? value)
+ {
+ var source = string.IsNullOrWhiteSpace(value) ? "IED" : value.Trim();
+ var invalid = Path.GetInvalidFileNameChars().ToHashSet();
+ var result = new string(source.Select(character => invalid.Contains(character) ? '_' : character).ToArray())
+ .Trim()
+ .Trim('.');
+ return string.IsNullOrWhiteSpace(result) ? "IED" : result;
+ }
+}
diff --git a/docs/FAT_ENGINEERING_WORKSTATION_CONTRACT.md b/docs/FAT_ENGINEERING_WORKSTATION_CONTRACT.md
new file mode 100644
index 000000000..0963aba70
--- /dev/null
+++ b/docs/FAT_ENGINEERING_WORKSTATION_CONTRACT.md
@@ -0,0 +1,112 @@
+# ARSAS FAT Engineering Workstation Contract
+
+This document is the architectural freeze for the Engineering-integrated FAT workflow. Changes that violate these invariants must not be merged, even if a visual patch appears to fix one field symptom.
+
+## Ownership
+
+- `MainWindow` owns the persistent Engineering workstation shell, navigation, global IED Explorer, and shared Command Dock.
+- Engineering owns IEC 61850 device identity, `SelectedDevice`, parsed `SclIedWorkspace`, static DataSet selection, live signal definitions, live points, MMS/report acquisition, and connection lifecycle.
+- The production FAT controller owns FAT preflight, session lifecycle, capture semantics, V1/V2 evidence, completion/result semantics, and FAT persistence.
+- FAT presentation must not own a second IEC 61850 parser, discovery session, MMS connection, live polling loop, or command runtime.
+- Report presentation must reuse the production FAT report definition; preview and PDF/print must not diverge into separate report models.
+
+## Primary user flow
+
+`Open SCL -> Connect/monitor IED -> select IED in persistent Explorer -> FAT`
+
+The first visible FAT frame must be the production FAT workspace for the selected Engineering IED. The primary flow must not require `Open SCL for FAT`, a launcher card, a second SCL parse, or a separate operator-visible FAT window.
+
+## Navigation invariant
+
+Engineering navigation has exactly seven destinations in this order:
+
+1. IEC 61850 Explorer
+2. Live Monitor
+3. Event Log
+4. Alarm
+5. GOOSE
+6. Diagnostics
+7. FAT
+
+There must be one canonical navigation owner. Do not reintroduce a second `ModuleInitializer` / `ApplicationIdle` parity layer that fights the canonical navigation state.
+
+M1 locks FAT as a literal seventh XAML sibling using the same `SegmentedNavButton` contract. Every responsive/navigation presentation layer must consume the same seven destinations: MainWindow index range is `0..6`, selection geometry divides the available navigation width into seven equal slots, and ballistic navigation styling includes `NavNativeFatButton`. Regression tests must fail if any of these layers silently falls back to six-slot behavior.
+
+## Multi-IED context invariant
+
+When FAT is idle, the viewed FAT IED follows Engineering `SelectedDevice`.
+
+When a FAT session starts or continues, the capture target is latched to that session IED. Changing the Explorer selection may change the viewed IED but must never redirect an active capture/evidence transaction to another IED.
+
+Persisted FAT state is reconciled by stable device/IEC identity. Background reconciliation is read/reconcile-only and must not manufacture new evidence.
+
+M3 is CODE VERIFIED and CI VERIFIED around this split: selected context remains an operator view/control projection, while evidence actions resolve the owning active IED session. Regression coverage exercises concurrent IED sessions while the selected context changes, and requires independent evidence journals/device routing. FIELD VERIFIED remains intentionally open until physical-IED acceptance.
+
+## Persistence authority invariant
+
+A persisted FAT result belongs to an IED only after its IEC technical identity and endpoint match. New M5 snapshots also persist the Engineering `LiveDeviceId`; when both the current Engineering IED and the saved snapshot know a DeviceId, a DeviceId mismatch is a hard fail-closed boundary.
+
+Legacy snapshots without DeviceId may migrate only through the exact IEC identity + endpoint path and the existing evidence-critical point configuration fingerprint. A persistence candidate may contribute prior progress/evidence to the freshly projected Engineering plan, but it must never replace that plan wholesale.
+
+Persistence reconciliation is not an evidence-producing operation. It may adopt already-persisted V1/V2/transition/result state into the matching current IED, but it must not append or manufacture evidence journal records. Production evidence creation remains owned by explicit FAT session/capture operations.
+
+The Engineering bootstrap must reconcile the isolated snapshot before creating its production FAT session controller. This ordering is intentional: reconciliation has no active evidence writer to call, then the normal production session/persistence controller is attached after the current Engineering plan has been safely reconciled.
+
+## Static DataSet authority invariant
+
+Automatic Engineering FAT uses the authoritative static DataSet projection from the already parsed `SclIedWorkspace`.
+
+Synthesized `scl-manual-*` aliases must not be allowed to create duplicate enabled ownership of the same primary live leaf in automatic static mode. The strict duplicate-live-reference preflight guard remains enabled; invalid duplicate scope is cleaned up rather than weakening the guard.
+
+Manual-only projects keep their manual-row behavior.
+
+## FAT presentation invariant
+
+The final Engineering FAT center must reuse the exact production FAT grid presentation rather than an approximation or a second native FAT grid implementation.
+
+Target reusable structure:
+
+- `FatWorkspaceView`: canonical production grid/workflow presentation.
+- `FatReportPreviewView`: canonical production A4 preview presentation.
+- `IoListTestingWindow`: legacy standalone shell that may host the reusable views for compatibility, but must not be the presentation/lifecycle owner of the Engineering FAT tab.
+
+The Engineering FAT tab must own a permanent FAT visual surface. Selecting FAT should only switch workstation content; it must not require `Window.Show -> Loaded -> detach/reparent`.
+
+## Report preview invariant
+
+Default center = production FAT grid.
+
+`Print/Report Preview` switches the same FAT center to the canonical paged A4 preview. The persistent IED Explorer and shared Command Dock remain visible. Returning from preview restores the same grid instance/state, including selection, scroll position, V1/V2 state, and active session context.
+
+## Protected production behavior
+
+Refactoring presentation must not change:
+
+- Select/SBO/Operate sequencing or control safety behavior.
+- `ctlModel`, interlock/synchrocheck/Test, CommandTermination semantics.
+- RCB runtime behavior.
+- GOOSE capture.
+- MMS/report/live-monitor acquisition semantics.
+- Production FAT preflight, auto-capture, evidence, completion/result, and persistence semantics.
+
+## Delivery gates
+
+A milestone is not called fixed until it has three statuses:
+
+- CODE VERIFIED
+- CI VERIFIED
+- FIELD VERIFIED
+
+Once a field gate is accepted, later milestones should not change that layer unless a regression test demonstrates a real dependency.
+
+## Current migration order
+
+1. M0 Architecture freeze and regression locks.
+2. M1 Canonical seven-destination shell/navigation.
+3. M2 Permanent FAT surface; remove primary launcher/black transition.
+4. M3 Selected-IED view synchronization.
+5. M4 Production controller adapter and latched capture context.
+6. M5 Evidence/persistence reconciliation.
+7. M6 Canonical in-place A4 report preview.
+8. M7 Remove donor-window/parity/experimental duplicate presentation code.
+9. M8 Physical-IED acceptance.
diff --git a/docs/FAT_M2_PERMANENT_HOST_VERIFICATION.md b/docs/FAT_M2_PERMANENT_HOST_VERIFICATION.md
new file mode 100644
index 000000000..9cd780163
--- /dev/null
+++ b/docs/FAT_M2_PERMANENT_HOST_VERIFICATION.md
@@ -0,0 +1,18 @@
+# FAT M2 — Permanent Production Host Verification
+
+M2 removes the FAT launcher as the primary Engineering experience and keeps the proven production FAT surface as the single presentation/engine authority.
+
+## Code contract
+
+- `MainWindow` owns the canonical FAT tab and permanent host slot.
+- Engineering static DataSet authority may prewarm FAT before the operator navigates to FAT.
+- Prewarm does not change `MainTabs.SelectedIndex`, call `MainWindow.Show()`, call `Activate()`, or steal focus.
+- `IoListTestingWindow` remains a temporary compatibility donor/controller owner only; it is prepared transparent, off-screen, non-activating, and absent from the taskbar before `Window.Show()`.
+- `MainWindow` remains visible while the embedded donor is initialized.
+- The embedded center is the exact production workspace detached from `IoListTestingWindow`; `InstallFatV2WorkspaceUx()` and the existing report-preview installer remain the presentation sources.
+- No `Open SCL for FAT` or `Open ARSAS Project` launcher is exposed in the canonical FAT tab.
+- Engineering continues to supply the already parsed SCL/static DataSet and shared live runtime; M2 does not introduce a second parser or acquisition authority.
+
+## Verification gate
+
+M2 is **code complete** only when the permanent-host regression tests compile and pass. It is **CI verified** only when the staging head passes the repository Build ARSAS, IO List Testing, and SV evidence validation workflows. Physical no-flicker behavior remains a field-verification item and must not be claimed from CI alone.
diff --git a/tests/ARSAS.Tests/AlarmAnnunciatorIntegrationRegressionTests.cs b/tests/ARSAS.Tests/AlarmAnnunciatorIntegrationRegressionTests.cs
index f7811ae2f..78926fd52 100644
--- a/tests/ARSAS.Tests/AlarmAnnunciatorIntegrationRegressionTests.cs
+++ b/tests/ARSAS.Tests/AlarmAnnunciatorIntegrationRegressionTests.cs
@@ -5,7 +5,7 @@ namespace ARSAS.Tests;
public sealed class AlarmAnnunciatorIntegrationRegressionTests
{
[Fact]
- public void Header_UsesSixWorkflowDestinations_WithoutDuplicateRuntimeStatusChips()
+ public void Header_UsesSevenWorkflowDestinations_WithoutDuplicateRuntimeStatusChips()
{
var document = XDocument.Parse(File.ReadAllText(FindRepoFile("MainWindow.xaml")));
XNamespace p = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
@@ -20,7 +20,7 @@ public void Header_UsesSixWorkflowDestinations_WithoutDuplicateRuntimeStatusChip
var navColumns = navGrid.Element(p + "Grid.ColumnDefinitions")?
.Elements(p + "ColumnDefinition").Count() ?? 0;
- Assert.Equal(6, navColumns);
+ Assert.Equal(7, navColumns);
Assert.Contains(navGrid.Descendants(p + "Button"), button =>
(string?)button.Attribute(x + "Name") == "NavAlarmButton" &&
(string?)button.Attribute("Tag") == "3" &&
@@ -31,6 +31,10 @@ public void Header_UsesSixWorkflowDestinations_WithoutDuplicateRuntimeStatusChip
Assert.Contains(navGrid.Descendants(p + "Button"), button =>
(string?)button.Attribute(x + "Name") == "NavDiagnosticsButton" &&
(string?)button.Attribute("Tag") == "5");
+ Assert.Contains(navGrid.Descendants(p + "Button"), button =>
+ (string?)button.Attribute(x + "Name") == "NavNativeFatButton" &&
+ (string?)button.Attribute("Tag") == "6" &&
+ (string?)button.Attribute("Content") == "FAT");
var headerSource = header.ToString(SaveOptions.DisableFormatting);
Assert.DoesNotContain("ConnectionInsightText", headerSource, StringComparison.Ordinal);
@@ -46,7 +50,7 @@ public void BallisticNavbar_AppliesTheSameCapsuleContractToAlarm()
{
var source = File.ReadAllText(FindRepoFile("SasOperationalUiPolicy.cs"));
- Assert.Contains("\"NavExplorerButton\", \"NavLiveButton\", \"NavEventsButton\", \"NavAlarmButton\", \"NavGooseButton\", \"NavDiagnosticsButton\"", source, StringComparison.Ordinal);
+ Assert.Contains("\"NavExplorerButton\", \"NavLiveButton\", \"NavEventsButton\", \"NavAlarmButton\", \"NavGooseButton\", \"NavDiagnosticsButton\", \"NavNativeFatButton\"", source, StringComparison.Ordinal);
Assert.Contains("UpdateNavigation(buttons, tabs.SelectedIndex", source, StringComparison.Ordinal);
Assert.Contains("buttons[index].Background = selected ? AccentGradient()", source, StringComparison.Ordinal);
}
@@ -122,17 +126,20 @@ public void Annunciator_FlashAndAckWorkAreBoundedToVisibleIedOrIedRail()
}
[Fact]
- public void NavigationAndDiagnosticsUseSixTabGeometry()
+ public void NavigationAndDiagnosticsUseSevenTabGeometry()
{
var navigation = File.ReadAllText(FindRepoFile("MainWindow.NavigationLayoutFix.cs"));
var main = File.ReadAllText(FindRepoFile("MainWindow.xaml.cs"));
+ var nativeFat = File.ReadAllText(FindRepoFile("MainWindow.NativeFatWorkspace.cs"));
- Assert.Contains("contentWidth / 6d", navigation, StringComparison.Ordinal);
- Assert.Contains("Math.Clamp(tabs.SelectedIndex, 0, 5)", navigation, StringComparison.Ordinal);
+ Assert.Contains("contentWidth / 7d", navigation, StringComparison.Ordinal);
+ Assert.Contains("Math.Clamp(tabs.SelectedIndex, 0, 6)", navigation, StringComparison.Ordinal);
Assert.Contains("NavAlarmButton", navigation, StringComparison.Ordinal);
+ Assert.Contains("NavNativeFatButton", navigation, StringComparison.Ordinal);
Assert.Contains("MainTabs.SelectedIndex == 4", main, StringComparison.Ordinal);
Assert.Contains("MainTabs.SelectedIndex == 5", main, StringComparison.Ordinal);
- Assert.Contains("Math.Clamp(index, 0, 5)", main, StringComparison.Ordinal);
+ Assert.Contains("private const int NativeFatWorkspaceIndex = 6", nativeFat, StringComparison.Ordinal);
+ Assert.Contains("Math.Clamp(index, 0, NativeFatWorkspaceIndex)", main, StringComparison.Ordinal);
}
[Fact]
diff --git a/tests/ARSAS.Tests/IoFatM4ProductionControllerAdapterRegressionTests.cs b/tests/ARSAS.Tests/IoFatM4ProductionControllerAdapterRegressionTests.cs
new file mode 100644
index 000000000..87888f7f6
--- /dev/null
+++ b/tests/ARSAS.Tests/IoFatM4ProductionControllerAdapterRegressionTests.cs
@@ -0,0 +1,236 @@
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Models.IoTesting;
+using ArIED61850Tester.Services.IoTesting;
+
+namespace ARSAS.Tests;
+
+public sealed class IoFatM4ProductionControllerAdapterRegressionTests
+{
+ [Fact]
+ public void LatchedStart_DoesNotFollowExplorerSelection_AndKeepsFrozenScope()
+ {
+ var fixture = CreateFixture();
+ fixture.PointA2.WorkspaceSelected = false;
+ new IoTestLiveBindingService().Bind(fixture.Project, fixture.Devices);
+
+ using var primary = NewController(fixture.Project, fixture.Devices, fixture.Root);
+ using var sessions = new IoTestMultiSessionCoordinator(fixture.Project, primary);
+ sessions.SelectContext(fixture.IedA);
+
+ var lease = IoFatProductionControllerAdapter.LatchStartTarget(fixture.Project, fixture.IedA);
+ Assert.Single(lease.Points);
+ Assert.Same(fixture.PointA1, lease.Points[0].Point);
+
+ // Simulate changes that can occur while Engineering connection preparation awaits:
+ // the global Explorer now views B and a second row becomes selected. Neither may
+ // redirect or widen the already-latched production evidence transaction.
+ sessions.SelectContext(fixture.IedB);
+ fixture.PointA2.WorkspaceSelected = true;
+
+ var start = IoFatProductionControllerAdapter.StartLatched(fixture.Project, sessions, lease);
+
+ Assert.True(start.Succeeded, start.Message);
+ Assert.Same(fixture.IedB, sessions.SelectedIed);
+ Assert.True(sessions.IsIedSessionActive(fixture.IedA));
+ Assert.False(sessions.IsIedSessionActive(fixture.IedB));
+ Assert.Contains(" / 1 complete", primary.ProgressText, StringComparison.Ordinal);
+
+ Assert.True(sessions.Stop(fixture.IedA, "test cleanup").Succeeded);
+ }
+
+ [Fact]
+ public void LatchedStart_FailsClosed_WhenEngineeringDeviceIdDriftsBeforeStart()
+ {
+ var fixture = CreateFixture();
+ new IoTestLiveBindingService().Bind(fixture.Project, fixture.Devices);
+
+ using var primary = NewController(fixture.Project, fixture.Devices, fixture.Root);
+ using var sessions = new IoTestMultiSessionCoordinator(fixture.Project, primary);
+ var lease = IoFatProductionControllerAdapter.LatchStartTarget(fixture.Project, fixture.IedA);
+ Assert.Equal("device-a", lease.DeviceId, ignoreCase: true);
+
+ fixture.IedA.ApplyLiveDeviceBinding(
+ "device-b",
+ "simulated Engineering binding drift",
+ isConnected: true,
+ isMonitoring: true);
+
+ var start = IoFatProductionControllerAdapter.StartLatched(fixture.Project, sessions, lease);
+
+ Assert.False(start.Succeeded);
+ Assert.Contains("DeviceId", start.Message, StringComparison.OrdinalIgnoreCase);
+ Assert.False(sessions.HasActiveSessions);
+ Assert.Empty(Directory.GetFiles(fixture.Root, "*.evidence.jsonl", SearchOption.AllDirectories));
+ }
+
+ [Fact]
+ public void LatchedStart_FailsClosed_WhenFrozenRowEligibilityChanges()
+ {
+ var fixture = CreateFixture();
+ new IoTestLiveBindingService().Bind(fixture.Project, fixture.Devices);
+
+ using var primary = NewController(fixture.Project, fixture.Devices, fixture.Root);
+ using var sessions = new IoTestMultiSessionCoordinator(fixture.Project, primary);
+ var lease = IoFatProductionControllerAdapter.LatchStartTarget(fixture.Project, fixture.IedA);
+
+ fixture.PointA1.WorkspaceSelected = false;
+ var start = IoFatProductionControllerAdapter.StartLatched(fixture.Project, sessions, lease);
+
+ Assert.False(start.Succeeded);
+ Assert.Contains("eligibility", start.Message, StringComparison.OrdinalIgnoreCase);
+ Assert.False(sessions.HasActiveSessions);
+ Assert.Empty(Directory.GetFiles(fixture.Root, "*.evidence.jsonl", SearchOption.AllDirectories));
+ }
+
+ [Fact]
+ public void ContinuePauseAndStop_UseExplicitIedOwner_NotCurrentExplorerProjection()
+ {
+ var fixture = CreateFixture();
+ new IoTestLiveBindingService().Bind(fixture.Project, fixture.Devices);
+
+ using var primary = NewController(fixture.Project, fixture.Devices, fixture.Root);
+ using var sessions = new IoTestMultiSessionCoordinator(fixture.Project, primary);
+ sessions.SelectContext(fixture.IedA);
+ var lease = IoFatProductionControllerAdapter.LatchStartTarget(fixture.Project, fixture.IedA);
+ Assert.True(IoFatProductionControllerAdapter.StartLatched(fixture.Project, sessions, lease).Succeeded);
+
+ Assert.True(sessions.Pause(fixture.IedA, "pause A").Succeeded);
+ sessions.SelectContext(fixture.IedB);
+
+ // Continue A while B is the viewed IED. The selected projection must remain B,
+ // while the active production controller continues its already-owned A session.
+ var resume = sessions.Resume(fixture.IedA);
+ Assert.True(resume.Succeeded, resume.Message);
+ Assert.Same(fixture.IedB, sessions.SelectedIed);
+ Assert.True(sessions.IsIedSessionActive(fixture.IedA));
+ Assert.False(sessions.IsIedSessionActive(fixture.IedB));
+
+ var stop = sessions.Stop(fixture.IedA, "stop A");
+ Assert.True(stop.Succeeded, stop.Message);
+ Assert.False(sessions.HasActiveSessions);
+ Assert.Same(fixture.IedB, sessions.SelectedIed);
+ }
+
+ private static Fixture CreateFixture()
+ {
+ var pointA1 = Point("A-1", "IED_A", "192.168.81.10", "IED_ALD0/GGIO1.Ind1.stVal");
+ var pointA2 = Point("A-2", "IED_A", "192.168.81.10", "IED_ALD0/GGIO1.Ind2.stVal");
+ var pointB = Point("B-1", "IED_B", "192.168.81.11", "IED_BLD0/GGIO1.Ind1.stVal");
+ var iedA = Ied("IED_A", "192.168.81.10", pointA1, pointA2);
+ var iedB = Ied("IED_B", "192.168.81.11", pointB);
+ var project = new IoTestProject
+ {
+ ProjectId = "M4-CAPTURE-LEASE",
+ SchemaVersion = "ARSAS-FAT-IO-1.0",
+ ProjectName = "M4 Production Adapter",
+ SourceWorkbookName = "M4.xlsx",
+ SourceWorkbookSha256 = new string('b', 64),
+ Ieds = { iedA, iedB }
+ };
+ project.InitializeRuntimeNotifications();
+
+ var deviceA = Device("device-a", iedA, pointA1, pointA2);
+ var deviceB = Device("device-b", iedB, pointB);
+ var devices = new[] { deviceA, deviceB };
+ var root = Path.Combine(Path.GetTempPath(), "ARSAS.Tests", "M4", Guid.NewGuid().ToString("N"));
+ Directory.CreateDirectory(root);
+ return new Fixture(project, iedA, iedB, pointA1, pointA2, pointB, devices, root);
+ }
+
+ private static IoTestPointPlan Point(string id, string iedName, string ipAddress, string reference) => new()
+ {
+ TestPointId = id,
+ IedName = iedName,
+ IpAddress = ipAddress,
+ SignalName = id,
+ ObjectReference = reference,
+ FunctionalConstraint = "ST",
+ ExpectedOnText = "ON",
+ ExpectedOffText = "OFF",
+ ExpectedOnRaw = 1,
+ ExpectedOffRaw = 0,
+ DataType = "BOOLEAN",
+ LogicalDevice = iedName + "LD0",
+ LogicalNode = "GGIO1",
+ DataObject = "Ind",
+ DataAttribute = "stVal",
+ SourceIecReference = reference,
+ EventLogSearchReference = reference,
+ ReportDisplayReference = reference + " [ST]",
+ BindingStatus = "CID_DATASET_EXACT",
+ TestEnabled = true,
+ ImportReady = true
+ };
+
+ private static IoTestIedPlan Ied(string name, string ipAddress, params IoTestPointPlan[] points)
+ {
+ var ied = new IoTestIedPlan
+ {
+ IedName = name,
+ IpAddress = ipAddress,
+ IedRole = "Protection IED"
+ };
+ ied.TestPoints.AddRange(points);
+ return ied;
+ }
+
+ private static Iec61850MonitorDevice Device(
+ string deviceId,
+ IoTestIedPlan ied,
+ params IoTestPointPlan[] points)
+ {
+ var device = new Iec61850MonitorDevice
+ {
+ DeviceId = deviceId,
+ Name = ied.IedName,
+ SclIedName = ied.IedName,
+ IpAddress = ied.IpAddress,
+ Port = 102,
+ IsConnected = true,
+ IsMonitoring = true,
+ Status = "Monitoring"
+ };
+
+ foreach (var point in points)
+ {
+ device.Points.Add(new Iec61850MonitorPoint
+ {
+ DeviceId = deviceId,
+ DeviceName = ied.IedName,
+ IpAddress = ied.IpAddress,
+ SignalName = point.SignalName,
+ IecReference = point.ObjectReference,
+ FunctionalConstraint = "ST",
+ Value = "False",
+ Quality = "Good",
+ DeviceTimestamp = "2026-09-10T04:00:00.000Z",
+ SourceMode = "BRCB",
+ Sequence = 0,
+ Status = "Live"
+ });
+ }
+ return device;
+ }
+
+ private static IoTestSessionController NewController(
+ IoTestProject project,
+ IReadOnlyCollection devices,
+ string root) => new(
+ project,
+ key => devices.FirstOrDefault(device =>
+ key.Equals(device.DeviceId, StringComparison.OrdinalIgnoreCase) ||
+ key.Equals(device.Name, StringComparison.OrdinalIgnoreCase) ||
+ key.Equals(device.IpAddress, StringComparison.OrdinalIgnoreCase)),
+ action => action(),
+ root);
+
+ private sealed record Fixture(
+ IoTestProject Project,
+ IoTestIedPlan IedA,
+ IoTestIedPlan IedB,
+ IoTestPointPlan PointA1,
+ IoTestPointPlan PointA2,
+ IoTestPointPlan PointB,
+ IReadOnlyCollection Devices,
+ string Root);
+}
diff --git a/tests/ARSAS.Tests/IoFatM5PersistenceAuthorityRegressionTests.cs b/tests/ARSAS.Tests/IoFatM5PersistenceAuthorityRegressionTests.cs
new file mode 100644
index 000000000..401af02fb
--- /dev/null
+++ b/tests/ARSAS.Tests/IoFatM5PersistenceAuthorityRegressionTests.cs
@@ -0,0 +1,228 @@
+using System.Security.Cryptography;
+using System.Text;
+using ArIED61850Tester.Models.IoTesting;
+using ArIED61850Tester.Services.IoTesting;
+using Xunit;
+
+namespace ARSAS.Tests;
+
+public sealed class IoFatM5PersistenceAuthorityRegressionTests
+{
+ [Fact]
+ public async Task Reconcile_DeviceIdMismatch_FailsClosedWithoutRestoringEvidence()
+ {
+ var root = TempDirectory();
+ var sourcePath = await WriteSourceAsync(root, "m5-device-mismatch.xlsx", "m5-device-mismatch-source");
+ var projectsRoot = Path.Combine(root, "projects");
+ var evidenceRoot = Path.Combine(root, "evidence");
+
+ var savedIed = Ied("IED-A", "192.168.90.11", "engineering-device-old");
+ var saved = Project(Hash(sourcePath), savedIed);
+ using (var session = Session(saved, evidenceRoot))
+ {
+ var opened = await IoTestWorkspacePersistence.OpenWorkbookAsync(
+ saved, session, sourcePath, projectsRoot, evidenceRoot);
+ using (opened.Workspace)
+ {
+ CompletePass(opened.Project.Ieds.Single().TestPoints.Single());
+ opened.Workspace.SaveNow();
+ }
+ }
+
+ var evidenceFilesBefore = EvidenceFiles(evidenceRoot);
+ var current = Project(Hash(sourcePath), Ied("IED-A", "192.168.90.11", "engineering-device-new"));
+
+ var reopened = await IoTestWorkspaceBootstrapService.OpenWorkbookAsync(
+ current, sourcePath, projectsRoot, evidenceRoot, Session);
+ using (reopened.Session)
+ using (reopened.Workspace)
+ {
+ Assert.Same(current, reopened.Project);
+ var point = reopened.Project.Ieds.Single().TestPoints.Single();
+ Assert.Equal(IoTestPointState.NotStarted, point.Runtime.State);
+ Assert.Null(point.Runtime.OnEvidence);
+ Assert.Null(point.Runtime.OffEvidence);
+ }
+
+ Assert.Equal(evidenceFilesBefore, EvidenceFiles(evidenceRoot));
+ }
+
+ [Fact]
+ public async Task Reconcile_MatchingDeviceId_RestoresExistingEvidenceWithoutCreatingNewEvidenceFiles()
+ {
+ var root = TempDirectory();
+ var sourcePath = await WriteSourceAsync(root, "m5-device-match.xlsx", "m5-device-match-source");
+ var projectsRoot = Path.Combine(root, "projects");
+ var evidenceRoot = Path.Combine(root, "evidence");
+ const string deviceId = "engineering-device-ied-a";
+
+ var saved = Project(Hash(sourcePath), Ied("IED-A", "192.168.90.21", deviceId));
+ using (var session = Session(saved, evidenceRoot))
+ {
+ var opened = await IoTestWorkspacePersistence.OpenWorkbookAsync(
+ saved, session, sourcePath, projectsRoot, evidenceRoot);
+ using (opened.Workspace)
+ {
+ CompletePass(opened.Project.Ieds.Single().TestPoints.Single());
+ opened.Workspace.SaveNow();
+ }
+ }
+
+ var evidenceFilesBefore = EvidenceFiles(evidenceRoot);
+ var current = Project(Hash(sourcePath), Ied("IED-A", "192.168.90.21", deviceId));
+
+ var reopened = await IoTestWorkspaceBootstrapService.OpenWorkbookAsync(
+ current, sourcePath, projectsRoot, evidenceRoot, Session);
+ using (reopened.Session)
+ using (reopened.Workspace)
+ {
+ Assert.Same(current, reopened.Project);
+ Assert.True(reopened.RestoredProgress);
+ var point = reopened.Project.Ieds.Single().TestPoints.Single();
+ Assert.Equal(IoTestPointState.Passed, point.Runtime.State);
+ Assert.NotNull(point.Runtime.OnEvidence);
+ Assert.NotNull(point.Runtime.OffEvidence);
+ }
+
+ // Background/bootstrap reconciliation may adopt already-persisted evidence into the
+ // fresh Engineering plan, but it is not an evidence-producing operation. Only an
+ // explicit FAT session/capture path is allowed to create journal evidence.
+ Assert.Equal(evidenceFilesBefore, EvidenceFiles(evidenceRoot));
+ }
+
+ [Fact]
+ public async Task Reconcile_LegacyEmptyDeviceId_RemainsCompatibleWithExactIecEndpoint()
+ {
+ var root = TempDirectory();
+ var sourcePath = await WriteSourceAsync(root, "m5-legacy-device.xlsx", "m5-legacy-device-source");
+ var projectsRoot = Path.Combine(root, "projects");
+ var evidenceRoot = Path.Combine(root, "evidence");
+
+ // Empty DeviceId represents historical snapshots created before the M5 authority key.
+ var saved = Project(Hash(sourcePath), Ied("IED-A", "192.168.90.31", deviceId: null));
+ using (var session = Session(saved, evidenceRoot))
+ {
+ var opened = await IoTestWorkspacePersistence.OpenWorkbookAsync(
+ saved, session, sourcePath, projectsRoot, evidenceRoot);
+ using (opened.Workspace)
+ {
+ CompletePass(opened.Project.Ieds.Single().TestPoints.Single());
+ opened.Workspace.SaveNow();
+ }
+ }
+
+ var current = Project(Hash(sourcePath), Ied("IED-A", "192.168.90.31", "engineering-device-now-known"));
+ var reopened = await IoTestWorkspaceBootstrapService.OpenWorkbookAsync(
+ current, sourcePath, projectsRoot, evidenceRoot, Session);
+ using (reopened.Session)
+ using (reopened.Workspace)
+ {
+ var point = reopened.Project.Ieds.Single().TestPoints.Single();
+ Assert.Equal(IoTestPointState.Passed, point.Runtime.State);
+ Assert.NotNull(point.Runtime.OnEvidence);
+ Assert.NotNull(point.Runtime.OffEvidence);
+ }
+ }
+
+ private static IoTestProject Project(string sourceHash, IoTestIedPlan ied)
+ {
+ var project = new IoTestProject
+ {
+ ProjectId = "M5-PERSISTENCE-AUTHORITY",
+ SchemaVersion = "ARSAS-FAT-IO-1.0",
+ ProjectName = "M5 persistence authority",
+ SourceWorkbookName = "m5.xlsx",
+ SourceWorkbookSha256 = sourceHash
+ };
+ project.Ieds.Add(ied);
+ return project;
+ }
+
+ private static IoTestIedPlan Ied(string name, string ip, string? deviceId)
+ {
+ var ied = new IoTestIedPlan
+ {
+ IedName = name,
+ IpAddress = ip,
+ IedRole = "Protection IED",
+ Location = "FAT bench"
+ };
+ if (!string.IsNullOrWhiteSpace(deviceId))
+ ied.ApplyLiveDeviceBinding(deviceId, "Engineering identity bound");
+ ied.TestPoints.Add(Point("TP-001", name, ip, $"{name}LD0/GGIO1.Ind1.stVal"));
+ return ied;
+ }
+
+ private static IoTestPointPlan Point(string id, string iedName, string ip, string objectReference)
+ => new()
+ {
+ TestPointId = id,
+ IedName = iedName,
+ IpAddress = ip,
+ SignalName = "Binary indication",
+ ObjectReference = objectReference,
+ FunctionalConstraint = "ST",
+ ExpectedOnText = "Active",
+ ExpectedOffText = "InActive",
+ ExpectedOnRaw = 1,
+ ExpectedOffRaw = 0,
+ DataType = "SDI",
+ SourceIecReference = objectReference,
+ EventLogSearchReference = objectReference,
+ SignalKind = FatSignalKind.Discrete,
+ CaptureMode = FatCaptureMode.AutomaticTransition,
+ ImportReady = true,
+ BindingStatus = "CID_DATASET_EXACT"
+ };
+
+ private static void CompletePass(IoTestPointPlan point)
+ {
+ var evaluator = new IoTestTransitionEvaluator();
+ evaluator.StartAttempt(point, Observation(false, 1));
+ evaluator.Observe(point, Observation(true, 2));
+ evaluator.Observe(point, Observation(false, 3));
+ Assert.Equal(IoTestPointState.Passed, point.Runtime.State);
+ }
+
+ private static IoTestObservation Observation(bool state, long sequence)
+ {
+ var timestamp = new DateTimeOffset(2026, 9, 10, 3, 0, 0, TimeSpan.Zero).AddMilliseconds(sequence * 100);
+ return new IoTestObservation(
+ state,
+ state ? "True" : "False",
+ timestamp,
+ timestamp.AddMilliseconds(-3),
+ "Good",
+ "BRCB",
+ sequence,
+ 1);
+ }
+
+ private static IoTestSessionController Session(IoTestProject project, string evidenceRoot)
+ => new(project, _ => null, action => action(), evidenceRoot);
+
+ private static async Task WriteSourceAsync(string root, string fileName, string content)
+ {
+ var path = Path.Combine(root, fileName);
+ await File.WriteAllBytesAsync(path, Encoding.UTF8.GetBytes(content));
+ return path;
+ }
+
+ private static string[] EvidenceFiles(string evidenceRoot)
+ => !Directory.Exists(evidenceRoot)
+ ? Array.Empty()
+ : Directory.EnumerateFiles(evidenceRoot, "*", SearchOption.AllDirectories)
+ .Select(path => Path.GetRelativePath(evidenceRoot, path))
+ .OrderBy(path => path, StringComparer.Ordinal)
+ .ToArray();
+
+ private static string Hash(string path)
+ => Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(path))).ToLowerInvariant();
+
+ private static string TempDirectory()
+ {
+ var path = Path.Combine(Path.GetTempPath(), "ARSAS.Tests", Guid.NewGuid().ToString("N"));
+ Directory.CreateDirectory(path);
+ return path;
+ }
+}
diff --git a/tests/ARSAS.Tests/IoFatPhaseBPerIedRestoreRegressionTests.cs b/tests/ARSAS.Tests/IoFatPhaseBPerIedRestoreRegressionTests.cs
index 4b263b5c0..6e2afdcad 100644
--- a/tests/ARSAS.Tests/IoFatPhaseBPerIedRestoreRegressionTests.cs
+++ b/tests/ARSAS.Tests/IoFatPhaseBPerIedRestoreRegressionTests.cs
@@ -134,6 +134,10 @@ public async Task Reopen_RequiresTechnicalKeyAndIpForIedOwnership()
using (reopened.Session)
using (reopened.Workspace)
{
+ // Bootstrap must keep the freshly imported Engineering plan as authority. A
+ // persistence candidate may contribute progress only after IED ownership matches;
+ // it must never replace the current project wholesale.
+ Assert.Same(current, reopened.Project);
var point = reopened.Project.Ieds.Single().TestPoints.Single();
Assert.Equal(IoTestPointState.NotStarted, point.Runtime.State);
Assert.Null(point.Runtime.OnEvidence);
diff --git a/tests/ARSAS.Tests/MainWindowTopBarLayoutRegressionTests.cs b/tests/ARSAS.Tests/MainWindowTopBarLayoutRegressionTests.cs
index 67a83f8a4..7a2a4aca7 100644
--- a/tests/ARSAS.Tests/MainWindowTopBarLayoutRegressionTests.cs
+++ b/tests/ARSAS.Tests/MainWindowTopBarLayoutRegressionTests.cs
@@ -3,7 +3,7 @@ namespace ARSAS.Tests;
public sealed class MainWindowTopBarLayoutRegressionTests
{
[Fact]
- public void NavigationLayout_UsesResponsiveWidthsAndConsistentSixDestinationLabels()
+ public void NavigationLayout_UsesResponsiveWidthsAndConsistentSevenDestinationGeometry()
{
var source = File.ReadAllText(FindRepoFile("MainWindow.NavigationLayoutFix.cs"));
@@ -14,20 +14,22 @@ public void NavigationLayout_UsesResponsiveWidthsAndConsistentSixDestinationLabe
Assert.Contains("\"Alarm\"", source, StringComparison.Ordinal);
Assert.DoesNotContain("\"Alarm Annunciator\"", source, StringComparison.Ordinal);
Assert.Contains("\"GOOSE Subscriber\"", source, StringComparison.Ordinal);
+ Assert.Contains("NavNativeFatButton", source, StringComparison.Ordinal);
Assert.Contains("var labels = wide ? FullLabels : CompactLabels", source, StringComparison.Ordinal);
}
[Fact]
- public void SelectionPill_IsDerivedFromActualSixCellNavWidth_NotFixed150Pixels()
+ public void SelectionPill_IsDerivedFromActualSevenCellNavWidth_NotFixed150Pixels()
{
var source = File.ReadAllText(FindRepoFile("MainWindow.NavigationLayoutFix.cs"));
- Assert.Contains("var cellWidth = contentWidth / 6d", source, StringComparison.Ordinal);
- Assert.Contains("Math.Clamp(tabs.SelectedIndex, 0, 5) * cellWidth", source, StringComparison.Ordinal);
+ Assert.Contains("var cellWidth = contentWidth / 7d", source, StringComparison.Ordinal);
+ Assert.Contains("Math.Clamp(tabs.SelectedIndex, 0, 6) * cellWidth", source, StringComparison.Ordinal);
Assert.Contains("pill.Width = Math.Max(1d, cellWidth - 2d)", source, StringComparison.Ordinal);
Assert.Contains("FindName(\"WorkflowPillTranslate\") as TranslateTransform", source, StringComparison.Ordinal);
Assert.Contains("pill.RenderTransform is TransformGroup", source, StringComparison.Ordinal);
Assert.DoesNotContain("* 150d", source, StringComparison.Ordinal);
+ Assert.DoesNotContain("contentWidth / 6d", source, StringComparison.Ordinal);
Assert.DoesNotContain("contentWidth / 5d", source, StringComparison.Ordinal);
}
@@ -41,6 +43,7 @@ public void ResponsiveCorrection_RunsAfterSelectionResizeAndRepeatedNavClick()
Assert.Contains("Button.ClickEvent", source, StringComparison.Ordinal);
Assert.Contains("OnMainWindowButtonClick", source, StringComparison.Ordinal);
Assert.Contains("NavAlarmButton", source, StringComparison.Ordinal);
+ Assert.Contains("NavNativeFatButton", source, StringComparison.Ordinal);
Assert.Contains("A repeated click on the already-selected tab", source, StringComparison.Ordinal);
Assert.Contains("DispatcherPriority.Loaded", source, StringComparison.Ordinal);
Assert.Contains("DispatcherPriority.ContextIdle", source, StringComparison.Ordinal);
diff --git a/tests/ARSAS.Tests/NativeFatPdfReportTests.cs b/tests/ARSAS.Tests/NativeFatPdfReportTests.cs
new file mode 100644
index 000000000..9f6c85fe3
--- /dev/null
+++ b/tests/ARSAS.Tests/NativeFatPdfReportTests.cs
@@ -0,0 +1,72 @@
+using System.Text;
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Services;
+
+namespace ARSAS.Tests;
+
+public sealed class NativeFatPdfReportTests
+{
+ [Fact]
+ public void Generate_ProducesPdfFromImmutableNativeSnapshot()
+ {
+ var snapshot = new NativeFatReportSnapshot(
+ DeviceId: "pdf-device-01",
+ IedName: "Relay PDF",
+ IpAddress: "192.0.2.55",
+ Port: 102,
+ GeneratedUtc: new DateTimeOffset(2026, 9, 9, 9, 15, 0, TimeSpan.Zero),
+ Rows:
+ [
+ new NativeFatReportRow(
+ SignalName: "Breaker status",
+ IecReference: "IED1LD0/GGIO1.Ind1.stVal",
+ FunctionalConstraint: "ST",
+ DataType: "Boolean",
+ IsHistorical: false,
+ Result: NativeFatResult.Pass,
+ HistoryCount: 2,
+ Value1Text: "False",
+ Value1Quality: "Good",
+ Value1DeviceTimestamp: "2026-09-09 09:00:00.001",
+ Value1SourceMode: "BRCB",
+ Value1CapturedUtc: new DateTimeOffset(2026, 9, 9, 9, 0, 1, TimeSpan.Zero),
+ Value2Text: "True",
+ Value2Quality: "Good",
+ Value2DeviceTimestamp: "2026-09-09 09:00:05.002",
+ Value2SourceMode: "BRCB",
+ Value2CapturedUtc: new DateTimeOffset(2026, 9, 9, 9, 0, 6, TimeSpan.Zero)),
+ new NativeFatReportRow(
+ SignalName: "Removed old DI",
+ IecReference: "IED1LD0/GGIO1.Ind9.stVal",
+ FunctionalConstraint: "ST",
+ DataType: "Boolean",
+ IsHistorical: true,
+ Result: NativeFatResult.Fail,
+ HistoryCount: 4,
+ Value1Text: "False",
+ Value1Quality: "Good",
+ Value1DeviceTimestamp: "2026-09-08 08:00:00.001",
+ Value1SourceMode: "MMS polling",
+ Value1CapturedUtc: new DateTimeOffset(2026, 9, 8, 8, 0, 1, TimeSpan.Zero),
+ Value2Text: "True",
+ Value2Quality: "Good",
+ Value2DeviceTimestamp: "2026-09-08 08:00:04.001",
+ Value2SourceMode: "MMS polling",
+ Value2CapturedUtc: new DateTimeOffset(2026, 9, 8, 8, 0, 5, TimeSpan.Zero))
+ ]);
+
+ var currentOnly = NativeFatPdfReportService.Generate(snapshot, includeHistorical: false);
+ var withHistory = NativeFatPdfReportService.Generate(snapshot, includeHistorical: true);
+
+ Assert.True(currentOnly.Length > 4_000);
+ Assert.True(withHistory.Length > currentOnly.Length);
+ Assert.Equal("%PDF-1.4", Encoding.ASCII.GetString(currentOnly, 0, 8));
+
+ var ascii = Encoding.ASCII.GetString(withHistory);
+ Assert.Contains("ARSAS Native FAT - Relay PDF - IEC 61850 FAT Evidence Report", ascii, StringComparison.Ordinal);
+ Assert.Contains("Breaker status", ascii, StringComparison.Ordinal);
+ Assert.Contains("Removed old DI", ascii, StringComparison.Ordinal);
+ Assert.Contains("historical included: 1", ascii, StringComparison.OrdinalIgnoreCase);
+ Assert.Contains("%%EOF", ascii, StringComparison.Ordinal);
+ }
+}
diff --git a/tests/ARSAS.Tests/NativeFatStateStoreRegressionTests.cs b/tests/ARSAS.Tests/NativeFatStateStoreRegressionTests.cs
new file mode 100644
index 000000000..c0b3db44b
--- /dev/null
+++ b/tests/ARSAS.Tests/NativeFatStateStoreRegressionTests.cs
@@ -0,0 +1,317 @@
+using ArIED61850Tester.Models;
+using ArIED61850Tester.Services;
+
+namespace ARSAS.Tests;
+
+public sealed class NativeFatStateStoreRegressionTests
+{
+ [Fact]
+ public void Reconcile_AddRenameRemoveReadd_PreservesExistingEvidence()
+ {
+ var device = CreateDevice("device-a", "Relay A");
+ var original = CreateSignal("Trip original", "IED1LD0/GGIO1.Ind1.stVal");
+ device.Signals.Add(original);
+
+ var state = new NativeFatDeviceState();
+ NativeFatStateStore.Reconcile(state, device);
+
+ var saved = Assert.Single(state.Signals);
+ Assert.Equal(NativeFatResult.Untested, saved.Result);
+ Assert.False(saved.IsHistorical);
+
+ using (var row = Assert.Single(NativeFatStateStore.BuildRows(state, device)))
+ {
+ original.Value = "True";
+ original.Quality = "Good";
+ original.DeviceTimestamp = "2026-09-09 08:15:01.125";
+ Assert.True(row.CaptureValue(1));
+ row.SetResult(NativeFatResult.Pass);
+ }
+
+ original.Name = "Trip renamed";
+ NativeFatStateStore.Reconcile(state, device);
+ saved = Assert.Single(state.Signals);
+ Assert.Equal("Trip renamed", saved.SignalName);
+ Assert.Equal(NativeFatResult.Pass, saved.Result);
+ Assert.Equal("True", saved.Value1?.Value);
+ Assert.False(saved.IsHistorical);
+
+ device.Signals.Clear();
+ NativeFatStateStore.Reconcile(state, device);
+ saved = Assert.Single(state.Signals);
+ Assert.True(saved.IsHistorical);
+ Assert.Equal(NativeFatResult.Pass, saved.Result);
+ Assert.Equal("True", saved.Value1?.Value);
+
+ // Same IEC identity, different case and '$' separator: this must restore the old
+ // FAT row rather than creating a second UNTESTED row.
+ device.Signals.Add(CreateSignal("Trip re-added", "ied1ld0/GGIO1$Ind1$stVal"));
+ NativeFatStateStore.Reconcile(state, device);
+ saved = Assert.Single(state.Signals);
+ Assert.False(saved.IsHistorical);
+ Assert.Equal("Trip re-added", saved.SignalName);
+ Assert.Equal(NativeFatResult.Pass, saved.Result);
+ Assert.Equal("True", saved.Value1?.Value);
+ }
+
+ [Fact]
+ public void Reconcile_ExplorerSelectionChange_PreservesEvidenceAndRestoresOnReselect()
+ {
+ var device = CreateDevice("device-selection", "Selection IED");
+ var first = CreateSignal("DI 1", "IED1LD0/GGIO1.Ind1.stVal");
+ var second = CreateSignal("DI 2", "IED1LD0/GGIO1.Ind2.stVal");
+ device.Signals.Add(first);
+ device.Signals.Add(second);
+
+ var state = new NativeFatDeviceState();
+ NativeFatStateStore.Reconcile(state, device);
+ Assert.Equal(2, state.Signals.Count);
+
+ var firstState = state.Signals.Single(signal =>
+ signal.Key == NativeFatIdentity.BuildKey(first));
+ firstState.Result = NativeFatResult.Pass;
+ firstState.Value1 = new NativeFatCapture
+ {
+ Value = "False",
+ Quality = "Good",
+ SourceMode = "BRCB"
+ };
+
+ // Keep DI 2 selected so Explorer has an explicit selected-signal scope. DI 1 must
+ // become historical rather than being deleted when its checkbox is cleared.
+ first.IsSelected = false;
+ NativeFatStateStore.Reconcile(state, device);
+
+ firstState = state.Signals.Single(signal =>
+ signal.Key == NativeFatIdentity.BuildKey(first));
+ var secondState = state.Signals.Single(signal =>
+ signal.Key == NativeFatIdentity.BuildKey(second));
+ Assert.True(firstState.IsHistorical);
+ Assert.False(secondState.IsHistorical);
+ Assert.Equal(NativeFatResult.Pass, firstState.Result);
+ Assert.Equal("False", firstState.Value1?.Value);
+
+ // Re-selecting the same canonical IEC identity resumes the old evidence instead of
+ // starting a new UNTESTED record.
+ first.IsSelected = true;
+ NativeFatStateStore.Reconcile(state, device);
+
+ firstState = state.Signals.Single(signal =>
+ signal.Key == NativeFatIdentity.BuildKey(first));
+ Assert.False(firstState.IsHistorical);
+ Assert.Equal(NativeFatResult.Pass, firstState.Result);
+ Assert.Equal("False", firstState.Value1?.Value);
+ Assert.Equal(2, state.Signals.Count);
+ }
+
+ [Fact]
+ public async Task SaveLoad_RestartAndIedRename_ResumeByStableDeviceId()
+ {
+ using var temp = new TemporaryDirectory();
+ var device = CreateDevice("stable-device-01", "Relay Before Rename");
+ var signal = CreateSignal("Breaker status", "IED1LD0/GGIO1.Ind2.stVal");
+ device.Signals.Add(signal);
+
+ var store = new NativeFatStateStore(temp.Path);
+ var state = await store.LoadAndReconcileAsync(device);
+ using (var row = Assert.Single(NativeFatStateStore.BuildRows(state, device)))
+ {
+ signal.Value = "False";
+ signal.Quality = "Good";
+ Assert.True(row.CaptureValue(1));
+ row.SetResult(NativeFatResult.Review);
+ }
+ await store.SaveAsync(state);
+ var originalPath = state.StoragePath;
+
+ device.Name = "Relay After Rename";
+ var restartedStore = new NativeFatStateStore(temp.Path);
+ var resumed = await restartedStore.LoadAndReconcileAsync(device);
+
+ var resumedSignal = Assert.Single(resumed.Signals);
+ Assert.Equal("Relay After Rename", resumed.IedName);
+ Assert.Equal(NativeFatResult.Review, resumedSignal.Result);
+ Assert.Equal("False", resumedSignal.Value1?.Value);
+ Assert.Equal(originalPath, resumed.StoragePath);
+ Assert.Single(Directory.GetFiles(temp.Path, "*.json"));
+ }
+
+ [Fact]
+ public async Task SameDisplayNameDifferentDeviceIds_NeverShareOneStateFile()
+ {
+ using var temp = new TemporaryDirectory();
+ var store = new NativeFatStateStore(temp.Path);
+
+ var first = CreateDevice("device-one", "Duplicate IED Name");
+ first.Signals.Add(CreateSignal("DI 1", "IED1LD0/GGIO1.Ind1.stVal"));
+ var firstState = await store.LoadAndReconcileAsync(first);
+ firstState.Signals.Single().Result = NativeFatResult.Pass;
+ await store.SaveAsync(firstState);
+
+ var second = CreateDevice("device-two", "Duplicate IED Name");
+ second.Signals.Add(CreateSignal("DI 1", "IED1LD0/GGIO1.Ind1.stVal"));
+ var secondState = await store.LoadAndReconcileAsync(second);
+ secondState.Signals.Single().Result = NativeFatResult.Fail;
+ await store.SaveAsync(secondState);
+
+ Assert.NotEqual(firstState.StoragePath, secondState.StoragePath);
+ Assert.Equal(2, Directory.GetFiles(temp.Path, "*.json").Length);
+
+ var restartedStore = new NativeFatStateStore(temp.Path);
+ var firstReloaded = await restartedStore.LoadAndReconcileAsync(first);
+ var secondReloaded = await restartedStore.LoadAndReconcileAsync(second);
+ Assert.Equal(NativeFatResult.Pass, Assert.Single(firstReloaded.Signals).Result);
+ Assert.Equal(NativeFatResult.Fail, Assert.Single(secondReloaded.Signals).Result);
+ }
+
+ [Fact]
+ public async Task DamagedPreferredJson_IsNeverOverwrittenByRecoveryState()
+ {
+ using var temp = new TemporaryDirectory();
+ var device = CreateDevice("device-corrupt", "Corrupt Evidence IED");
+ device.Signals.Add(CreateSignal("DI 1", "IED1LD0/GGIO1.Ind1.stVal"));
+
+ var firstStore = new NativeFatStateStore(temp.Path);
+ var seed = await firstStore.LoadAsync(device);
+ var damagedPath = seed.StoragePath;
+ const string damagedContent = "{ this is intentionally not valid JSON";
+ await File.WriteAllTextAsync(damagedPath, damagedContent);
+
+ var recoveryStore = new NativeFatStateStore(temp.Path);
+ var recovered = await recoveryStore.LoadAndReconcileAsync(device);
+ Assert.NotEqual(damagedPath, recovered.StoragePath);
+ Assert.Contains("RECOVERY", Path.GetFileName(recovered.StoragePath), StringComparison.OrdinalIgnoreCase);
+
+ await recoveryStore.SaveAsync(recovered);
+ Assert.Equal(damagedContent, await File.ReadAllTextAsync(damagedPath));
+ Assert.True(File.Exists(recovered.StoragePath));
+ Assert.Equal(2, Directory.GetFiles(temp.Path, "*.json").Length);
+ }
+
+ [Fact]
+ public void ReportSnapshot_FreezesEvidenceAndSummaryAtBuildTime()
+ {
+ var device = CreateDevice("device-report", "Report IED");
+ var state = new NativeFatDeviceState
+ {
+ DeviceId = device.DeviceId,
+ IedName = device.Name,
+ Signals =
+ {
+ new NativeFatSignalState
+ {
+ Key = "IED1LD0/GGIO1.IND1.STVAL|ST",
+ SignalName = "Current DI",
+ IecReference = "IED1LD0/GGIO1.Ind1.stVal",
+ FunctionalConstraint = "ST",
+ DataType = "Boolean",
+ Result = NativeFatResult.Pass,
+ Value1 = new NativeFatCapture
+ {
+ Value = "False",
+ Quality = "Good",
+ DeviceTimestamp = "2026-09-09 08:00:00.001",
+ SourceMode = "BRCB",
+ CapturedUtc = new DateTimeOffset(2026, 9, 9, 8, 0, 1, TimeSpan.Zero)
+ },
+ Value2 = new NativeFatCapture
+ {
+ Value = "True",
+ Quality = "Good",
+ DeviceTimestamp = "2026-09-09 08:00:05.002",
+ SourceMode = "BRCB",
+ CapturedUtc = new DateTimeOffset(2026, 9, 9, 8, 0, 6, TimeSpan.Zero)
+ },
+ History = { new NativeFatHistoryEntry { Action = "Result PASS", Result = NativeFatResult.Pass } }
+ },
+ new NativeFatSignalState
+ {
+ Key = "IED1LD0/GGIO1.IND9.STVAL|ST",
+ SignalName = "Removed DI",
+ IecReference = "IED1LD0/GGIO1.Ind9.stVal",
+ FunctionalConstraint = "ST",
+ DataType = "Boolean",
+ Result = NativeFatResult.Fail,
+ IsHistorical = true
+ }
+ }
+ };
+
+ var generated = new DateTimeOffset(2026, 9, 9, 8, 30, 0, TimeSpan.Zero);
+ var snapshot = NativeFatReportSnapshotBuilder.Build(device, state, generated);
+
+ Assert.Equal(generated, snapshot.GeneratedUtc);
+ Assert.Equal(1, snapshot.CurrentCount);
+ Assert.Equal(1, snapshot.HistoricalCount);
+ Assert.Equal(1, snapshot.PassCount);
+ Assert.Equal(0, snapshot.FailCount);
+ Assert.Equal(0, snapshot.UntestedCount);
+
+ var current = snapshot.Rows.Single(row => !row.IsHistorical);
+ Assert.Equal("False", current.Value1Text);
+ Assert.Equal("True", current.Value2Text);
+ Assert.Equal("Good", current.Value1Quality);
+ Assert.Equal("BRCB", current.Value2SourceMode);
+ Assert.Contains("history 1 record", current.EvidenceSummaryText, StringComparison.OrdinalIgnoreCase);
+
+ // A report snapshot is immutable evidence. Later live/persisted mutation must not
+ // retroactively change what this preview/export build represented.
+ state.Signals[0].Value1!.Value = "CHANGED AFTER SNAPSHOT";
+ state.Signals[0].Result = NativeFatResult.Review;
+ Assert.Equal("False", current.Value1Text);
+ Assert.Equal(NativeFatResult.Pass, current.Result);
+ }
+
+ private static Iec61850MonitorDevice CreateDevice(string deviceId, string name)
+ => new()
+ {
+ DeviceId = deviceId,
+ Name = name,
+ IpAddress = "192.0.2.10",
+ Port = 102
+ };
+
+ private static SignalDefinition CreateSignal(string name, string reference)
+ {
+ var signal = new SignalDefinition
+ {
+ Name = name,
+ ObjectReference = reference,
+ FunctionalConstraint = "ST",
+ DataType = "Boolean",
+ Category = "Status",
+ IsSelected = true,
+ ProbeStatus = "Readable"
+ };
+ Assert.True(signal.CanPublishAsSignal, $"Test signal '{reference}' must be publishable by Explorer policy.");
+ return signal;
+ }
+
+ private sealed class TemporaryDirectory : IDisposable
+ {
+ public TemporaryDirectory()
+ {
+ Path = System.IO.Path.Combine(
+ System.IO.Path.GetTempPath(),
+ "ARSAS.Tests",
+ "NativeFat",
+ Guid.NewGuid().ToString("N"));
+ Directory.CreateDirectory(Path);
+ }
+
+ public string Path { get; }
+
+ public void Dispose()
+ {
+ try
+ {
+ if (Directory.Exists(Path))
+ Directory.Delete(Path, recursive: true);
+ }
+ catch
+ {
+ // Test cleanup must not hide the actual assertion result.
+ }
+ }
+ }
+}
diff --git a/tests/ARSAS.Tests/ProductionFatEngineeringTabRegressionTests.cs b/tests/ARSAS.Tests/ProductionFatEngineeringTabRegressionTests.cs
new file mode 100644
index 000000000..c53331a23
--- /dev/null
+++ b/tests/ARSAS.Tests/ProductionFatEngineeringTabRegressionTests.cs
@@ -0,0 +1,125 @@
+namespace ARSAS.Tests;
+
+public sealed class ProductionFatEngineeringTabRegressionTests
+{
+ [Fact]
+ public void EngineeringProjection_ReusesParsedSclWorkspaceWithoutOpeningXmlAgain()
+ {
+ var source = File.ReadAllText(FindRepoFile("Services/IoTesting/IoFatEngineeringWorkspaceProjectionService.cs"));
+
+ Assert.Contains("device.SclWorkspace", source, StringComparison.Ordinal);
+ Assert.Contains("FatSclWorkspaceImportService.Import(workspaceSources)", source, StringComparison.Ordinal);
+ Assert.Contains("ENGINEERING_SCL_DATASET_AUTHORITY", source, StringComparison.Ordinal);
+ Assert.Contains("IoFatSourceWorkspaceService.DescribeAsync", source, StringComparison.Ordinal);
+ Assert.DoesNotContain("SclWorkspaceService", source, StringComparison.Ordinal);
+ Assert.DoesNotContain("OpenAsync(", source, StringComparison.Ordinal);
+ Assert.DoesNotContain("LoadScl", source, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void ProductionFatTab_AutoBootstrapsFromSelectedEngineeringStaticDataSet()
+ {
+ var source = File.ReadAllText(FindRepoFile("MainWindow.ProductionFatEngineeringBootstrap.cs"));
+
+ Assert.Contains("QueueProductionFatEngineeringBootstrap();", source, StringComparison.Ordinal);
+ Assert.Contains("selected?.SclWorkspace", source, StringComparison.Ordinal);
+ Assert.Contains("DesignModel.DataSets.Sum", source, StringComparison.Ordinal);
+ Assert.Contains("IoFatEngineeringWorkspaceProjectionService.BuildAsync", source, StringComparison.Ordinal);
+ Assert.Contains("AdoptEngineeringRuntimeWorkspaces", source, StringComparison.Ordinal);
+ Assert.Contains("IoTestWorkspaceBootstrapService.OpenSourcesAsync", source, StringComparison.Ordinal);
+ Assert.Contains("SynchronizeImportedSclFatWithEngineering", source, StringComparison.Ordinal);
+ Assert.Contains("ShowIoTestingWorkspaceAsync", source, StringComparison.Ordinal);
+ Assert.Contains("no SCL re-import", source, StringComparison.Ordinal);
+ Assert.DoesNotContain("OpenSclFatTesting_Click", source, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void ProductionFatTab_RegistersExactEngineeringRuntimeWorkspacesForSharedAcquisition()
+ {
+ var source = File.ReadAllText(FindRepoFile("Services/IoTesting/IoFatSclProjectImportService.cs"));
+
+ Assert.Contains("AdoptEngineeringRuntimeWorkspaces", source, StringComparison.Ordinal);
+ Assert.Contains("SetRuntimeWorkspaces(stable)", source, StringComparison.Ordinal);
+ Assert.Contains("workspace.WorkspaceKey", source, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void SeventhFatDestination_IsCanonicalMainWindowSiblingWithOneNavigationOwner()
+ {
+ var xaml = File.ReadAllText(FindRepoFile("MainWindow.xaml"));
+ var mainSource = File.ReadAllText(FindRepoFile("MainWindow.xaml.cs"));
+ var bridgeSource = File.ReadAllText(FindRepoFile("MainWindow.NativeFatWorkspace.cs"));
+ var productionSource = File.ReadAllText(FindRepoFile("MainWindow.ProductionFatTab.cs"));
+ var repoRoot = FindRepoRoot();
+
+ Assert.Contains("x:Name=\"NavNativeFatButton\" Grid.Column=\"6\" Content=\"FAT\" Tag=\"6\" Click=\"NavButton_Click\" Style=\"{StaticResource SegmentedNavButton}\"", xaml, StringComparison.Ordinal);
+ Assert.Contains("Grid.ColumnSpan=\"7\"", xaml, StringComparison.Ordinal);
+ Assert.Contains("x:Name=\"NativeFatTab\" Header=\"FAT\"", xaml, StringComparison.Ordinal);
+
+ Assert.Contains("Math.Clamp(index, 0, NativeFatWorkspaceIndex)", mainSource, StringComparison.Ordinal);
+ Assert.Contains("var cellWidth = contentWidth / 7d", mainSource, StringComparison.Ordinal);
+ Assert.Contains("NavNativeFatButton", mainSource, StringComparison.Ordinal);
+
+ Assert.Contains("private const int NativeFatWorkspaceIndex = 6", bridgeSource, StringComparison.Ordinal);
+ Assert.Contains("QueueNativeFatNavigationGeometry", bridgeSource, StringComparison.Ordinal);
+ Assert.DoesNotContain("_nativeFatTab", bridgeSource, StringComparison.Ordinal);
+ Assert.DoesNotContain("_nativeFatNavButton", bridgeSource, StringComparison.Ordinal);
+ Assert.DoesNotContain("BuildNativeFatWorkspaceContent", bridgeSource, StringComparison.Ordinal);
+ Assert.DoesNotContain("DataGrid", bridgeSource, StringComparison.Ordinal);
+
+ Assert.Contains("NativeFatTab.Content = BuildProductionFatPermanentHost();", productionSource, StringComparison.Ordinal);
+ Assert.Contains("NavNativeFatButton.ToolTip", productionSource, StringComparison.Ordinal);
+ Assert.DoesNotContain("ProductionFatNavButton_Click", productionSource, StringComparison.Ordinal);
+ Assert.DoesNotContain("_nativeFatInstalled", productionSource, StringComparison.Ordinal);
+ Assert.DoesNotContain("_nativeFatTab", productionSource, StringComparison.Ordinal);
+ Assert.DoesNotContain("_nativeFatNavButton", productionSource, StringComparison.Ordinal);
+
+ Assert.False(
+ File.Exists(Path.Combine(repoRoot, "MainWindow.ProductionFatNavigationParity.cs")),
+ "Do not reintroduce a second ApplicationIdle navigation parity owner. MainWindow is the seven-slot navigation authority.");
+ }
+
+ [Fact]
+ public void ExistingWorkspaceSelectionSideEffects_RemainProtectedWhileAddingFat()
+ {
+ var source = File.ReadAllText(FindRepoFile("MainWindow.xaml.cs"));
+
+ Assert.Contains("device.ClearUnreadEvents()", source, StringComparison.Ordinal);
+ Assert.Contains("ActivateGooseSubscriberWorkspace()", source, StringComparison.Ordinal);
+ Assert.Contains("ClearDiagnosticAlert()", source, StringComparison.Ordinal);
+ Assert.Contains("UpdateNavigationVisuals(MainTabs.SelectedIndex, animate: true)", source, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void ProductionFatSafetyBoundary_KeepsEngineeringAuthorityAndStrictPreflightCoverage()
+ {
+ var bootstrapSource = File.ReadAllText(FindRepoFile("MainWindow.ProductionFatEngineeringBootstrap.cs"));
+ var fieldRegressionSource = File.ReadAllText(FindRepoFile("tests/ARSAS.Tests/ProductionFatP0FieldRegressionTests.cs"));
+
+ Assert.Contains("RetireManualWorkspaceRowsForStaticDataSetMode", bootstrapSource, StringComparison.Ordinal);
+ Assert.Contains("AutomaticStaticDataSetScope_RetiresManualAliasBeforeSessionPreflight", fieldRegressionSource, StringComparison.Ordinal);
+ Assert.Contains("IoTestSessionPreflight.Validate", fieldRegressionSource, StringComparison.Ordinal);
+ Assert.Contains("multiple enabled test points", fieldRegressionSource, StringComparison.OrdinalIgnoreCase);
+ }
+
+ private static string FindRepoFile(string relativePath)
+ => Path.Combine(FindRepoRoot(), relativePath);
+
+ private static string FindRepoRoot()
+ {
+ DirectoryInfo? directory = new(AppContext.BaseDirectory);
+ while (directory != null)
+ {
+ if (File.Exists(Path.Combine(directory.FullName, "MainWindow.xaml")) &&
+ Directory.Exists(Path.Combine(directory.FullName, "tests", "ARSAS.Tests")))
+ {
+ return directory.FullName;
+ }
+
+ directory = directory.Parent;
+ }
+
+ throw new DirectoryNotFoundException(
+ $"Could not locate repository root from '{AppContext.BaseDirectory}'.");
+ }
+}
diff --git a/tests/ARSAS.Tests/ProductionFatM2PermanentHostRegressionTests.cs b/tests/ARSAS.Tests/ProductionFatM2PermanentHostRegressionTests.cs
new file mode 100644
index 000000000..75266cc0d
--- /dev/null
+++ b/tests/ARSAS.Tests/ProductionFatM2PermanentHostRegressionTests.cs
@@ -0,0 +1,78 @@
+namespace ARSAS.Tests;
+
+public sealed class ProductionFatM2PermanentHostRegressionTests
+{
+ [Fact]
+ public void FatTab_IsPermanentHost_NotLauncherOrAlternateOpenSclWorkflow()
+ {
+ var source = Read("MainWindow.ProductionFatTab.cs");
+
+ Assert.Contains("BuildProductionFatPermanentHost()", source, StringComparison.Ordinal);
+ Assert.DoesNotContain("BuildProductionFatLauncher", source, StringComparison.Ordinal);
+ Assert.DoesNotContain("Open SCL for FAT", source, StringComparison.Ordinal);
+ Assert.DoesNotContain("Open ARSAS Project", source, StringComparison.Ordinal);
+ Assert.DoesNotContain("OpenSclFatTesting_Click", source, StringComparison.Ordinal);
+ Assert.DoesNotContain("OpenIoListPackage_Click", source, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void EngineeringStaticDataSet_PrewarmIsIndependentOfFatTabSelection()
+ {
+ var bootstrap = Read("MainWindow.ProductionFatEngineeringBootstrap.cs");
+ var shared = Read("MainWindow.SharedSclWorkspace.cs");
+
+ Assert.Contains("e.PropertyName != nameof(SelectedDevice)", bootstrap, StringComparison.Ordinal);
+ Assert.Contains("QueueProductionFatEngineeringBootstrap();", shared, StringComparison.Ordinal);
+ Assert.DoesNotContain("_productionFatEngineeringBootstrapBusy ||\n MainTabs.SelectedIndex != NativeFatWorkspaceIndex", bootstrap, StringComparison.Ordinal);
+ Assert.DoesNotContain("_productionFatEngineeringBootstrapInstalled || MainTabs.SelectedIndex != NativeFatWorkspaceIndex", bootstrap, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void EmbeddedDonor_IsPreparedBeforeShow_AndMainWindowStaysVisible()
+ {
+ var launch = Read("MainWindow.IoTesting.cs");
+ var host = Read("IoListTestingWindow.EmbeddedEngineeringHost.cs");
+ var tab = Read("MainWindow.ProductionFatTab.cs");
+
+ var prepare = launch.IndexOf("window.PrepareForEmbeddedEngineeringHost();", StringComparison.Ordinal);
+ var show = launch.IndexOf("window.Show();", StringComparison.Ordinal);
+ Assert.True(prepare >= 0 && show > prepare, "Donor visibility must be prepared before Window.Show().");
+ Assert.Contains("if (!ProductionFatTabReady)\n Hide();", launch, StringComparison.Ordinal);
+ Assert.Contains("Left = -32000d", host, StringComparison.Ordinal);
+ Assert.Contains("Opacity = 0d", host, StringComparison.Ordinal);
+ Assert.Contains("ShowActivated = false", host, StringComparison.Ordinal);
+ Assert.Contains("ShowInTaskbar = false", host, StringComparison.Ordinal);
+
+ Assert.DoesNotContain("MainTabs.SelectedIndex = NativeFatWorkspaceIndex", tab, StringComparison.Ordinal);
+ Assert.DoesNotContain("Activate();", tab, StringComparison.Ordinal);
+ Assert.DoesNotContain("if (!IsVisible)\n Show();", tab, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void EmbeddedSurface_RemainsExactProductionGridAndPreviewSource()
+ {
+ var host = Read("IoListTestingWindow.EmbeddedEngineeringHost.cs");
+
+ Assert.Contains("InstallFatV2WorkspaceUx();", host, StringComparison.Ordinal);
+ Assert.Contains("InstallPerIedPrintPreview();", host, StringComparison.Ordinal);
+ Assert.Contains("DetachProductionFatCentralWorkspace()", host, StringComparison.Ordinal);
+ Assert.Contains("owner.MountProductionFatWorkspace(this, surface)", host, StringComparison.Ordinal);
+ }
+
+ private static string Read(string relativePath)
+ => File.ReadAllText(Path.Combine(FindRepoRoot(), relativePath)).Replace("\r\n", "\n", StringComparison.Ordinal);
+
+ private static string FindRepoRoot()
+ {
+ DirectoryInfo? directory = new(AppContext.BaseDirectory);
+ while (directory != null)
+ {
+ if (File.Exists(Path.Combine(directory.FullName, "MainWindow.xaml")) &&
+ Directory.Exists(Path.Combine(directory.FullName, "tests", "ARSAS.Tests")))
+ return directory.FullName;
+ directory = directory.Parent;
+ }
+
+ throw new DirectoryNotFoundException("Could not locate repository root.");
+ }
+}
diff --git a/tests/ARSAS.Tests/ProductionFatM3SelectedIedBindingRegressionTests.cs b/tests/ARSAS.Tests/ProductionFatM3SelectedIedBindingRegressionTests.cs
new file mode 100644
index 000000000..c8d50ce60
--- /dev/null
+++ b/tests/ARSAS.Tests/ProductionFatM3SelectedIedBindingRegressionTests.cs
@@ -0,0 +1,104 @@
+namespace ARSAS.Tests;
+
+public sealed class ProductionFatM3SelectedIedBindingRegressionTests
+{
+ [Fact]
+ public void Start_LatchesCaptureTarget_WithoutTakingOverViewedContext()
+ {
+ var window = Read("IoListTestingWindow.xaml.cs");
+ var coordinator = Read("Services/IoTesting/IoTestMultiSessionCoordinator.cs");
+
+ var requested = window.IndexOf("var requestedIed = SelectedIed;", StringComparison.Ordinal);
+ var latch = window.IndexOf("IoFatProductionControllerAdapter.LatchStartTarget(Project, requestedIed)", requested, StringComparison.Ordinal);
+ var selected = window.IndexOf("var selectedIed = captureLease.Ied;", latch, StringComparison.Ordinal);
+ var prepare = window.IndexOf("await engineeringWindow.PrepareIoTestIedForFatAsync(", selected, StringComparison.Ordinal);
+ var start = window.IndexOf("IoFatProductionControllerAdapter.StartLatched(Project, Session, captureLease)", prepare, StringComparison.Ordinal);
+
+ Assert.True(requested >= 0, "Start FAT must read the currently viewed IED before asynchronous preparation.");
+ Assert.True(latch > requested, "Production FAT must freeze the IED and exact capture scope before asynchronous preparation.");
+ Assert.True(selected > latch, "The preparation target must come from the frozen production capture lease.");
+ Assert.True(prepare > selected, "Engineering acquisition must prepare the latched target.");
+ Assert.True(start > prepare, "The production session must start from the same frozen lease after preparation.");
+
+ var startBody = MethodBody(
+ coordinator,
+ "public IoTestSessionActionResult Start(\n IoTestIedPlan? ied,\n IReadOnlyCollection? captureScope)",
+ "public IoTestSessionActionResult Pause");
+ Assert.DoesNotContain("SelectContext(ied)", startBody, StringComparison.Ordinal);
+ Assert.Contains("GetOrCreateController(ied)", startBody, StringComparison.Ordinal);
+ Assert.Contains("controller.Start(ied, captureScope)", startBody, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void EngineeringExplorer_RemainsViewedIedAuthority_WhileSessionsMayRun()
+ {
+ var owner = Read("MainWindow.ProductionFatTab.cs");
+ var embedded = Read("IoListTestingWindow.EmbeddedEngineeringHost.cs");
+ var window = Read("IoListTestingWindow.xaml.cs");
+
+ var propertyHandler = MethodBody(
+ owner,
+ "private void ProductionFat_MainWindowPropertyChanged",
+ "private void SynchronizeProductionFatSelectedIed()");
+ Assert.Contains("e.PropertyName == nameof(SelectedDevice)", propertyHandler, StringComparison.Ordinal);
+ Assert.Contains("SynchronizeProductionFatSelectedIed();", propertyHandler, StringComparison.Ordinal);
+ Assert.DoesNotContain("HasRunningSession", propertyHandler, StringComparison.Ordinal);
+
+ var selectDevice = MethodBody(
+ embedded,
+ "internal void SelectEngineeringDeviceForEmbeddedFat",
+ "internal void NotifyEmbeddedHostActivated");
+ Assert.Contains("SelectedIed = null;", selectDevice, StringComparison.Ordinal);
+ Assert.Contains("SelectedIed = match;", selectDevice, StringComparison.Ordinal);
+ Assert.Contains("Session.SelectContext", window, StringComparison.Ordinal);
+ Assert.Contains("public bool CanSelectIed => true;", window, StringComparison.Ordinal);
+
+ var deviceId = selectDevice.IndexOf("device.DeviceId", StringComparison.Ordinal);
+ var sclIedName = selectDevice.IndexOf("device.SclIedName", StringComparison.Ordinal);
+ var displayName = selectDevice.IndexOf("device.Name", StringComparison.Ordinal);
+ var ipAddress = selectDevice.IndexOf("device.IpAddress", StringComparison.Ordinal);
+ Assert.True(deviceId >= 0, "Engineering DeviceId must be the strongest view identity.");
+ Assert.True(sclIedName > deviceId, "SCL IED identity must follow DeviceId fallback.");
+ Assert.True(displayName > sclIedName, "Engineering display name must be weaker than SCL identity.");
+ Assert.True(ipAddress > displayName, "IP address must be the final view-binding fallback.");
+ }
+
+ [Fact]
+ public void EvidenceActions_ResolveOwningActiveController_NotCurrentView()
+ {
+ var coordinator = Read("Services/IoTesting/IoTestMultiSessionCoordinator.cs");
+
+ Assert.Contains("ResolveOwningActiveController", coordinator, StringComparison.Ordinal);
+ Assert.Contains("points.Any(ied.TestPoints.Contains)", coordinator, StringComparison.Ordinal);
+ Assert.Contains("points.Any(point => !owners[0].TestPoints.Contains(point))", coordinator, StringComparison.Ordinal);
+ Assert.Contains("_controllers.TryGetValue(owners[0], out var controller)", coordinator, StringComparison.Ordinal);
+ Assert.Contains("!controller.IsSessionActive", coordinator, StringComparison.Ordinal);
+ }
+
+ private static string MethodBody(string source, string startMarker, string nextMarker)
+ {
+ var start = source.IndexOf(startMarker, StringComparison.Ordinal);
+ Assert.True(start >= 0, $"Missing method marker: {startMarker}");
+ var end = source.IndexOf(nextMarker, start + startMarker.Length, StringComparison.Ordinal);
+ Assert.True(end > start, $"Missing following method marker: {nextMarker}");
+ return source[start..end];
+ }
+
+ private static string Read(string relativePath)
+ => File.ReadAllText(Path.Combine(FindRepoRoot(), relativePath))
+ .Replace("\r\n", "\n", StringComparison.Ordinal);
+
+ private static string FindRepoRoot()
+ {
+ DirectoryInfo? directory = new(AppContext.BaseDirectory);
+ while (directory != null)
+ {
+ if (File.Exists(Path.Combine(directory.FullName, "MainWindow.xaml")) &&
+ Directory.Exists(Path.Combine(directory.FullName, "tests", "ARSAS.Tests")))
+ return directory.FullName;
+ directory = directory.Parent;
+ }
+
+ throw new DirectoryNotFoundException("Could not locate repository root.");
+ }
+}
diff --git a/tests/ARSAS.Tests/ProductionFatM6ReportPreviewRegressionTests.cs b/tests/ARSAS.Tests/ProductionFatM6ReportPreviewRegressionTests.cs
new file mode 100644
index 000000000..2da47482c
--- /dev/null
+++ b/tests/ARSAS.Tests/ProductionFatM6ReportPreviewRegressionTests.cs
@@ -0,0 +1,130 @@
+namespace ARSAS.Tests;
+
+public sealed class ProductionFatM6ReportPreviewRegressionTests
+{
+ [Fact]
+ public void EmbeddedFat_UsesExactProductionPreviewInsideTheSameCenter()
+ {
+ var xaml = File.ReadAllText(FindRepoFile("IoListTestingWindow.xaml"));
+ var embedded = File.ReadAllText(FindRepoFile("IoListTestingWindow.EmbeddedEngineeringHost.cs"));
+ var preview = File.ReadAllText(FindRepoFile("IoListTestingWindow.PrintPreview.cs"));
+ var productionTab = File.ReadAllText(FindRepoFile("MainWindow.ProductionFatTab.cs"));
+
+ Assert.Contains("x:Name=\"WorkspacePreviewToggle\"", xaml, StringComparison.Ordinal);
+ Assert.Contains("Content=\"Print Preview\"", xaml, StringComparison.Ordinal);
+ Assert.Contains("Click=\"TogglePrintPreview_Click\"", xaml, StringComparison.Ordinal);
+
+ Assert.Contains("InstallPerIedPrintPreview();", embedded, StringComparison.Ordinal);
+ Assert.Contains("_printPreviewToggle = WorkspacePreviewToggle;", embedded, StringComparison.Ordinal);
+ Assert.Contains("DetachProductionFatCentralWorkspace", embedded, StringComparison.Ordinal);
+
+ // MainWindow hosts the exact detached production center in the canonical XAML FAT tab.
+ // Explorer and Command Dock remain owned by the workstation shell; preview never
+ // replaces MainWindow itself and no retired native FAT tab authority is recreated.
+ Assert.Contains("NativeFatTab.Content = surface;", productionTab, StringComparison.Ordinal);
+ Assert.DoesNotContain("_nativeFatTab.Content = surface;", productionTab, StringComparison.Ordinal);
+ Assert.Contains("global Engineering IED Explorer and shared Command Dock remain authoritative", productionTab, StringComparison.Ordinal);
+
+ var install = ExtractMethod(preview, "private void InstallPerIedPrintPreview()");
+ Assert.Contains("_signalWorkspaceGrid = workspaceGrid.Children.OfType().FirstOrDefault();", install, StringComparison.Ordinal);
+ Assert.Contains("_printPreviewHost = BuildPrintPreviewHost();", install, StringComparison.Ordinal);
+ Assert.Contains("workspaceGrid.Children.Add(_printPreviewHost);", install, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void PreviewToggle_PreservesTheExactProductionGridInstanceAndCaptureSession()
+ {
+ var source = File.ReadAllText(FindRepoFile("IoListTestingWindow.PrintPreview.cs"));
+ var toggle = ExtractMethod(source, "private void TogglePrintPreview_Click(object sender, RoutedEventArgs e)");
+
+ Assert.Contains("_signalWorkspaceGrid.Visibility = _printPreviewActive ? Visibility.Collapsed : Visibility.Visible;", toggle, StringComparison.Ordinal);
+ Assert.Contains("_printPreviewHost.Visibility = _printPreviewActive ? Visibility.Visible : Visibility.Collapsed;", toggle, StringComparison.Ordinal);
+ Assert.Contains("RefreshPrintPreview();", toggle, StringComparison.Ordinal);
+
+ // M6 is an in-place view switch. Recreating the grid would lose scroll/selection,
+ // while touching session lifecycle here could redirect or interrupt an active capture.
+ Assert.DoesNotContain("new DataGrid", toggle, StringComparison.Ordinal);
+ Assert.DoesNotContain("Session.Stop", toggle, StringComparison.Ordinal);
+ Assert.DoesNotContain("Session.Pause", toggle, StringComparison.Ordinal);
+ Assert.DoesNotContain("Session.Resume", toggle, StringComparison.Ordinal);
+ Assert.DoesNotContain("Cancel", toggle, StringComparison.Ordinal);
+ Assert.DoesNotContain("Dispose", toggle, StringComparison.Ordinal);
+ Assert.DoesNotContain("Show()", toggle, StringComparison.Ordinal);
+ Assert.DoesNotContain("ShowDialog", toggle, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void PreviewAndNativePdf_ShareOneReportLayoutAuthority()
+ {
+ var preview = File.ReadAllText(FindRepoFile("IoListTestingWindow.PrintPreview.cs"));
+ var documentBuilder = File.ReadAllText(FindRepoFile("Services/IoTesting/IoFatReportPreviewDocumentBuilder.cs"));
+ var pdf = File.ReadAllText(FindRepoFile("Services/IoTesting/IoFatPdfReportService.cs"));
+
+ var refresh = ExtractMethod(preview, "private void RefreshPrintPreview()");
+ Assert.Contains("IoFatReportPreviewService.CreateIedScopedProject(Project, SelectedIed)", refresh, StringComparison.Ordinal);
+ Assert.Contains("IoFatReportPreviewDocumentBuilder.Build(scopedProject, draft)", refresh, StringComparison.Ordinal);
+ Assert.Contains("Session.IsSessionActive && ReferenceEquals(Session.ActiveIed, SelectedIed)", refresh, StringComparison.Ordinal);
+
+ Assert.Contains("IoFatPdfReportService.BuildLayout(project, generatedAt, draft)", documentBuilder, StringComparison.Ordinal);
+ Assert.Contains("var layout = BuildLayout(project, generatedAt, draft: false);", pdf, StringComparison.Ordinal);
+ Assert.Contains("IoFatNativePdfWriter.Build(layout, project)", pdf, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void ActivePreview_TracksViewedIedAndEvidenceWithoutStoppingCapture()
+ {
+ var source = File.ReadAllText(FindRepoFile("IoListTestingWindow.PrintPreview.cs"));
+
+ Assert.Contains("_printPreviewActive && e.PropertyName == nameof(SelectedIed)", source, StringComparison.Ordinal);
+ Assert.Contains("e.PropertyName is nameof(Session.State) or nameof(Session.EvidenceRecordCount)", source, StringComparison.Ordinal);
+ Assert.Contains("Dispatcher.BeginInvoke(DispatcherPriority.Background, RefreshPrintPreview)", source, StringComparison.Ordinal);
+ }
+
+ private static string ExtractMethod(string source, string signature)
+ {
+ var start = source.IndexOf(signature, StringComparison.Ordinal);
+ Assert.True(start >= 0, $"Could not find method '{signature}'.");
+
+ var openBrace = source.IndexOf('{', start);
+ Assert.True(openBrace >= 0, $"Could not find opening brace for '{signature}'.");
+
+ var depth = 0;
+ for (var index = openBrace; index < source.Length; index++)
+ {
+ switch (source[index])
+ {
+ case '{':
+ depth++;
+ break;
+ case '}':
+ depth--;
+ if (depth == 0)
+ return source[start..(index + 1)];
+ break;
+ }
+ }
+
+ throw new InvalidDataException($"Method '{signature}' has no balanced closing brace.");
+ }
+
+ private static string FindRepoFile(string relativePath)
+ => Path.Combine(FindRepoRoot(), relativePath);
+
+ private static string FindRepoRoot()
+ {
+ DirectoryInfo? directory = new(AppContext.BaseDirectory);
+ while (directory != null)
+ {
+ if (File.Exists(Path.Combine(directory.FullName, "MainWindow.xaml")) &&
+ Directory.Exists(Path.Combine(directory.FullName, "tests", "ARSAS.Tests")))
+ {
+ return directory.FullName;
+ }
+
+ directory = directory.Parent;
+ }
+
+ throw new DirectoryNotFoundException(
+ $"Could not locate repository root from '{AppContext.BaseDirectory}'.");
+ }
+}
diff --git a/tests/ARSAS.Tests/ProductionFatM7CleanupRegressionTests.cs b/tests/ARSAS.Tests/ProductionFatM7CleanupRegressionTests.cs
new file mode 100644
index 000000000..f0e993000
--- /dev/null
+++ b/tests/ARSAS.Tests/ProductionFatM7CleanupRegressionTests.cs
@@ -0,0 +1,103 @@
+namespace ARSAS.Tests;
+
+public sealed class ProductionFatM7CleanupRegressionTests
+{
+ [Fact]
+ public void ObsoleteNativeFatRuntime_IsNotASecondProductionAuthority()
+ {
+ var repoRoot = FindRepoRoot();
+ var bridge = File.ReadAllText(Path.Combine(repoRoot, "MainWindow.NativeFatWorkspace.cs"));
+ var productionTab = File.ReadAllText(Path.Combine(repoRoot, "MainWindow.ProductionFatTab.cs"));
+
+ Assert.False(
+ File.Exists(Path.Combine(repoRoot, "MainWindow.NativeFatExport.cs")),
+ "The retired native FAT export must not return; production FAT owns report/export delivery.");
+ Assert.False(
+ File.Exists(Path.Combine(repoRoot, "MainWindow.NativeFatReportPreview.cs")),
+ "The retired native FAT side-panel preview must not return. Production FAT owns one in-place report preview.");
+ Assert.False(
+ File.Exists(Path.Combine(repoRoot, "MainWindow.NativeFatHistoryInspector.cs")),
+ "The retired side-panel history inspector must not return as a second FAT presentation stack.");
+ Assert.False(
+ File.Exists(Path.Combine(repoRoot, "MainWindow.NativeFatExplorerSync.cs")),
+ "The retired native FAT Explorer reconciler must not return; Engineering selection and production FAT own synchronization.");
+ Assert.False(
+ File.Exists(Path.Combine(repoRoot, "MainWindow.NativeFatPersistenceSafety.cs")),
+ "The retired native FAT persistence runtime must not return; production FAT storage remains the persistence authority.");
+
+ // MainWindow.NativeFatWorkspace.cs is now only a compatibility bridge for the
+ // canonical seventh shell slot. It must never regain its own FAT runtime/state.
+ Assert.Contains("private const int NativeFatWorkspaceIndex = 6", bridge, StringComparison.Ordinal);
+ Assert.Contains("QueueNativeFatNavigationGeometry", bridge, StringComparison.Ordinal);
+ Assert.DoesNotContain("DataGrid", bridge, StringComparison.Ordinal);
+ Assert.DoesNotContain("DispatcherTimer", bridge, StringComparison.Ordinal);
+ Assert.DoesNotContain("NativeFatStateStore", bridge, StringComparison.Ordinal);
+ Assert.DoesNotContain("NativeFatSignalRow", bridge, StringComparison.Ordinal);
+ Assert.DoesNotContain("NativeFatCapture", bridge, StringComparison.Ordinal);
+ Assert.DoesNotContain("SaveNativeFatStateAsync", bridge, StringComparison.Ordinal);
+ Assert.DoesNotContain("BuildNativeFatWorkspaceContent", bridge, StringComparison.Ordinal);
+ Assert.DoesNotContain("RegisterNativeFatWorkspace", bridge, StringComparison.Ordinal);
+
+ // Production FAT mounts directly into the canonical XAML slot. There must be no
+ // compatibility-field handshake with the retired native runtime.
+ Assert.Contains("NativeFatTab.Content = BuildProductionFatPermanentHost();", productionTab, StringComparison.Ordinal);
+ Assert.Contains("NativeFatTab.Content = surface;", productionTab, StringComparison.Ordinal);
+ Assert.Contains("NavNativeFatButton.ToolTip", productionTab, StringComparison.Ordinal);
+ Assert.DoesNotContain("_nativeFatInstalled", productionTab, StringComparison.Ordinal);
+ Assert.DoesNotContain("_nativeFatTab", productionTab, StringComparison.Ordinal);
+ Assert.DoesNotContain("_nativeFatNavButton", productionTab, StringComparison.Ordinal);
+ Assert.DoesNotContain("AttachNativeFatObservedDevice", productionTab, StringComparison.Ordinal);
+ Assert.DoesNotContain("NativeFat_MainWindowPropertyChanged", productionTab, StringComparison.Ordinal);
+ Assert.DoesNotContain("NativeFat_MainTabsSelectionChanged", productionTab, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void ProductionReportPreviewAndExport_RemainSingleAuthority()
+ {
+ var repoRoot = FindRepoRoot();
+ var productionPreview = File.ReadAllText(Path.Combine(repoRoot, "IoListTestingWindow.PrintPreview.cs"));
+ var embeddedHost = File.ReadAllText(Path.Combine(repoRoot, "IoListTestingWindow.EmbeddedEngineeringHost.cs"));
+ var pdfService = File.ReadAllText(Path.Combine(repoRoot, "Services", "IoTesting", "IoFatPdfReportService.cs"));
+
+ Assert.Contains("BuildPrintPreviewHost", productionPreview, StringComparison.Ordinal);
+ Assert.Contains("IoFatReportPreviewDocumentBuilder.Build(scopedProject, draft)", productionPreview, StringComparison.Ordinal);
+ Assert.Contains("InstallPerIedPrintPreview();", embeddedHost, StringComparison.Ordinal);
+ Assert.Contains("_printPreviewToggle = WorkspacePreviewToggle;", embeddedHost, StringComparison.Ordinal);
+ Assert.Contains("BuildLayout", pdfService, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void Cleanup_DoesNotRetireProductionCapturePreflightOrEngineeringAcquisitionAuthority()
+ {
+ var bootstrap = File.ReadAllText(FindRepoFile("MainWindow.ProductionFatEngineeringBootstrap.cs"));
+ var adapter = File.ReadAllText(FindRepoFile("Services/IoTesting/IoFatProductionControllerAdapter.cs"));
+ var contract = File.ReadAllText(FindRepoFile("docs/FAT_ENGINEERING_WORKSTATION_CONTRACT.md"));
+
+ Assert.Contains("AdoptEngineeringRuntimeWorkspaces", bootstrap, StringComparison.Ordinal);
+ Assert.Contains("IoTestSessionPreflight.Validate", adapter, StringComparison.Ordinal);
+ Assert.Contains("IoFatProductionControllerAdapter", adapter, StringComparison.Ordinal);
+ Assert.Contains("production FAT", contract, StringComparison.OrdinalIgnoreCase);
+ Assert.Contains("Engineering", contract, StringComparison.OrdinalIgnoreCase);
+ }
+
+ private static string FindRepoFile(string relativePath)
+ => Path.Combine(FindRepoRoot(), relativePath);
+
+ private static string FindRepoRoot()
+ {
+ DirectoryInfo? directory = new(AppContext.BaseDirectory);
+ while (directory != null)
+ {
+ if (File.Exists(Path.Combine(directory.FullName, "MainWindow.xaml")) &&
+ Directory.Exists(Path.Combine(directory.FullName, "tests", "ARSAS.Tests")))
+ {
+ return directory.FullName;
+ }
+
+ directory = directory.Parent;
+ }
+
+ throw new DirectoryNotFoundException(
+ $"Could not locate repository root from '{AppContext.BaseDirectory}'.");
+ }
+}
diff --git a/tests/ARSAS.Tests/ProductionFatP0FieldRegressionTests.cs b/tests/ARSAS.Tests/ProductionFatP0FieldRegressionTests.cs
new file mode 100644
index 000000000..6b6beeff0
--- /dev/null
+++ b/tests/ARSAS.Tests/ProductionFatP0FieldRegressionTests.cs
@@ -0,0 +1,162 @@
+using ArIED61850Tester.Models.IoTesting;
+using ArIED61850Tester.Services.IoTesting;
+
+namespace ARSAS.Tests;
+
+public sealed class ProductionFatP0FieldRegressionTests
+{
+ [Fact]
+ public void AutomaticStaticDataSetScope_RetiresManualAliasBeforeSessionPreflight()
+ {
+ const string staticReference = "AA1E1F06R4V1T3p1_OperationalValues/RPRE_MMXU1.A.phsA";
+ const string primaryLiveLeaf = "AA1E1F06R4V1T3p1_OperationalValues/RPRE_MMXU1.A.phsA.cVal.mag.f";
+
+ var staticPoint = StaticPoint(staticReference);
+ var manualAlias = ManualPoint(primaryLiveLeaf);
+ staticPoint.ApplyLiveBinding(
+ IoTestLiveBindingState.LivePointReady,
+ "regression live binding",
+ "device-1",
+ primaryLiveLeaf);
+ manualAlias.ApplyLiveBinding(
+ IoTestLiveBindingState.LivePointReady,
+ "regression live binding",
+ "device-1",
+ primaryLiveLeaf);
+
+ var ied = Ied(staticPoint, manualAlias);
+ var blocked = IoTestSessionPreflight.Validate(ied);
+ Assert.False(blocked.Succeeded);
+ Assert.Contains("multiple enabled test points", blocked.Message, StringComparison.OrdinalIgnoreCase);
+
+ var retired = IoFatEngineeringSelectionBridge.RetireManualWorkspaceRowsForStaticDataSetMode(ied);
+
+ Assert.Equal(1, retired);
+ Assert.True(staticPoint.WorkspaceSelected);
+ Assert.False(manualAlias.WorkspaceSelected);
+ Assert.True(manualAlias.TestEnabled);
+ Assert.True(manualAlias.IsIncludedInFat);
+ Assert.Equal(primaryLiveLeaf, manualAlias.LiveSignalReference);
+
+ var ready = IoTestSessionPreflight.Validate(ied);
+ Assert.True(ready.Succeeded, ready.Message);
+ }
+
+ [Fact]
+ public void StaticDataSetModeCleanup_DoesNotTouchManualOnlyProjects()
+ {
+ var manual = ManualPoint("AA1E1F06R4LD0/GGIO1.Ind1.stVal");
+ var ied = Ied(manual);
+
+ var retired = IoFatEngineeringSelectionBridge.RetireManualWorkspaceRowsForStaticDataSetMode(ied);
+
+ Assert.Equal(0, retired);
+ Assert.True(manual.WorkspaceSelected);
+ Assert.True(manual.TestEnabled);
+ Assert.True(manual.IsIncludedInFat);
+ }
+
+ [Fact]
+ public void EngineeringBootstrap_AppliesStaticCleanupBeforeProductionWindowIsShown()
+ {
+ var source = Read("MainWindow.ProductionFatEngineeringBootstrap.cs");
+ var synchronize = source.IndexOf("SynchronizeImportedSclFatWithEngineering(launch.Project);", StringComparison.Ordinal);
+ var retire = source.IndexOf("RetireManualWorkspaceRowsForStaticDataSetMode", StringComparison.Ordinal);
+ var show = source.IndexOf("await ShowIoTestingWorkspaceAsync(launch, importWarningCount: 0);", StringComparison.Ordinal);
+
+ Assert.True(synchronize >= 0, "Engineering/FAT synchronization call is missing.");
+ Assert.True(retire > synchronize, "Static DataSet cleanup must happen after shared selection synchronization so newly-created manual aliases are also retired.");
+ Assert.True(show > retire, "Static DataSet cleanup must complete before the production FAT workspace/session can be exposed.");
+ }
+
+ [Fact]
+ public void EmbeddedAutomaticBootstrap_NeverHidesEngineeringWindow()
+ {
+ var source = Read("MainWindow.ProductionFatNoFlicker.cs");
+
+ Assert.Contains("public new void Hide()", source, StringComparison.Ordinal);
+ Assert.Contains("ShouldKeepEngineeringVisibleDuringProductionFatBootstrap", source, StringComparison.Ordinal);
+ Assert.Contains("_productionFatEngineeringBootstrapBusy", source, StringComparison.Ordinal);
+ Assert.Contains("ProductionFatTabReady", source, StringComparison.Ordinal);
+ Assert.DoesNotContain("MainTabs.SelectedIndex == NativeFatWorkspaceIndex", source, StringComparison.Ordinal);
+ Assert.Contains("base.Hide();", source, StringComparison.Ordinal);
+ }
+
+ private static IoTestPointPlan StaticPoint(string staticReference)
+ => new()
+ {
+ TestPointId = "scl-static-fat-member",
+ IedName = "AA1E1F06R4",
+ IpAddress = "192.168.81.103",
+ SignalName = "A PhsA",
+ ObjectReference = staticReference,
+ FunctionalConstraint = "MX",
+ ExpectedOnText = "Value 1",
+ ExpectedOffText = "Value 2",
+ DataType = "FLOAT32",
+ SignalAddress = "source-sha",
+ DataSetName = "AA1E1F06R4LD0/LLN0.OperationalValues",
+ SourceIecReference = staticReference,
+ ReportDisplayReference = staticReference,
+ EventLogSearchReference = staticReference,
+ SourceRow = 1,
+ SignalKind = FatSignalKind.Analog,
+ CaptureMode = FatCaptureMode.OperatorSnapshot,
+ WorkspaceSelected = true,
+ TestEnabled = true,
+ ImportReady = true,
+ BindingStatus = IoTestSignalSelectionService.SclDataSetAuthorityBindingStatus,
+ BindingEvidence = "Static SCL DataSet authority"
+ };
+
+ private static IoTestPointPlan ManualPoint(string runtimeReference)
+ => new()
+ {
+ TestPointId = "scl-manual-8498597f6ee9a39943c0",
+ IedName = "AA1E1F06R4",
+ IpAddress = "192.168.81.103",
+ SignalName = "A PhsA scalar alias",
+ ObjectReference = runtimeReference,
+ FunctionalConstraint = "MX",
+ ExpectedOnText = "Value 1",
+ ExpectedOffText = "Value 2",
+ DataType = "FLOAT32",
+ SignalAddress = "source-sha",
+ SourceIecReference = runtimeReference,
+ ReportDisplayReference = runtimeReference,
+ EventLogSearchReference = runtimeReference,
+ SignalKind = FatSignalKind.Analog,
+ CaptureMode = FatCaptureMode.OperatorSnapshot,
+ WorkspaceSelected = true,
+ TestEnabled = true,
+ ImportReady = true,
+ BindingStatus = IoTestSignalSelectionService.SclWorkspaceAuthorityBindingStatus,
+ BindingEvidence = "Shared SCL workspace authority"
+ };
+
+ private static IoTestIedPlan Ied(params IoTestPointPlan[] points)
+ => new()
+ {
+ IedName = "AA1E1F06R4",
+ IpAddress = "192.168.81.103",
+ TestPoints = points.ToList()
+ };
+
+ private static string Read(string relativePath)
+ => File.ReadAllText(FindRepoFile(relativePath)).Replace("\r\n", "\n", StringComparison.Ordinal);
+
+ private static string FindRepoFile(string relativePath)
+ {
+ DirectoryInfo? directory = new(AppContext.BaseDirectory);
+ while (directory != null)
+ {
+ var candidate = Path.Combine(directory.FullName, relativePath);
+ if (File.Exists(candidate))
+ return candidate;
+ directory = directory.Parent;
+ }
+
+ throw new FileNotFoundException(
+ $"Could not locate repository file '{relativePath}' from '{AppContext.BaseDirectory}'.");
+ }
+}