Merge commit '5135a036' into remed/lane-B

2026-10-22 15:29:36 -04:00
parent a8284f499e 5135a0366e
commit 9c8e70c5b7
117 changed files with 9847 additions and 994 deletions
@@ -57,10 +57,11 @@ public class PageAuthorizationGuardTests
        //    AddSecretsAuthorization(). ──
        [typeof(SecretsAdmin)] = global::ZB.MOM.WW.Secrets.Ui.SecretsAuthorization.ManagePolicy,

-        // ── AuthenticatedRead (16): dashboards, lists, live tails (read-only) + the dev ContextMenu demo ──
+        // ── AuthenticatedRead (17): dashboards, lists, live tails (read-only) + the dev ContextMenu demo ──
        [typeof(Home)] = AdminUiPolicies.AuthenticatedRead,
        [typeof(global::ZB.MOM.WW.OtOpcUa.AdminUI.Components.Pages.Dev.ContextMenuDemo)] = AdminUiPolicies.AuthenticatedRead,
        [typeof(Fleet)] = AdminUiPolicies.AuthenticatedRead,
+        [typeof(global::ZB.MOM.WW.OtOpcUa.AdminUI.Components.Pages.FleetDiagnostics)] = AdminUiPolicies.AuthenticatedRead,
        [typeof(global::ZB.MOM.WW.OtOpcUa.AdminUI.Components.Pages.Hosts)] = AdminUiPolicies.AuthenticatedRead,
        [typeof(Alerts)] = AdminUiPolicies.AuthenticatedRead,
        [typeof(ScriptLog)] = AdminUiPolicies.AuthenticatedRead,
@@ -18,6 +18,7 @@ public sealed class CompletionTests
        labels.ShouldContain("SetVirtualTag");
        labels.ShouldContain("Now");
        labels.ShouldContain("Logger");
+        labels.ShouldContain("CancellationToken");
    }

    [Fact] public async Task Scope_completion_includes_the_ctx_local()
@@ -48,6 +48,7 @@ public sealed class DiagnoseTests
    [InlineData("""var x = 41; System.Threading.Interlocked.Increment(ref x); return x;""")]
    [InlineData("""var x = 42; return System.Threading.Volatile.Read(ref x);""")]
    [InlineData("""object o = 42; return o.GetType().IsValueType ? 1 : 0;""")]
+    [InlineData("""ctx.CancellationToken.ThrowIfCancellationRequested(); return ctx.CancellationToken.IsCancellationRequested ? 1 : 0;""")]
    public void Allow_listed_forms_are_not_flagged_in_the_editor(string code)
        => Diag(code).ShouldBeEmpty();

@@ -169,4 +169,26 @@ public sealed class FocasTagConfigModelTests
    [InlineData("""{"address":"R100","dataType":2}""")]
    public void Validate_accepts_every_dataType_the_driver_accepts(string json)
        => FocasTagConfigModel.FromJson(json).Validate().ShouldBeNull();
+
+    /// <summary>
+    ///     #740 / R07:U8 — String on a PMC / PARAM / MACRO address is refused by the driver (no area read
+    ///     returns text), so the modal refuses it too, for a model built in the editor and for a loaded blob.
+    /// </summary>
+    [Theory]
+    [InlineData("R100")]
+    [InlineData("PARAM:6711")]
+    [InlineData("MACRO:500")]
+    public void Validate_refuses_string_on_an_area_address(string address)
+    {
+        new FocasTagConfigModel { Address = address, DataType = FocasDataType.String }
+            .Validate().ShouldNotBeNull().ShouldContain("String");
+        FocasTagConfigModel.FromJson($$"""{"address":"{{address}}","dataType":"String"}""")
+            .Validate().ShouldNotBeNull().ShouldContain("String");
+    }
+
+    /// <summary>Positive control: the fixed tree's string fields keep String.</summary>
+    [Fact]
+    public void Validate_accepts_string_on_a_fixed_tree_path()
+        => new FocasTagConfigModel { Address = "FIXED:Identity/SeriesNumber", DataType = FocasDataType.String }
+            .Validate().ShouldBeNull();
 }
