fix(galaxy): #859 review — read path window, atomic promote, session epoch, per-call windows

1. ReadAsync (subscribe-once) now opens the early-event window around its
   SubscribeBulk + registration; an initial value that overtook the reply was
   dropped and the read returned BadTimeout.
2. Register/Rebind write the reverse map and promote parked events in ONE
   critical section under the park gate, and ResolveOrPark resolves under that
   gate whenever anything is held (lock-free fast path only when nothing is),
   so a later live event can no longer overtake the parked initial value. A
   resolved handle that still holds a parked list queues behind it.
3. Held events are fenced by a session epoch: each new EventPump calls
   StartNewEpoch(), discarding parked AND promoted-but-unreplayed events; an
   older pump can neither park nor replay. Item-handle reuse across a reconnect
   can no longer put an old-session value on a new tag.
4. ResubscribeAllAsync opens one window per subscription, not across the whole
   replay.
5. Promoted-but-unreplayed (ready) events count toward MaxParkedEvents.
6. Begin/End of a window run under the park gate, so N->0 discard and 0->1
   open are atomic (no inherited leftovers).
Documented that ParkedEventsReady may run under _registryGate/_syncLock and
relies on the channel's AllowSynchronousContinuations=false.

Tests use TestWait (#858); each new test was checked red against a mutation
of the fix it pins.

Claude-Session: https://claude.ai/code/session_01GT67AD99zQQqpLCVm3p7xk
This commit is contained in:
Joseph Doherty
2026-11-11 10:26:28 -05:00
parent 1a31e3f584
commit f89e0cc04c
5 changed files with 505 additions and 203 deletions
@@ -7,6 +7,7 @@ using Xunit;
using ZB.MOM.WW.MxGateway.Contracts.Proto;
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
using ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Config;
using ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Health;
using ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Runtime;
namespace ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Tests.Runtime;
@@ -22,8 +23,6 @@ namespace ZB.MOM.WW.OtOpcUa.Driver.Galaxy.Tests.Runtime;
/// </summary>
public sealed class EarlyEventWindowTests
{
private const int WaitMs = 10_000;
private static MxEvent DataChange(int handle, double value) => new()
{
Family = MxEventFamily.OnDataChange,
@@ -33,15 +32,11 @@ public sealed class EarlyEventWindowTests
SourceTimestamp = Timestamp.FromDateTime(DateTime.UtcNow),
};
private static async Task WaitUntilAsync(Func<bool> predicate, string because)
{
var deadline = DateTime.UtcNow.AddMilliseconds(WaitMs);
while (!predicate())
{
if (DateTime.UtcNow > deadline) throw new TimeoutException(because);
await Task.Delay(5);
}
}
private static GalaxyDriverOptions Opts() => new(
new GalaxyGatewayOptions("https://mxgw.test:5001", "key"),
new GalaxyMxAccessOptions("OtOpcUa-A"),
new GalaxyRepositoryOptions(),
new GalaxyReconnectOptions());
// ===== Registry =====
@@ -50,8 +45,9 @@ public sealed class EarlyEventWindowTests
public void Unknown_handle_without_a_pending_subscribe_is_stale()
{
var registry = new SubscriptionRegistry();
var epoch = registry.StartNewEpoch();
registry.ResolveOrPark(DataChange(7, 1), out _).ShouldBe(EarlyEventOutcome.Stale);
registry.ResolveOrPark(DataChange(7, 1), epoch, out _).ShouldBe(EarlyEventOutcome.Stale);
registry.ParkedEventCount.ShouldBe(0);
}
@@ -60,22 +56,23 @@ public sealed class EarlyEventWindowTests
public void Parked_events_are_promoted_in_order_on_register()
{
var registry = new SubscriptionRegistry();
var epoch = registry.StartNewEpoch();
var woken = 0;
registry.ParkedEventsReady += () => woken++;
using (registry.BeginPendingSubscribe())
{
registry.ResolveOrPark(DataChange(7, 1), out _).ShouldBe(EarlyEventOutcome.Parked);
registry.ResolveOrPark(DataChange(7, 2), out _).ShouldBe(EarlyEventOutcome.Parked);
registry.ResolveOrPark(DataChange(8, 9), out _).ShouldBe(EarlyEventOutcome.Parked);
registry.TakeReadyEvents().ShouldBeEmpty();
registry.ResolveOrPark(DataChange(7, 1), epoch, out _).ShouldBe(EarlyEventOutcome.Parked);
registry.ResolveOrPark(DataChange(7, 2), epoch, out _).ShouldBe(EarlyEventOutcome.Parked);
registry.ResolveOrPark(DataChange(8, 9), epoch, out _).ShouldBe(EarlyEventOutcome.Parked);
registry.TakeReadyEvents(epoch).ShouldBeEmpty();
registry.Register(1, [new TagBinding("Tank.Level", 7)]);
}
woken.ShouldBe(1);
registry.TakeReadyEvents().Select(e => e.Value.DoubleValue).ShouldBe([1.0, 2.0]);
registry.TakeReadyEvents().ShouldBeEmpty();
registry.TakeReadyEvents(epoch).Select(e => e.Value.DoubleValue).ShouldBe([1.0, 2.0]);
registry.TakeReadyEvents(epoch).ShouldBeEmpty();
// Handle 8 was never registered: closing the last window discarded it.
registry.ParkedEventCount.ShouldBe(0);
}
@@ -85,15 +82,16 @@ public sealed class EarlyEventWindowTests
public void Rebind_promotes_parked_events_for_the_new_handles()
{
var registry = new SubscriptionRegistry();
var epoch = registry.StartNewEpoch();
registry.Register(1, [new TagBinding("Tank.Level", 7)]);
using (registry.BeginPendingSubscribe())
{
registry.ResolveOrPark(DataChange(70, 5), out _).ShouldBe(EarlyEventOutcome.Parked);
registry.ResolveOrPark(DataChange(70, 5), epoch, out _).ShouldBe(EarlyEventOutcome.Parked);
registry.Rebind(1, [new TagBinding("Tank.Level", 70)]);
}
registry.TakeReadyEvents().Single().ItemHandle.ShouldBe(70);
registry.TakeReadyEvents(epoch).Single().ItemHandle.ShouldBe(70);
}
/// <summary>Closing one of two overlapping windows keeps the other subscribe's parked events.</summary>
@@ -101,10 +99,11 @@ public sealed class EarlyEventWindowTests
public void Closing_one_of_two_windows_keeps_parked_events()
{
var registry = new SubscriptionRegistry();
var epoch = registry.StartNewEpoch();
var first = registry.BeginPendingSubscribe();
var second = registry.BeginPendingSubscribe();
registry.ResolveOrPark(DataChange(7, 1), out _).ShouldBe(EarlyEventOutcome.Parked);
registry.ResolveOrPark(DataChange(7, 1), epoch, out _).ShouldBe(EarlyEventOutcome.Parked);
first.Dispose();
first.Dispose(); // idempotent — must not close the second window
registry.PendingSubscribeCount.ShouldBe(1);
@@ -112,7 +111,26 @@ public sealed class EarlyEventWindowTests
second.Dispose();
registry.ParkedEventCount.ShouldBe(0);
registry.ResolveOrPark(DataChange(7, 1), out _).ShouldBe(EarlyEventOutcome.Stale);
registry.ResolveOrPark(DataChange(7, 1), epoch, out _).ShouldBe(EarlyEventOutcome.Stale);
}
/// <summary>
/// Review #6: a window opening right after the previous one closed never inherits its
/// leftovers (the N→0 discard and the 0→1 open are serialised under the park gate).
/// </summary>
[Fact]
public void A_new_window_never_inherits_the_previous_windows_leftovers()
{
var registry = new SubscriptionRegistry();
var epoch = registry.StartNewEpoch();
var first = registry.BeginPendingSubscribe();
registry.ResolveOrPark(DataChange(7, 1), epoch, out _).ShouldBe(EarlyEventOutcome.Parked);
first.Dispose();
using var second = registry.BeginPendingSubscribe();
registry.ParkedEventCount.ShouldBe(0);
registry.Register(1, [new TagBinding("Reused", 7)]);
registry.TakeReadyEvents(epoch).ShouldBeEmpty("the closed window's event must not reach the new owner of handle 7");
}
/// <summary>Parking is bounded; past the bound the event is dropped as overflow.</summary>
@@ -120,29 +138,77 @@ public sealed class EarlyEventWindowTests
public void Parking_is_bounded()
{
var registry = new SubscriptionRegistry();
var epoch = registry.StartNewEpoch();
using var window = registry.BeginPendingSubscribe();
var ev = DataChange(7, 1);
for (var i = 0; i < SubscriptionRegistry.MaxParkedEvents; i++)
{
registry.ResolveOrPark(ev, out _).ShouldBe(EarlyEventOutcome.Parked);
registry.ResolveOrPark(ev, epoch, out _).ShouldBe(EarlyEventOutcome.Parked);
}
registry.ResolveOrPark(ev, out _).ShouldBe(EarlyEventOutcome.Overflow);
registry.ResolveOrPark(ev, epoch, out _).ShouldBe(EarlyEventOutcome.Overflow);
registry.ParkedEventCount.ShouldBe(SubscriptionRegistry.MaxParkedEvents);
}
/// <summary>Review #5: promoted-but-not-yet-replayed events still count toward the bound.</summary>
[Fact]
public void Ready_events_count_toward_the_bound()
{
var registry = new SubscriptionRegistry();
var epoch = registry.StartNewEpoch();
using var window = registry.BeginPendingSubscribe();
var ev = DataChange(7, 1);
for (var i = 0; i < SubscriptionRegistry.MaxParkedEvents; i++) registry.ResolveOrPark(ev, epoch, out _);
registry.Register(1, [new TagBinding("Tank.Level", 7)]); // all promoted to ready
registry.ResolveOrPark(DataChange(8, 1), epoch, out _).ShouldBe(EarlyEventOutcome.Overflow);
registry.TakeReadyEvents(epoch).Count.ShouldBe(SubscriptionRegistry.MaxParkedEvents);
registry.ParkedEventCount.ShouldBe(0);
registry.ResolveOrPark(DataChange(8, 1), epoch, out _).ShouldBe(EarlyEventOutcome.Parked,
"positive control: once replayed, the room is back");
}
/// <summary>A registered handle resolves normally even while a window is open.</summary>
[Fact]
public void Registered_handle_resolves_while_a_window_is_open()
{
var registry = new SubscriptionRegistry();
var epoch = registry.StartNewEpoch();
registry.Register(1, [new TagBinding("Tank.Level", 7)]);
using var window = registry.BeginPendingSubscribe();
registry.ResolveOrPark(DataChange(7, 1), out var subs).ShouldBe(EarlyEventOutcome.Resolved);
registry.ResolveOrPark(DataChange(7, 1), epoch, out var subs).ShouldBe(EarlyEventOutcome.Resolved);
subs.Single().FullReference.ShouldBe("Tank.Level");
}
/// <summary>
/// Review #3: held events belong to a session epoch. A new epoch (a new pump after a
/// reconnect) discards parked AND promoted-but-unreplayed events, and an older pump can
/// neither park nor replay — so a reused handle number never receives an old-session value.
/// </summary>
[Fact]
public void A_new_epoch_discards_held_events_and_fences_the_old_epoch()
{
var registry = new SubscriptionRegistry();
var oldEpoch = registry.StartNewEpoch();
using var window = registry.BeginPendingSubscribe();
registry.ResolveOrPark(DataChange(7, 111), oldEpoch, out _).ShouldBe(EarlyEventOutcome.Parked);
registry.ResolveOrPark(DataChange(8, 112), oldEpoch, out _).ShouldBe(EarlyEventOutcome.Parked);
registry.Register(1, [new TagBinding("Old.A", 8)]); // 8 promoted to ready, never replayed
var newEpoch = registry.StartNewEpoch();
registry.ParkedEventCount.ShouldBe(0);
registry.TakeReadyEvents(newEpoch).ShouldBeEmpty();
registry.Register(2, [new TagBinding("New.B", 7)]); // new session reuses handle 7
registry.TakeReadyEvents(newEpoch).ShouldBeEmpty("the old session's value must not reach New.B");
registry.ResolveOrPark(DataChange(9, 1), oldEpoch, out _).ShouldBe(EarlyEventOutcome.Stale);
registry.TakeReadyEvents(oldEpoch).ShouldBeEmpty();
registry.ResolveOrPark(DataChange(9, 1), newEpoch, out _).ShouldBe(EarlyEventOutcome.Parked,
"positive control: the current epoch still parks");
}
// ===== EventPump =====
private sealed class ChannelSubscriber : IGalaxySubscriber
@@ -163,7 +229,7 @@ public sealed class EarlyEventWindowTests
}
}
public ValueTask EmitAsync(MxEvent ev) => _events.Writer.WriteAsync(ev);
public void Emit(MxEvent ev) => _events.Writer.TryWrite(ev).ShouldBeTrue();
}
/// <summary>
@@ -182,14 +248,14 @@ public sealed class EarlyEventWindowTests
using (registry.BeginPendingSubscribe())
{
await subscriber.EmitAsync(DataChange(7, 42));
await WaitUntilAsync(() => registry.ParkedEventCount == 1, "the early event must be parked, not dropped");
subscriber.Emit(DataChange(7, 42));
await TestWait.UntilAsync(() => registry.ParkedEventCount == 1, "the early event must be parked, not dropped");
delivered.ShouldBeEmpty();
registry.Register(1, [new TagBinding("Tank.Level", 7)]);
}
await WaitUntilAsync(() => !delivered.IsEmpty, "the parked initial value must be replayed");
await TestWait.UntilAsync(() => !delivered.IsEmpty, "the parked initial value must be replayed");
var args = delivered.Single();
args.FullReference.ShouldBe("Tank.Level");
((double)args.Snapshot.Value!).ShouldBe(42.0);
@@ -208,17 +274,56 @@ public sealed class EarlyEventWindowTests
using (registry.BeginPendingSubscribe())
{
await subscriber.EmitAsync(DataChange(7, 1));
await subscriber.EmitAsync(DataChange(7, 2));
await WaitUntilAsync(() => registry.ParkedEventCount == 2, "both early events must be parked");
subscriber.Emit(DataChange(7, 1));
subscriber.Emit(DataChange(7, 2));
await TestWait.UntilAsync(() => registry.ParkedEventCount == 2, "both early events must be parked");
registry.Register(1, [new TagBinding("Tank.Level", 7)]);
await subscriber.EmitAsync(DataChange(7, 3));
subscriber.Emit(DataChange(7, 3));
}
await WaitUntilAsync(() => delivered.Count >= 3, "all three values must be delivered");
await TestWait.UntilAsync(() => delivered.Count >= 3, "all three values must be delivered",
() => string.Join(",", delivered));
delivered.ShouldBe([1.0, 2.0, 3.0]);
}
/// <summary>
/// Review #2: a live event arriving while a registration has written the reverse map but not
/// yet promoted (a 50k-binding Register is milliseconds of work) must NOT overtake the parked
/// initial value. The hook runs inside that window, emits the newer value and gives the pump
/// ample time to (wrongly) dispatch it; the pump must instead wait for the promotion.
/// </summary>
[Fact]
public async Task Pump_does_not_let_a_live_event_overtake_a_registration_in_progress()
{
var subscriber = new ChannelSubscriber();
var registry = new SubscriptionRegistry();
var delivered = new ConcurrentQueue<double>();
await using var pump = new EventPump(subscriber, registry, channelCapacity: 16, clientName: "Early");
pump.OnDataChange += (_, e) => delivered.Enqueue((double)e.Snapshot.Value!);
pump.Start();
var deliveredDuringRegistration = -1;
using (registry.BeginPendingSubscribe())
{
subscriber.Emit(DataChange(7, 1));
await TestWait.UntilAsync(() => registry.ParkedEventCount == 1, "the initial value must be parked");
registry.AfterMapWriteForTests = () =>
{
subscriber.Emit(DataChange(7, 2));
Thread.Sleep(300);
deliveredDuringRegistration = delivered.Count;
};
registry.Register(1, [new TagBinding("Tank.Level", 7)]);
registry.AfterMapWriteForTests = null;
}
await TestWait.UntilAsync(() => delivered.Count >= 2, "both values must be delivered",
() => string.Join(",", delivered));
deliveredDuringRegistration.ShouldBe(0, "nothing may dispatch for the handle mid-registration");
delivered.ShouldBe([1.0, 2.0]);
}
/// <summary>
/// A genuinely stale event (no subscribe in flight) is still dropped; the positive control
/// that follows it proves the pump processed it rather than not having got to it yet.
@@ -234,35 +339,72 @@ public sealed class EarlyEventWindowTests
pump.OnDataChange += (_, e) => delivered.Enqueue(e);
pump.Start();
await subscriber.EmitAsync(DataChange(99, 5)); // unsubscribed handle
await subscriber.EmitAsync(DataChange(7, 6)); // positive control, strictly after
subscriber.Emit(DataChange(99, 5)); // unsubscribed handle
subscriber.Emit(DataChange(7, 6)); // positive control, strictly after
await WaitUntilAsync(() => !delivered.IsEmpty, "the positive control must arrive");
await TestWait.UntilAsync(() => !delivered.IsEmpty, "the positive control must arrive");
delivered.Single().FullReference.ShouldBe("Tank.Level");
registry.ParkedEventCount.ShouldBe(0);
// Registering 99 now must not resurrect the stale event.
registry.Register(2, [new TagBinding("Other", 99)]);
registry.TakeReadyEvents().ShouldBeEmpty();
registry.ParkedEventCount.ShouldBe(0);
}
// ===== GalaxyDriver end-to-end =====
/// <summary>
/// Review #3, pump level: an event the old session's pump parked is never replayed by the
/// next session's pump onto the tag that now owns the reused handle number.
/// </summary>
[Fact]
public async Task Pump_after_reconnect_never_replays_an_old_session_event_onto_a_reused_handle()
{
var registry = new SubscriptionRegistry();
var delivered = new ConcurrentQueue<DataChangeEventArgs>();
using var window = registry.BeginPendingSubscribe(); // e.g. a subscribe hanging across the reconnect
var oldStream = new ChannelSubscriber();
var oldPump = new EventPump(oldStream, registry, channelCapacity: 16, clientName: "Old");
oldPump.Start();
oldStream.Emit(DataChange(7, 111));
await TestWait.UntilAsync(() => registry.ParkedEventCount == 1, "the old session's event must be parked");
await oldPump.DisposeAsync();
var newStream = new ChannelSubscriber();
await using var newPump = new EventPump(newStream, registry, channelCapacity: 16, clientName: "New");
newPump.OnDataChange += (_, e) => delivered.Enqueue(e);
newPump.Start();
registry.Register(2, [new TagBinding("New.Tag", 7)]); // new session reuses handle 7
newStream.Emit(DataChange(7, 222)); // positive control on the new session
await TestWait.UntilAsync(() => !delivered.IsEmpty, "the new session's value must arrive");
await TestWait.UntilAsync(() => registry.ParkedEventCount == 0, "nothing may stay held");
delivered.Select(e => (double)e.Snapshot.Value!).ShouldBe([222.0]);
}
// ===== GalaxyDriver / probe watcher end-to-end =====
/// <summary>
/// A gateway fake that writes each new handle's initial value to the event stream and only
/// returns the SubscribeBulk reply once the driver's pump has consumed that event — the
/// returns the SubscribeBulk reply once the consumer's pump has parked that event — the
/// event deterministically precedes the reply.
/// </summary>
private sealed class EventBeforeReplySubscriber(Func<int> parkedCount) : IGalaxySubscriber
private sealed class EventBeforeReplySubscriber : IGalaxySubscriber
{
private readonly Channel<MxEvent> _events = Channel.CreateUnbounded<MxEvent>();
private int _nextHandle = 100;
/// <summary>Gets or sets the consumer's held-event count, polled before replying.</summary>
public Func<int> ParkedCount { get; set; } = () => 0;
/// <summary>Gets the handles unsubscribed so far.</summary>
public ConcurrentQueue<int> Unsubscribed { get; } = new();
public async Task<IReadOnlyList<SubscribeResult>> SubscribeBulkAsync(
IReadOnlyList<string> fullReferences, int bufferedUpdateIntervalMs, CancellationToken cancellationToken)
{
var results = new List<SubscribeResult>();
var before = parkedCount();
var before = ParkedCount();
foreach (var fullRef in fullReferences)
{
var handle = Interlocked.Increment(ref _nextHandle);
@@ -270,12 +412,17 @@ public sealed class EarlyEventWindowTests
results.Add(new SubscribeResult { TagAddress = fullRef, ItemHandle = handle, WasSuccessful = true });
}
await WaitUntilAsync(() => parkedCount() >= before + fullReferences.Count,
"the initial values must reach the pump (and be parked) before the reply is returned");
await TestWait.UntilAsync(() => ParkedCount() >= before + fullReferences.Count,
"the initial values must reach the pump (and be parked) before the reply is returned",
() => $"held={ParkedCount()} before={before}");
return results;
}
public Task UnsubscribeBulkAsync(IReadOnlyList<int> itemHandles, CancellationToken cancellationToken) => Task.CompletedTask;
public Task UnsubscribeBulkAsync(IReadOnlyList<int> itemHandles, CancellationToken cancellationToken)
{
foreach (var h in itemHandles) Unsubscribed.Enqueue(h);
return Task.CompletedTask;
}
public async IAsyncEnumerable<MxEvent> StreamEventsAsync([EnumeratorCancellation] CancellationToken cancellationToken)
{
@@ -290,26 +437,61 @@ public sealed class EarlyEventWindowTests
[Fact]
public async Task Driver_publishes_an_initial_value_that_arrived_before_the_subscribe_reply()
{
GalaxyDriver? driverRef = null;
var subscriber = new EventBeforeReplySubscriber(() => driverRef!.ParkedEarlyEventCountForTests);
var subscriber = new EventBeforeReplySubscriber();
using var driver = new GalaxyDriver(
"g",
new GalaxyDriverOptions(
new GalaxyGatewayOptions("https://mxgw.test:5001", "key"),
new GalaxyMxAccessOptions("OtOpcUa-A"),
new GalaxyRepositoryOptions(),
new GalaxyReconnectOptions()),
hierarchySource: null, dataReader: null, dataWriter: null, subscriber: subscriber);
driverRef = driver;
"g", Opts(), hierarchySource: null, dataReader: null, dataWriter: null, subscriber: subscriber);
subscriber.ParkedCount = () => driver.ParkedEarlyEventCountForTests;
var delivered = new ConcurrentQueue<DataChangeEventArgs>();
driver.OnDataChange += (_, e) => delivered.Enqueue(e);
var handle = await driver.SubscribeAsync(
["Tank.Level", "Tank.Temp"], TimeSpan.FromSeconds(1), TestContext.Current.CancellationToken);
await WaitUntilAsync(() => delivered.Count >= 2, "both initial values must be published");
await TestWait.UntilAsync(() => delivered.Count >= 2, "both initial values must be published");
delivered.Select(e => e.FullReference).OrderBy(r => r).ShouldBe(["Tank.Level", "Tank.Temp"]);
delivered.ShouldAllBe(e => e.SubscriptionHandle.Equals(handle));
driver.ParkedEarlyEventCountForTests.ShouldBe(0);
}
/// <summary>
/// Review #1: the subscribe-once read waits ONLY for the initial value, so an initial value
/// that overtakes the reply must still complete the read Good — not BadTimeout.
/// </summary>
[Fact]
public async Task Driver_read_returns_an_initial_value_that_arrived_before_the_subscribe_reply()
{
var subscriber = new EventBeforeReplySubscriber();
using var driver = new GalaxyDriver(
"g", Opts(), hierarchySource: null, dataReader: null, dataWriter: null, subscriber: subscriber);
subscriber.ParkedCount = () => driver.ParkedEarlyEventCountForTests;
var snapshots = await TestWait.ForAsync(
driver.ReadAsync(["Tank.Level"], TestContext.Current.CancellationToken),
"the read must complete");
var snapshot = snapshots.ShouldHaveSingleItem();
snapshot.StatusCode.ShouldBe(StatusCodeMap.Good);
((double)snapshot.Value!).ShouldBe(1010.0);
driver.ParkedEarlyEventCountForTests.ShouldBe(0);
}
/// <summary>The probe watcher's initial ScanState overtaking its reply still reaches the fan-out.</summary>
[Fact]
public async Task Probe_watcher_initial_value_that_arrived_before_the_reply_is_dispatched()
{
var registry = new SubscriptionRegistry();
var subscriber = new EventBeforeReplySubscriber { ParkedCount = () => registry.ParkedEventCount };
var delivered = new ConcurrentQueue<DataChangeEventArgs>();
await using var pump = new EventPump(subscriber, registry, channelCapacity: 16, clientName: "Probe");
pump.OnDataChange += (_, e) => delivered.Enqueue(e);
pump.Start();
using var watcher = new PerPlatformProbeWatcher(subscriber, new HostStatusAggregator(), registry);
await watcher.SyncPlatformsAsync(["PlatformA"], TestContext.Current.CancellationToken);
await TestWait.UntilAsync(() => !delivered.IsEmpty, "the initial ScanState must be dispatched");
var args = delivered.Single();
args.FullReference.ShouldBe("PlatformA.ScanState");
((GalaxySubscriptionHandle)args.SubscriptionHandle).SubscriptionId.ShouldBe(SubscriptionRegistry.ProbeSubscriptionId);
}
}