@@ -0,0 +1,64 @@
+using Microsoft.Extensions.Configuration;
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Core.Scripting;
+using ZB.MOM.WW.OtOpcUa.Host.Configuration;
+
+namespace ZB.MOM.WW.OtOpcUa.Host.Tests.Configuration;
+
+/// <summary>
+///     Review m-1: the <c>Scripting</c> section binds by the documented key names and is clamped at bind. Each
+///     configured value differs from the compiled default, so a misspelled key (which the binder would silently
+///     ignore, falling back to the default) goes red.
+/// </summary>
+public sealed class ScriptingOptionsBindingTests
+{
+    private static IConfiguration Config(Dictionary<string, string?> values) =>
+        new ConfigurationBuilder().AddInMemoryCollection(values).Build();
+
+    [Fact]
+    public void Every_documented_key_binds_to_its_property()
+    {
+        var bound = ScriptingOptionsBinding.Bind(Config(new()
+        {
+            ["Scripting:MaxAllocBytesPerRun"] = "8388608",
+            ["Scripting:QuarantineAfterConsecutiveTimeouts"] = "7",
+            ["Scripting:StuckOrphanQuarantineFactor"] = "4.5",
+            // Sibling keys owned by the script-log pipeline must not disturb the bind.
+            ["Scripting:LogFilePath"] = "logs/x-.log",
+            ["Scripting:LogTopicMinLevel"] = "Warning",
+        }), out var adjustments);
+
+        adjustments.ShouldBeEmpty();
+        bound.MaxAllocBytesPerRun.ShouldBe(8L * 1024 * 1024);
+        bound.QuarantineAfterConsecutiveTimeouts.ShouldBe(7);
+        bound.StuckOrphanQuarantineFactor.ShouldBe(4.5);
+    }
+
+    [Fact]
+    public void Out_of_range_values_are_clamped_at_bind_and_reported()
+    {
+        var bound = ScriptingOptionsBinding.Bind(Config(new()
+        {
+            ["Scripting:StuckOrphanQuarantineFactor"] = "1e300",
+            ["Scripting:MaxAllocBytesPerRun"] = "1024",
+            ["Scripting:QuarantineAfterConsecutiveTimeouts"] = "0",
+        }), out var adjustments);
+
+        bound.StuckOrphanQuarantineFactor.ShouldBe(ScriptingOptions.MaxStuckOrphanQuarantineFactor);
+        bound.MaxAllocBytesPerRun.ShouldBe(ScriptingOptions.MinMaxAllocBytesPerRun);
+        bound.QuarantineAfterConsecutiveTimeouts.ShouldBe(1);
+        adjustments.Count.ShouldBe(3);
+    }
+
+    [Fact]
+    public void An_absent_section_yields_the_compiled_defaults()
+    {
+        var bound = ScriptingOptionsBinding.Bind(Config(new()), out var adjustments);
+
+        adjustments.ShouldBeEmpty();
+        bound.MaxAllocBytesPerRun.ShouldBe(ScriptingOptions.DefaultMaxAllocBytesPerRun);
+        bound.QuarantineAfterConsecutiveTimeouts.ShouldBe(ScriptingOptions.DefaultQuarantineAfterConsecutiveTimeouts);
+        bound.StuckOrphanQuarantineFactor.ShouldBe(ScriptingOptions.DefaultStuckOrphanQuarantineFactor);
+    }
+}
@@ -0,0 +1,103 @@
+using System.Text.Json;
+using Akka.Actor;
+using Serilog;
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Commons.Engines;
+using ZB.MOM.WW.OtOpcUa.Commons.OpcUa;
+using ZB.MOM.WW.OtOpcUa.Commons.Types;
+using ZB.MOM.WW.OtOpcUa.Configuration.Entities;
+using ZB.MOM.WW.OtOpcUa.Configuration.Enums;
+using ZB.MOM.WW.OtOpcUa.Core.ScriptedAlarms;
+using ZB.MOM.WW.OtOpcUa.Core.Scripting;
+using ZB.MOM.WW.OtOpcUa.Runtime.Drivers;
+using ZB.MOM.WW.OtOpcUa.Runtime.OpcUa;
+using ZB.MOM.WW.OtOpcUa.Runtime.Tests.Harness;
+using ZB.MOM.WW.OtOpcUa.Runtime.VirtualTags;
+
+namespace ZB.MOM.WW.OtOpcUa.Runtime.Tests.Drivers;
+
+/// <summary>
+///     Review I-2: under the factory Props a supervision restart of the scripted-alarm host builds a fresh, EMPTY
+///     engine. Nothing re-sent <c>ApplyScriptedAlarms</c>, so until the next deploy the host had no mux interest
+///     (inputs stopped) and its ownership filter dropped every operator ack/shelve as "not owned". The host now
+///     tells its parent <see cref="ScriptedAlarms.ScriptedAlarmHostActor.ScriptedAlarmHostRestarted"/> from <c>PostRestart</c>,
+///     and <see cref="DriverHostActor"/> re-sends the last plans it applied. This test never re-applies by hand.
+/// </summary>
+public sealed class DriverHostActorScriptedAlarmRestartTests : RuntimeActorTestBase
+{
+    private static readonly NodeId TestNode = NodeId.Parse("driver-alarmhost-restart-test");
+    private static readonly RevisionHash RevA = RevisionHash.Parse(new string('d', 64));
+    private static readonly TimeSpan Timeout = TimeSpan.FromSeconds(30);
+
+    private static DeploymentId SeedAlarmDeployment(Microsoft.EntityFrameworkCore.IDbContextFactory<ZB.MOM.WW.OtOpcUa.Configuration.OtOpcUaConfigDbContext> db)
+    {
+        var artifact = JsonSerializer.SerializeToUtf8Bytes(new
+        {
+            ScriptedAlarms = new[]
+            {
+                new
+                {
+                    ScriptedAlarmId = "alm-1", EquipmentId = "eq-1", Name = "HighTemp", AlarmType = "AlarmCondition",
+                    Severity = 800, MessageTemplate = "hot", PredicateScriptId = "s-1",
+                    HistorizeToAveva = false, Retain = true, Enabled = true,
+                },
+            },
+            Scripts = new[] { new { ScriptId = "s-1", SourceCode = "return (int)ctx.GetTag(\"M.T\").Value > 90;" } },
+        });
+        var id = DeploymentId.NewId();
+        using var ctx = db.CreateDbContext();
+        ctx.Deployments.Add(new Deployment
+        {
+            DeploymentId = id.Value, RevisionHash = RevA.Value, Status = DeploymentStatus.Sealed,
+            CreatedBy = "test", SealedAtUtc = DateTime.UtcNow, ArtifactBlob = artifact,
+        });
+        ctx.SaveChanges();
+        return id;
+    }
+
+    [Fact]
+    public void After_a_supervision_restart_the_alarm_host_is_re_applied_and_inputs_and_acks_work_again()
+    {
+        var db = NewInMemoryDbFactory();
+        var deploymentId = SeedAlarmDeployment(db);
+        var publish = this.CreateCleanOutcomePublishProbe();
+        var mux = CreateTestProbe();
+        var coordinator = CreateTestProbe();
+        var host = Sys.ActorOf(DriverHostActor.Props(
+            db, TestNode, coordinator.Ref,
+            localRoles: new HashSet<string> { "driver" },
+            dependencyMux: mux.Ref,
+            opcUaPublishActor: publish.Ref,
+            virtualTagEvaluator: NullVirtualTagEvaluator.Instance,
+            virtualTagHostOverride: CreateTestProbe().Ref,
+            scriptRootLogger: new ScriptRootLogger(new LoggerConfiguration().CreateLogger()),
+            alarmStateStore: new InMemoryAlarmStateStore()));
+        V3ArtifactSeeder.Dispatch(host, coordinator, deploymentId, RevA);
+
+        var first = mux.FishForMessage<DependencyMuxActor.RegisterInterest>(r => r.TagRefs.Contains("M.T"), Timeout);
+        var alarmHost = first.Subscriber;
+
+        // The crash: a batch item with a null TagId makes the upstream Push throw (the documented unguarded
+        // path), so supervision restarts the alarm host. NO manual re-apply follows.
+        alarmHost.Tell(new VirtualTagActor.DependencyValueBatch(new[]
+        {
+            new VirtualTagActor.DependencyValueChanged(null!, 1, DateTime.UtcNow),
+        }));
+        mux.FishForMessage<DependencyMuxActor.UnregisterInterest>(u => u.Subscriber.Equals(alarmHost), Timeout);
+
+        // The parent re-applies on the restart signal: interest is registered again by the new incarnation.
+        mux.FishForMessage<DependencyMuxActor.RegisterInterest>(r => r.TagRefs.Contains("M.T"), Timeout);
+
+        // Inputs work: a dependency push activates the alarm.
+        alarmHost.Tell(new VirtualTagActor.DependencyValueChanged("M.T", 99, DateTime.UtcNow));
+        publish.FishForMessage<OpcUaPublishActor.AlarmStateUpdate>(
+            m => m.AlarmNodeId == "alm-1" && m.State.Active && !m.State.Acknowledged, Timeout);
+
+        // Acks work: the restarted engine owns alm-1 again, so the command is not filtered out as unowned.
+        alarmHost.Tell(new AlarmCommand(AlarmId: "alm-1", Operation: "Acknowledge", User: "alice", Comment: null, UnshelveAtUtc: null));
+        publish.FishForMessage<OpcUaPublishActor.AlarmStateUpdate>(
+            m => m.AlarmNodeId == "alm-1" && m.State.Acknowledged, Timeout)
+            .State.Acknowledged.ShouldBeTrue();
+    }
+}
@@ -0,0 +1,224 @@
+using Akka.Actor;
+using Akka.TestKit;
+using Microsoft.EntityFrameworkCore;
+using Shouldly;
+using Xunit;
+using ZB.MOM.WW.OtOpcUa.Commons.Engines;
+using ZB.MOM.WW.OtOpcUa.Commons.Messages.Admin;
+using ZB.MOM.WW.OtOpcUa.Commons.OpcUa;
+using ZB.MOM.WW.OtOpcUa.Commons.Types;
+using ZB.MOM.WW.OtOpcUa.Configuration;
+using ZB.MOM.WW.OtOpcUa.Runtime.Drivers;
+using ZB.MOM.WW.OtOpcUa.Runtime.Tests.Harness;
+using ZB.MOM.WW.OtOpcUa.Runtime.VirtualTags;
+
+namespace ZB.MOM.WW.OtOpcUa.Runtime.Tests.Drivers;
+
+/// <summary>
+///     The dependency mux retains a ref's last value for replay-opting subscribers and evicts a driver's values on
+///     <see cref="DependencyMuxActor.SourceRemoved"/>. Before this, nothing in production sent that message, so a
+///     driver removed by a deploy kept its last Good in the mux and replayed it to the next replay-opting
+///     subscriber as if it were current. The host now sends it wherever a driver OBJECT ends (deploy removal,
+///     config-change respawn, operator Restart), never on a supervision restart, and drops value bursts from the
+///     child incarnations it has already stopped so a late burst cannot re-retain what was evicted. All through a
+///     REAL mux and real driver children.
+/// </summary>
+public sealed class DriverHostActorSourceRemovedTests : RuntimeActorTestBase
+{
+    private static readonly NodeId TestNode = NodeId.Parse("driver-sourceremoved-test");
+    private static readonly RevisionHash RevA = RevisionHash.Parse(new string('a', 64));
+    private static readonly RevisionHash RevB = RevisionHash.Parse(new string('b', 64));
+    private const string Path1 = "Plant/Modbus/dev1/speed";
+    private const string Path2 = "Plant/Modbus2/dev2/flow";
+    private static readonly (string, string, string, string, string?)[] NoRefs = [];
+
+    private static readonly (string Driver, string DriverName, string Device, string Tag, string DataType, bool Writable)[] BothDrivers =
+    [
+        ("DI-1", "Modbus", "dev1", "speed", "Double", false),
+        ("DI-2", "Modbus2", "dev2", "flow", "Double", false),
+    ];
+
+    private IActorRef _host = ActorRefs.Nobody;
+    private IActorRef _mux = ActorRefs.Nobody;
+    private TestProbe _coordinator = null!;
+    private TestProbe _holder = null!;
+    private RecordingSubscribableDriverFactory _factory = null!;
+    private IDbContextFactory<OtOpcUaConfigDbContext> _db = null!;
+
+    /// <summary>Spawns a host over a real mux with two enabled drivers, waits for both children to subscribe,
+    /// registers a replay-opting holder (so the mux retains both refs) and publishes one value per driver.</summary>
+    private void ArrangeTwoDriversWithRetainedValues()
+    {
+        _db = NewInMemoryDbFactory();
+        var revA = V3ArtifactSeeder.SeedV3Deployment(_db, RevA, BothDrivers, NoRefs, enabled: true);
+        _factory = new RecordingSubscribableDriverFactory("Modbus");
+        _mux = Sys.ActorOf(DependencyMuxActor.Props());
+        _coordinator = CreateTestProbe();
+        _holder = CreateTestProbe();
+        _host = Sys.ActorOf(DriverHostActor.Props(
+            _db, TestNode, _coordinator.Ref,
+            driverFactory: _factory,
+            localRoles: new HashSet<string> { "driver" },
+            dependencyMux: _mux,
+            virtualTagEvaluator: NullVirtualTagEvaluator.Instance,
+            virtualTagHostOverride: CreateTestProbe().Ref));
+        V3ArtifactSeeder.Dispatch(_host, _coordinator, revA, RevA);
+        AwaitAssert(() => _factory.Created.Count.ShouldBe(2), PresenceBudget);
+        // The spawn hands a child the PREVIOUS apply's set (empty on the first deploy) and the bulk push then
+        // re-subscribes with the real one; a value fired before that lands is lost, so wait for the real set.
+        AwaitSubscribed("DI-1", Path1);
+        AwaitSubscribed("DI-2", Path2);
+
+        _mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { Path1, Path2 }, _holder.Ref, ReplayRetained: true));
+        Driver("DI-1").FireDataChange(Path1, 11.0);
+        Driver("DI-2").FireDataChange(Path2, 22.0);
+        // One fish for both: the two drivers' bursts arrive in either order, and fishing for one at a time would
+        // discard the other.
+        var pending = new HashSet<string>(StringComparer.Ordinal) { Path1, Path2 };
+        _holder.FishForMessage<VirtualTagActor.DependencyValueBatch>(b =>
+        {
+            foreach (var i in b.Items)
+                if ((i.TagId == Path1 && Equals(i.Value, 11.0)) || (i.TagId == Path2 && Equals(i.Value, 22.0)))
+                    pending.Remove(i.TagId);
+            return pending.Count == 0;
+        }, PresenceBudget);
+    }
+
+    /// <summary>Waits until the holder has been delivered <paramref name="value"/> for <paramref name="path"/>.</summary>
+    private void AwaitHolder(string path, object value) =>
+        _holder.FishForMessage<VirtualTagActor.DependencyValueBatch>(
+            b => b.Items.Any(i => i.TagId == path && Equals(i.Value, value)), PresenceBudget);
+
+    private void AwaitSubscribed(string driverId, string path) =>
+        AwaitAssert(() => (Driver(driverId).LastSubscribedRefs ?? []).ShouldContain(path), PresenceBudget);
+
+    private RecordingSubscribableDriver Driver(string id) => _factory.Created.Last(d => d.DriverInstanceId == id);
+
+    /// <summary>A fresh replay-opting subscriber for both refs; returns what it was replayed, keyed by ref.</summary>
+    private Dictionary<string, VirtualTagActor.DependencyValueChanged> Replayed()
+    {
+        var probe = CreateTestProbe();
+        _mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { Path1, Path2 }, probe.Ref, ReplayRetained: true));
+        return probe.ExpectMsg<VirtualTagActor.DependencyValueBatch>(PresenceBudget)
+            .Items.ToDictionary(i => i.TagId, StringComparer.Ordinal);
+    }
+
+    /// <summary>The live child actor for <paramref name="driverId"/> (named <c>drv-{id}-g{generation}</c>).</summary>
+    private IActorRef ChildOf(string driverId)
+    {
+        var probe = CreateTestProbe();
+        Sys.ActorSelection(_host.Path.ToStringWithoutAddress() + "/drv-" + driverId + "-g*").Tell(new Identify(driverId), probe.Ref);
+        return probe.ExpectMsg<ActorIdentity>(PresenceBudget).Subject.ShouldNotBeNull();
+    }
+
+    private static void ShouldNotBeTheOldGood(Dictionary<string, VirtualTagActor.DependencyValueChanged> replay, string path, object oldValue)
+    {
+        if (!replay.TryGetValue(path, out var item)) return;
+        (Equals(item.Value, oldValue) && OpcUaStatus.IsGood(item.StatusCode))
+            .ShouldBeFalse($"the stopped incarnation's last Good for {path} was replayed as current");
+    }
+
+    [Fact]
+    public void A_driver_removed_by_a_deploy_is_no_longer_replayed_while_a_still_present_driver_is()
+    {
+        ArrangeTwoDriversWithRetainedValues();
+
+        // Positive control before the removal: both values replay.
+        Replayed().Keys.ShouldBe(new[] { Path1, Path2 }, ignoreOrder: true);
+
+        // Deploy B drops DI-1 (StopChild).
+        var revB = V3ArtifactSeeder.SeedV3Deployment(_db, RevB, [("DI-2", "Modbus2", "dev2", "flow", "Double", false)], NoRefs, enabled: true);
+        V3ArtifactSeeder.Dispatch(_host, _coordinator, revB, RevB);
+
+        AwaitAssert(
+            () => Replayed().Keys.ToArray().ShouldBe(new[] { Path2 }, "DI-1 was removed: its last Good must not replay; DI-2's must"),
+            PresenceBudget);
+    }
+
+    /// <summary>Review I-1: a burst the removed child sent after the eviction (it stops asynchronously, so it keeps
+    /// publishing through the rest of the apply) must be dropped by the host, not forwarded to re-retain the value.</summary>
+    [Fact]
+    public void A_late_burst_from_a_removed_child_does_not_re_retain_its_value()
+    {
+        ArrangeTwoDriversWithRetainedValues();
+        var oldChild = ChildOf("DI-1");
+        // Hold the removed child in its PostStop so it has NOT terminated when the stale burst lands; a terminated
+        // actor cannot send, and the host forgets a retired child on Terminated.
+        var gate = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        Driver("DI-1").ShutdownGate = gate;
+
+        var revB = V3ArtifactSeeder.SeedV3Deployment(_db, RevB, [("DI-2", "Modbus2", "dev2", "flow", "Double", false)], NoRefs, enabled: true);
+        V3ArtifactSeeder.Dispatch(_host, _coordinator, revB, RevB);
+
+        // The stale burst, sent AS the stopped child.
+        _host.Tell(ValuePublishes.Single("DI-1", Path1, 11.0, OpcUaStatus.Good, DateTime.UtcNow), oldChild);
+        // Positive control / ordering fence: a live driver's value sent after it is delivered, so the stale burst
+        // has been processed by the host by the time we look.
+        Driver("DI-2").FireDataChange(Path2, 23.0);
+        AwaitHolder(Path2, 23.0);
+
+        Replayed().Keys.ToArray().ShouldBe(new[] { Path2 }, "the removed child's late burst re-retained its last Good");
+        gate.TrySetResult();
+    }
+
+    /// <summary>Review m-3: a config edit respawns the driver (stop + spawn); the OLD object's value is evicted, and
+    /// the NEW driver's value replays (positive control).</summary>
+    [Fact]
+    public void A_config_change_respawn_evicts_the_old_value_and_the_new_drivers_value_replays()
+    {
+        ArrangeTwoDriversWithRetainedValues();
+
+        // Adding a tag to DI-1 changes its merged DriverConfig, which respawns it.
+        var revB = V3ArtifactSeeder.SeedV3Deployment(_db, RevB,
+            [.. BothDrivers, ("DI-1", "Modbus", "dev1", "temp", "Double", false)], NoRefs, enabled: true);
+        V3ArtifactSeeder.Dispatch(_host, _coordinator, revB, RevB);
+        AwaitAssert(() => _factory.Created.Count.ShouldBe(3), PresenceBudget);
+        var respawned = Driver("DI-1");
+        // The spawn hands the child the PREVIOUS apply's set, then the bulk push re-subscribes with the new one
+        // (which names the added tag); a value fired between the two can be lost, so wait for the final set.
+        AwaitAssert(() => (respawned.LastSubscribedRefs ?? []).ShouldContain("Plant/Modbus/dev1/temp"), PresenceBudget);
+
+        ShouldNotBeTheOldGood(Replayed(), Path1, 11.0);
+
+        respawned.FireDataChange(Path1, 33.0);
+        AwaitHolder(Path1, 33.0);
+        var replay = Replayed();
+        replay[Path1].Value.ShouldBe(33.0, "the respawned driver's own value replays");
+        replay[Path2].Value.ShouldBe(22.0, "the untouched driver is unaffected");
+    }
+
+    /// <summary>Review m-3: an operator Restart builds a new driver object; the old one's value is evicted and the
+    /// new one's replays.</summary>
+    [Fact]
+    public void An_operator_restart_evicts_the_old_value_and_the_new_drivers_value_replays()
+    {
+        ArrangeTwoDriversWithRetainedValues();
+
+        _host.Tell(new RestartDriver("c1", "DI-1", "tester", Guid.NewGuid()));
+        AwaitAssert(() => _factory.Created.Count.ShouldBe(3), PresenceBudget);
+        var restarted = Driver("DI-1");
+        AwaitSubscribed("DI-1", Path1);
+
+        ShouldNotBeTheOldGood(Replayed(), Path1, 11.0);
+
+        restarted.FireDataChange(Path1, 44.0);
+        AwaitHolder(Path1, 44.0);
+        Replayed()[Path1].Value.ShouldBe(44.0);
+    }
+
+    [Fact]
+    public void A_supervision_restart_does_not_evict_the_drivers_retained_value()
+    {
+        ArrangeTwoDriversWithRetainedValues();
+        var di1 = Driver("DI-1");
+
+        // Crash DI-1's child: Akka restarts it around the SAME driver object, and the host reprovisions it.
+        di1.FireMalformedDataChange(Path1);
+        AwaitAssert(() => di1.InitializeCount.ShouldBe(2), PresenceBudget);
+        _factory.Created.Count.ShouldBe(2, "a supervision restart re-uses the driver; no new one is created");
+
+        var replay = Replayed();
+        replay.Keys.ShouldBe(new[] { Path1, Path2 }, ignoreOrder: true,
+            "a restart is the same driver instance: its last value stays replayable");
+    }
+}
@@ -110,7 +110,7 @@ public sealed class DriverInstanceActorBatchForwardTests : RuntimeActorTestBase
        batch.Items.Count.ShouldBe(2);

        // The per-tag raises for the SAME burst produced nothing extra — no second batch, no
-        // AttributeValuePublished. Anything here means both handlers were attached.
+        // single-item batch. Anything here means both handlers were attached.
        parent.ExpectNoMsg(TimeSpan.FromMilliseconds(400));
    }

@@ -279,11 +279,18 @@ internal sealed class RecordingSubscribableDriver : IDriver, ISubscribable, IAla
    /// <inheritdoc />
    public Task ReinitializeAsync(string driverConfigJson, CancellationToken cancellationToken) => Task.CompletedTask;

+    /// <summary>
+    ///     When set, <see cref="ShutdownAsync"/> awaits it (the actor bounds the wait), which keeps a stopping child
+    ///     ALIVE in its PostStop for as long as the test wants — the window in which a stopped child can still
+    ///     have messages reaching its parent.
+    /// </summary>
+    public TaskCompletionSource? ShutdownGate { get; set; }
+
    /// <inheritdoc />
    public Task ShutdownAsync(CancellationToken cancellationToken)
    {
        Interlocked.Increment(ref _shutdownCount);
-        return Task.CompletedTask;
+        return ShutdownGate?.Task ?? Task.CompletedTask;
    }

    /// <inheritdoc />
@@ -5,8 +5,8 @@ namespace ZB.MOM.WW.OtOpcUa.Runtime.Tests.Harness;
 /// <summary>
 ///     Builds the ONE message shape a driver child sends for its values — a
 ///     <see cref="DriverInstanceActor.AttributeValueBatchPublished"/> — for tests that push a single value into the
-///     dependency mux by hand. The per-value <see cref="DriverInstanceActor.AttributeValuePublished"/> has no
-///     production sender (02/U4); tests should not keep one alive either.
+///     dependency mux by hand. There is no per-value message: the former per-value record had no production
+///     sender and was deleted (02/U4).
 /// </summary>
 public static class ValuePublishes
 {
@@ -19,7 +19,7 @@ namespace ZB.MOM.WW.OtOpcUa.Runtime.Tests.Historian;
 /// <remarks>
 ///     Adapted from the plan's Task 17: the recorder handles the REAL fan-out message the mux emits —
 ///     <see cref="VirtualTagActor.DependencyValueChanged"/> (TagId/Value/TimestampUtc/StatusCode) —
-///     not <c>DriverInstanceActor.AttributeValuePublished</c>. The typed-value / real-status behaviour is
+///     not the driver-side <c>DriverInstanceActor.AttributeValueBatchPublished</c>. The typed-value / real-status behaviour is
 ///     pinned in <see cref="ContinuousHistorizationRecorderTypedValueTests"/>.
 /// </remarks>
 public sealed class ContinuousHistorizationRecorderTests : TestKit
@@ -10,9 +10,9 @@ namespace ZB.MOM.WW.OtOpcUa.Runtime.Tests.VirtualTags;

 public sealed class DependencyMuxActorTests : RuntimeActorTestBase
 {
-    /// <summary>Verifies that AttributeValuePublished messages are forwarded only to subscribers interested in the specific reference.</summary>
+    /// <summary>Verifies that a published value is forwarded only to subscribers interested in the specific reference.</summary>
    [Fact]
-    public void AttributeValuePublished_is_forwarded_only_to_subscribers_interested_in_that_ref()
+    public void A_published_value_is_forwarded_only_to_subscribers_interested_in_that_ref()
    {
        var mux = Sys.ActorOf(DependencyMuxActor.Props());
        var subA = CreateTestProbe();
@@ -21,9 +21,9 @@ public sealed class DependencyMuxActorTests : RuntimeActorTestBase
        mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "tag-1", "tag-2" }, subA.Ref));
        mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "tag-2", "tag-3" }, subB.Ref));

-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-1", 10, OpcUaStatus.Good, DateTime.UtcNow));
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-3", 30, OpcUaStatus.Good, DateTime.UtcNow));
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-2", 20, OpcUaStatus.Good, DateTime.UtcNow));
+        mux.Tell(ValuePublishes.Single("driver-1", "tag-1", 10, OpcUaStatus.Good, DateTime.UtcNow));
+        mux.Tell(ValuePublishes.Single("driver-1", "tag-3", 30, OpcUaStatus.Good, DateTime.UtcNow));
+        mux.Tell(ValuePublishes.Single("driver-1", "tag-2", 20, OpcUaStatus.Good, DateTime.UtcNow));

        // The mux emits ONLY batches — the per-value comms-loss ingress fans out as a single-item batch.
        // subA hears tag-1 + tag-2.
@@ -54,7 +54,7 @@ public sealed class DependencyMuxActorTests : RuntimeActorTestBase
        var sub = CreateTestProbe();

        mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "tag-1" }, sub.Ref));
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "nobody-cares", 99, OpcUaStatus.Good, DateTime.UtcNow));
+        mux.Tell(ValuePublishes.Single("driver-1", "nobody-cares", 99, OpcUaStatus.Good, DateTime.UtcNow));

        sub.ExpectNoMsg(TimeSpan.FromMilliseconds(200));
    }
@@ -67,11 +67,11 @@ public sealed class DependencyMuxActorTests : RuntimeActorTestBase
        var sub = CreateTestProbe();

        mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "tag-1" }, sub.Ref));
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-1", 10, OpcUaStatus.Good, DateTime.UtcNow));
+        mux.Tell(ValuePublishes.Single("driver-1", "tag-1", 10, OpcUaStatus.Good, DateTime.UtcNow));
        sub.ExpectMsg<VirtualTagActor.DependencyValueBatch>();

        mux.Tell(new DependencyMuxActor.UnregisterInterest(sub.Ref));
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-1", 20, OpcUaStatus.Good, DateTime.UtcNow));
+        mux.Tell(ValuePublishes.Single("driver-1", "tag-1", 20, OpcUaStatus.Good, DateTime.UtcNow));
        sub.ExpectNoMsg(TimeSpan.FromMilliseconds(200));
    }

@@ -85,10 +85,10 @@ public sealed class DependencyMuxActorTests : RuntimeActorTestBase
        mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "tag-1" }, sub.Ref));
        mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "tag-2" }, sub.Ref)); // replaces tag-1

-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-1", 10, OpcUaStatus.Good, DateTime.UtcNow));
+        mux.Tell(ValuePublishes.Single("driver-1", "tag-1", 10, OpcUaStatus.Good, DateTime.UtcNow));
        sub.ExpectNoMsg(TimeSpan.FromMilliseconds(200));

-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "tag-2", 20, OpcUaStatus.Good, DateTime.UtcNow));
+        mux.Tell(ValuePublishes.Single("driver-1", "tag-2", 20, OpcUaStatus.Good, DateTime.UtcNow));
        sub.ExpectMsg<VirtualTagActor.DependencyValueBatch>().Items.ShouldHaveSingleItem().TagId.ShouldBe("tag-2");
    }

@@ -110,18 +110,18 @@ public sealed class DependencyMuxActorTests : RuntimeActorTestBase
        // gets dropped (no subscriber for "ref-a" yet), so we re-publish each pass.
        AwaitAssert(() =>
        {
-            mux.Tell(new DriverInstanceActor.AttributeValuePublished(
+            mux.Tell(ValuePublishes.Single(
                "driver-1", "ref-a", 10, OpcUaStatus.Good, DateTime.UtcNow));
            parent.ExpectMsg<VirtualTagActor.EvaluationResult>(TimeSpan.FromMilliseconds(200))
                .Value.ShouldBe(10);
        }, duration: PresenceBudget);

        // From here the actor is wired — second publish drives the sum.
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "ref-b", 32, OpcUaStatus.Good, DateTime.UtcNow));
+        mux.Tell(ValuePublishes.Single("driver-1", "ref-b", 32, OpcUaStatus.Good, DateTime.UtcNow));
        parent.ExpectMsg<VirtualTagActor.EvaluationResult>(PresenceBudget).Value.ShouldBe(42);

        // Unrelated ref shouldn't fire eval.
-        mux.Tell(new DriverInstanceActor.AttributeValuePublished("driver-1", "ref-unrelated", 99, OpcUaStatus.Good, DateTime.UtcNow));
+        mux.Tell(ValuePublishes.Single("driver-1", "ref-unrelated", 99, OpcUaStatus.Good, DateTime.UtcNow));
        parent.ExpectNoMsg(TimeSpan.FromMilliseconds(200));
    }

@@ -221,7 +221,7 @@ public sealed class DependencyMuxActorTests : RuntimeActorTestBase
        var sub = CreateTestProbe();
        mux.Tell(new DependencyMuxActor.RegisterInterest(new[] { "tag-1" }, sub.Ref));

-        mux.Tell(new DriverInstanceActor.AttributeValuePublished(
+        mux.Tell(ValuePublishes.Single(
            "driver-1", "tag-1", 10, OpcUaStatus.Bad, DateTime.UtcNow));

        sub.ExpectMsg<VirtualTagActor.DependencyValueBatch>()