refactor(runtime): publish canonical entity object deltas

Issue stable Runtime identities at canonical registration, publish entity and inventory commits through one generation-stamped synchronous stream, and make graphical adapters borrow the same direct views and events as a no-window host. Preserve exact projection teardown and retail mutation order while removing App-side event reconstruction.

Make the hard-recenter ordering fixture independent of the production two-millisecond frame budget so its injected-failure gate is deterministic.

Co-authored-by: Codex <codex@openai.com>

tests/AcDream.Runtime.Tests/Entities/RuntimeEntityObjectLifetimeTests.cs

@@ -1,6 +1,7 @@
 using AcDream.Core.Net;
 using AcDream.Core.Net.Messages;
 using AcDream.Core.Physics;
+using AcDream.Core.Items;
 using AcDream.Runtime.Entities;
 
 namespace AcDream.Runtime.Tests.Entities;
@@ -120,14 +121,19 @@ public sealed class RuntimeEntityObjectLifetimeTests
         Assert.False(lifetime.TryAcceptDelete(
             new DeleteObject.Parsed(spawn.Guid, 7),
             isLocalPlayer: false,
+            removeRetainedObject: true,
             out _));
         Assert.NotNull(lifetime.Objects.Get(spawn.Guid));
 
         Assert.True(lifetime.TryAcceptDelete(
             new DeleteObject.Parsed(spawn.Guid, 6),
             isLocalPlayer: false,
+            removeRetainedObject: true,
             out RuntimeEntityDeleteAcceptance accepted));
+        Assert.Same(canonical, accepted.RetiredCanonical);
+        Assert.False(lifetime.Entities.TryGetActive(spawn.Guid, out _));
         lifetime.CompleteAcceptedDelete(accepted);
+        Assert.Null(lifetime.RetireCanonicalOnly(canonical));
         Assert.Null(lifetime.Objects.Get(spawn.Guid));
     }
 
@@ -146,6 +152,7 @@ public sealed class RuntimeEntityObjectLifetimeTests
         Assert.True(owner.TryAcceptDelete(
             new DeleteObject.Parsed(spawn.Guid, spawn.InstanceSequence),
             isLocalPlayer: false,
+            removeRetainedObject: true,
             out RuntimeEntityDeleteAcceptance acceptance));
 
         Assert.Throws<InvalidOperationException>(
@@ -175,6 +182,509 @@ public sealed class RuntimeEntityObjectLifetimeTests
         Assert.Same(canonical, retained);
     }
 
+    [Fact]
+    public void CanonicalRegistration_IssuesIdentityBeforeAnyProjection()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        WorldSession.EntitySpawn spawn = Spawn(
+            0x70000010u,
+            4,
+            "direct");
+        RuntimeEntityRecord canonical = Accept(lifetime, spawn);
+
+        Assert.Equal(
+            RuntimeEntityDirectory.FirstLocalEntityId,
+            canonical.LocalEntityId);
+        Assert.True(lifetime.EntityView.TryGet(
+            spawn.Guid,
+            out RuntimeEntitySnapshot snapshot));
+        Assert.Equal(canonical.LocalEntityId, snapshot.Identity.LocalEntityId);
+        Assert.Equal(spawn.InstanceSequence, snapshot.Identity.Incarnation);
+        Assert.Equal(spawn.Position!.Value.LandblockId, snapshot.CellId);
+    }
+
+    [Fact]
+    public void EntityAndInventoryCommits_ShareOnePerGenerationSequence()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        RuntimeGenerationToken generation = new(8);
+        ulong frame = 20;
+        lifetime.BindEventContext(() => generation, () => frame);
+        var observer = new RecordingObserver();
+        using IDisposable subscription = lifetime.Events.Subscribe(observer);
+        WorldSession.EntitySpawn spawn = Spawn(
+            0x70000011u,
+            2,
+            "ordered");
+        RuntimeEntityRecord canonical =
+            lifetime.RegisterEntity(spawn).Canonical!;
+
+        Assert.True(lifetime.ApplyAcceptedSpawn(
+            canonical,
+            canonical.CreateIntegrationVersion,
+            spawn,
+            replaceGeneration: false));
+        frame++;
+        lifetime.Objects.MoveItem(
+            spawn.Guid,
+            newContainerId: 0x50000001u,
+            newSlot: 3);
+        _ = lifetime.RegisterEntity(spawn);
+
+        Assert.Equal(
+            [
+                (RuntimeTraceKind.Entity, 1UL),
+                (RuntimeTraceKind.Inventory, 2UL),
+                (RuntimeTraceKind.Inventory, 3UL),
+                (RuntimeTraceKind.Entity, 4UL),
+            ],
+            observer.Order);
+        Assert.All(
+            observer.Stamps,
+            stamp => Assert.Equal(generation, stamp.Generation));
+        Assert.Equal(20UL, observer.Stamps[0].FrameNumber);
+        Assert.Equal(21UL, observer.Stamps[^1].FrameNumber);
+
+        generation = new RuntimeGenerationToken(9);
+        lifetime.ClearObjects();
+        Assert.Equal(1UL, observer.Stamps[^1].Sequence);
+        Assert.Equal(generation, observer.Stamps[^1].Generation);
+    }
+
+    [Fact]
+    public void InventoryView_UsesCanonicalRuntimeIncarnationWithoutApp()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        WorldSession.EntitySpawn spawn = Spawn(
+            0x70000012u,
+            12,
+            "inventory");
+        RuntimeEntityRecord canonical = Accept(lifetime, spawn);
+        Assert.True(lifetime.ApplyAcceptedSpawn(
+            canonical,
+            canonical.CreateIntegrationVersion,
+            spawn,
+            replaceGeneration: false));
+
+        Assert.True(lifetime.InventoryView.TryGet(
+            spawn.Guid,
+            out RuntimeInventoryItemSnapshot item));
+        Assert.Equal((ushort)12, item.Incarnation);
+        Assert.Equal("inventory", item.Name);
+    }
+
+    [Fact]
+    public void UnknownConfirmedMove_RetainsIdentityAndPlacementInStream()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        var observer = new RecordingObserver();
+        using IDisposable subscription = lifetime.Events.Subscribe(observer);
+
+        Assert.False(lifetime.Objects.ApplyConfirmedServerMove(
+            0x7000DEADu,
+            newContainerId: 0x50000001u,
+            newWielderId: 0u,
+            newSlot: 7));
+
+        RuntimeInventoryDelta moved = Assert.Single(observer.Inventory);
+        Assert.Equal(RuntimeInventoryChange.Moved, moved.Change);
+        Assert.Equal(0x7000DEADu, moved.Item.ObjectId);
+        Assert.Equal(0x50000001u, moved.Item.ContainerId);
+        Assert.Equal(7, moved.Item.ContainerSlot);
+    }
+
+    [Fact]
+    public void EventSubscriptions_AreExactAndDisposeWithoutRetention()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        var observer = new RecordingObserver();
+        IDisposable subscription = lifetime.Events.Subscribe(observer);
+
+        Assert.Equal(1, lifetime.Events.SubscriberCount);
+        Assert.Throws<InvalidOperationException>(
+            () => lifetime.Events.Subscribe(observer));
+
+        subscription.Dispose();
+        subscription.Dispose();
+
+        Assert.Equal(0, lifetime.Events.SubscriberCount);
+    }
+
+    [Fact]
+    public void Dispose_DetachesEveryObserverAndRejectsLaterDispatch()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        var observer = new RecordingObserver();
+        _ = lifetime.Events.Subscribe(observer);
+
+        lifetime.Dispose();
+        lifetime.Dispose();
+
+        Assert.Equal(0, lifetime.Events.SubscriberCount);
+        Assert.Throws<ObjectDisposedException>(
+            () => lifetime.RegisterEntity(
+                Spawn(0x70000018u, 1, "disposed")));
+        lifetime.Objects.AddOrUpdate(new ClientObject
+        {
+            ObjectId = 0x70000019u,
+            Name = "detached",
+        });
+        Assert.Empty(observer.Order);
+    }
+
+    [Fact]
+    public void ObserverFailure_DoesNotInterruptCommitOrLaterObservers()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        var throwing = new CallbackObserver(
+            onEntity: static _ => throw new InvalidOperationException("observer"));
+        var recording = new RecordingObserver();
+        using IDisposable first = lifetime.Events.Subscribe(throwing);
+        using IDisposable second = lifetime.Events.Subscribe(recording);
+
+        RuntimeEntityRegistrationResult result =
+            lifetime.RegisterEntity(Spawn(0x70000015u, 1, "committed"));
+
+        Assert.True(result.LogicalRegistrationCreated);
+        Assert.NotNull(result.Canonical);
+        Assert.True(lifetime.Entities.IsCurrent(result.Canonical));
+        Assert.Single(recording.Entities);
+        Assert.Equal(RuntimeEntityChange.Registered, recording.Entities[0].Change);
+        Assert.Equal(1, lifetime.Events.DispatchFailureCount);
+        Assert.IsType<InvalidOperationException>(
+            lifetime.Events.LastDispatchFailure);
+    }
+
+    [Fact]
+    public void ObserverMutationDuringDispatch_AffectsOnlyLaterCommits()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        var removed = new RecordingObserver();
+        var added = new RecordingObserver();
+        IDisposable? removedSubscription = null;
+        IDisposable? addedSubscription = null;
+        bool mutated = false;
+        var mutating = new CallbackObserver(
+            onEntity: _ =>
+            {
+                if (mutated)
+                    return;
+                mutated = true;
+                removedSubscription!.Dispose();
+                addedSubscription = lifetime.Events.Subscribe(added);
+            });
+        using IDisposable first = lifetime.Events.Subscribe(mutating);
+        removedSubscription = lifetime.Events.Subscribe(removed);
+
+        RuntimeEntityRegistrationResult registration =
+            lifetime.RegisterEntity(Spawn(0x70000016u, 1, "first"));
+        _ = lifetime.RegisterEntity(registration.Canonical!.Snapshot);
+
+        Assert.Single(removed.Entities);
+        Assert.Single(added.Entities);
+        Assert.Equal(
+            RuntimeEntityChange.Registered,
+            removed.Entities[0].Change);
+        Assert.Equal(
+            RuntimeEntityChange.Updated,
+            added.Entities[0].Change);
+
+        addedSubscription!.Dispose();
+        Assert.Equal(1, lifetime.Events.SubscriberCount);
+    }
+
+    [Fact]
+    public void DirectDelete_PublishesTerminalEntityBeforeInventoryRemoval()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        lifetime.BindEventContext(static () => new(4), static () => 11);
+        var observer = new RecordingObserver();
+        using IDisposable subscription = lifetime.Events.Subscribe(observer);
+        WorldSession.EntitySpawn spawn =
+            Spawn(0x70000017u, 5, "delete");
+        RuntimeEntityRegistrationResult registration =
+            lifetime.RegisterEntity(spawn);
+        RuntimeEntityRecord canonical = registration.Canonical!;
+        Assert.True(lifetime.ApplyAcceptedSpawn(
+            canonical,
+            canonical.CreateIntegrationVersion,
+            spawn,
+            replaceGeneration: true));
+
+        Assert.True(lifetime.TryAcceptDelete(
+            new DeleteObject.Parsed(spawn.Guid, spawn.InstanceSequence),
+            isLocalPlayer: false,
+            removeRetainedObject: true,
+            out RuntimeEntityDeleteAcceptance acceptance));
+        lifetime.CompleteAcceptedDelete(acceptance);
+        Assert.Null(lifetime.RetireCanonicalOnly(canonical));
+
+        Assert.Equal(
+            [
+                (RuntimeTraceKind.Entity, 1UL),
+                (RuntimeTraceKind.Inventory, 2UL),
+                (RuntimeTraceKind.Entity, 3UL),
+                (RuntimeTraceKind.Inventory, 4UL),
+            ],
+            observer.Order);
+        Assert.Equal(
+            RuntimeEntityChange.Deleted,
+            observer.Entities[^1].Change);
+        Assert.False(lifetime.EntityView.TryGet(spawn.Guid, out _));
+        Assert.False(lifetime.InventoryView.TryGet(spawn.Guid, out _));
+        Assert.Equal(0, lifetime.Entities.ClaimedLocalIdCount);
+    }
+
+    [Fact]
+    public void SessionClear_SealsOldGenerationAndNextStartsAtOne()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        RuntimeGenerationToken generation = new(12);
+        lifetime.BindEventContext(() => generation, static () => 30UL);
+        var observer = new RecordingObserver();
+        bool rejectedReentrantCreate = false;
+        var reentrant = new CallbackObserver(
+            onEntity: delta =>
+            {
+                if (delta.Change is not RuntimeEntityChange.Deleted)
+                    return;
+                rejectedReentrantCreate = Assert.Throws<InvalidOperationException>(
+                    () => lifetime.RegisterEntity(
+                        Spawn(delta.Entity.Identity.ServerGuid, 2, "stale")))
+                    is not null;
+            });
+        using IDisposable first = lifetime.Events.Subscribe(reentrant);
+        using IDisposable second = lifetime.Events.Subscribe(observer);
+        WorldSession.EntitySpawn spawn =
+            Spawn(0x70000020u, 1, "old");
+        RuntimeEntityRecord canonical =
+            lifetime.RegisterEntity(spawn).Canonical!;
+        Assert.True(lifetime.ApplyAcceptedSpawn(
+            canonical,
+            canonical.CreateIntegrationVersion,
+            spawn,
+            replaceGeneration: true));
+
+        IReadOnlyList<RuntimeEntityRecord> retired =
+            lifetime.BeginSessionClear();
+        lifetime.ClearObjects();
+        Assert.Null(lifetime.RetireCanonicalOnly(Assert.Single(retired)));
+        Assert.True(lifetime.CompleteSessionClearIfConverged());
+
+        generation = new RuntimeGenerationToken(13);
+        RuntimeEntityRecord replacement =
+            lifetime.RegisterEntity(Spawn(spawn.Guid, 2, "new")).Canonical!;
+
+        Assert.True(rejectedReentrantCreate);
+        Assert.Equal((ushort)2, replacement.Incarnation);
+        Assert.Equal(
+            [
+                (new RuntimeGenerationToken(12), 1UL),
+                (new RuntimeGenerationToken(12), 2UL),
+                (new RuntimeGenerationToken(12), 3UL),
+                (new RuntimeGenerationToken(12), 4UL),
+                (new RuntimeGenerationToken(13), 1UL),
+            ],
+            observer.Stamps
+                .Select(stamp => (stamp.Generation, stamp.Sequence))
+                .ToArray());
+    }
+
+    [Fact]
+    public void RegisterEntity_DirectHostPublishesCompleteGenerationOrder()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        lifetime.BindEventContext(static () => new(3), static () => 9);
+        var observer = new RecordingObserver();
+        using IDisposable subscription = lifetime.Events.Subscribe(observer);
+        const uint guid = 0x70000013u;
+
+        RuntimeEntityRegistrationResult first =
+            lifetime.RegisterEntity(Spawn(guid, 1, "first"));
+        RuntimeEntityRegistrationResult refresh =
+            lifetime.RegisterEntity(Spawn(guid, 1, "refresh"));
+        RuntimeEntityRegistrationResult replacement =
+            lifetime.RegisterEntity(Spawn(guid, 2, "replacement"));
+
+        Assert.True(first.LogicalRegistrationCreated);
+        Assert.False(refresh.LogicalRegistrationCreated);
+        Assert.True(replacement.ReplacedExistingGeneration);
+        Assert.Equal(
+            [
+                RuntimeEntityChange.Registered,
+                RuntimeEntityChange.Updated,
+                RuntimeEntityChange.Deleted,
+                RuntimeEntityChange.Registered,
+            ],
+            observer.Entities.Select(delta => delta.Change).ToArray());
+        Assert.Equal(
+            [1UL, 2UL, 3UL, 4UL],
+            observer.Entities
+                .Select(delta => delta.Stamp.Sequence)
+                .ToArray());
+        Assert.Equal(
+            (ushort)2,
+            lifetime.EntityView.TryGet(guid, out RuntimeEntitySnapshot current)
+                ? current.Identity.Incarnation
+                : (ushort)0);
+        Assert.Equal(0, lifetime.Entities.PendingTeardownCount);
+    }
+
+    [Fact]
+    public void RegisterEntity_ReentrantNewerGenerationSupersedesOuterCreate()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        const uint guid = 0x70000014u;
+        _ = lifetime.RegisterEntity(Spawn(guid, 1, "first"));
+        bool nested = false;
+        var observer = new CallbackObserver(
+            onEntity: delta =>
+            {
+                if (nested
+                    || delta.Change is not RuntimeEntityChange.Deleted)
+                {
+                    return;
+                }
+
+                nested = true;
+                _ = lifetime.RegisterEntity(Spawn(guid, 3, "nested"));
+            });
+        using IDisposable subscription = lifetime.Events.Subscribe(observer);
+
+        RuntimeEntityRegistrationResult outer =
+            lifetime.RegisterEntity(Spawn(guid, 2, "outer"));
+
+        Assert.Equal(
+            CreateObjectTimestampDisposition.StaleGeneration,
+            outer.Inbound.Disposition);
+        Assert.False(outer.LogicalRegistrationCreated);
+        Assert.True(lifetime.Entities.TryGetActive(
+            guid,
+            out RuntimeEntityRecord current));
+        Assert.Equal((ushort)3, current.Incarnation);
+        Assert.NotNull(current.LocalEntityId);
+    }
+
+    [Fact]
+    public void RegisterEntity_ReentrantDeleteSupersedesSameGenerationRefresh()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        const uint guid = 0x70000021u;
+        RuntimeEntityRecord first =
+            lifetime.RegisterEntity(Spawn(guid, 1, "first")).Canonical!;
+        bool deleted = false;
+        var observer = new CallbackObserver(
+            onEntity: delta =>
+            {
+                if (deleted
+                    || delta.Change is not RuntimeEntityChange.Updated)
+                {
+                    return;
+                }
+
+                deleted = lifetime.TryAcceptDelete(
+                    new DeleteObject.Parsed(guid, 1),
+                    isLocalPlayer: false,
+                    removeRetainedObject: false,
+                    out RuntimeEntityDeleteAcceptance acceptance);
+                if (deleted)
+                {
+                    lifetime.CompleteAcceptedDelete(acceptance);
+                    Assert.Null(lifetime.RetireCanonicalOnly(first));
+                }
+            });
+        using IDisposable subscription = lifetime.Events.Subscribe(observer);
+
+        RuntimeEntityRegistrationResult refresh =
+            lifetime.RegisterEntity(Spawn(guid, 1, "refresh"));
+
+        Assert.True(deleted);
+        Assert.Equal(
+            CreateObjectTimestampDisposition.StaleGeneration,
+            refresh.Inbound.Disposition);
+        Assert.Null(refresh.Canonical);
+        Assert.False(lifetime.Entities.TryGetActive(guid, out _));
+    }
+
+    [Fact]
+    public void RegisterEntity_ReentrantReplacementSupersedesInitialCommit()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        const uint guid = 0x70000022u;
+        bool replaced = false;
+        var observer = new CallbackObserver(
+            onEntity: delta =>
+            {
+                if (replaced
+                    || delta.Change is not RuntimeEntityChange.Registered
+                    || delta.Entity.Identity.Incarnation != 1)
+                {
+                    return;
+                }
+
+                replaced = true;
+                _ = lifetime.RegisterEntity(Spawn(guid, 2, "replacement"));
+            });
+        using IDisposable subscription = lifetime.Events.Subscribe(observer);
+
+        RuntimeEntityRegistrationResult outer =
+            lifetime.RegisterEntity(Spawn(guid, 1, "outer"));
+
+        Assert.True(replaced);
+        Assert.Equal(
+            CreateObjectTimestampDisposition.StaleGeneration,
+            outer.Inbound.Disposition);
+        Assert.False(outer.LogicalRegistrationCreated);
+        Assert.Equal(
+            (ushort)2,
+            Assert.IsType<RuntimeEntityRecord>(outer.Canonical).Incarnation);
+    }
+
+    [Fact]
+    public void AcceptedUpdate_RevalidatesAfterReentrantTerminalObserver()
+    {
+        var lifetime = new RuntimeEntityObjectLifetime();
+        const uint guid = 0x70000023u;
+        RuntimeEntityRecord canonical =
+            lifetime.RegisterEntity(Spawn(guid, 1, "vector")).Canonical!;
+        bool deleted = false;
+        var observer = new CallbackObserver(
+            onEntity: delta =>
+            {
+                if (deleted
+                    || delta.Change is not RuntimeEntityChange.Updated)
+                {
+                    return;
+                }
+
+                deleted = lifetime.TryAcceptDelete(
+                    new DeleteObject.Parsed(guid, 1),
+                    isLocalPlayer: false,
+                    removeRetainedObject: false,
+                    out RuntimeEntityDeleteAcceptance acceptance);
+                if (deleted)
+                {
+                    lifetime.CompleteAcceptedDelete(acceptance);
+                    Assert.Null(lifetime.RetireCanonicalOnly(canonical));
+                }
+            });
+        using IDisposable subscription = lifetime.Events.Subscribe(observer);
+
+        bool remainedCurrent = lifetime.TryApplyVector(
+            new VectorUpdate.Parsed(
+                guid,
+                new System.Numerics.Vector3(1f, 0f, 0f),
+                System.Numerics.Vector3.Zero,
+                InstanceSequence: 1,
+                VectorSequence: 2),
+            acknowledgeProjection: null,
+            out _);
+
+        Assert.True(deleted);
+        Assert.False(remainedCurrent);
+        Assert.False(lifetime.Entities.TryGetActive(guid, out _));
+    }
+
     private static RuntimeEntityRecord Accept(
         RuntimeEntityObjectLifetime lifetime,
         WorldSession.EntitySpawn spawn)
@@ -248,4 +758,38 @@ public sealed class RuntimeEntityObjectLifetimeTests
             PositionSequence: 1,
             Physics: physics);
     }
+
+    private sealed class RecordingObserver : IRuntimeEntityObjectObserver
+    {
+        public List<(RuntimeTraceKind Kind, ulong Sequence)> Order { get; } = [];
+        public List<RuntimeEventStamp> Stamps { get; } = [];
+        public List<RuntimeEntityDelta> Entities { get; } = [];
+        public List<RuntimeInventoryDelta> Inventory { get; } = [];
+
+        public void OnEntity(in RuntimeEntityDelta delta)
+        {
+            Order.Add((RuntimeTraceKind.Entity, delta.Stamp.Sequence));
+            Stamps.Add(delta.Stamp);
+            Entities.Add(delta);
+        }
+
+        public void OnInventory(in RuntimeInventoryDelta delta)
+        {
+            Order.Add((RuntimeTraceKind.Inventory, delta.Stamp.Sequence));
+            Stamps.Add(delta.Stamp);
+            Inventory.Add(delta);
+        }
+    }
+
+    private sealed class CallbackObserver(
+        Action<RuntimeEntityDelta>? onEntity = null,
+        Action<RuntimeInventoryDelta>? onInventory = null)
+        : IRuntimeEntityObjectObserver
+    {
+        public void OnEntity(in RuntimeEntityDelta delta) =>
+            onEntity?.Invoke(delta);
+
+        public void OnInventory(in RuntimeInventoryDelta delta) =>
+            onInventory?.Invoke(delta);
+    }
 }

tests/AcDream.Runtime.Tests/GameRuntimeContractTests.cs

@@ -80,6 +80,21 @@ public sealed class GameRuntimeContractTests
         Assert.Equal(99UL, independent.FrameNumber);
     }
 
+    [Fact]
+    public void EventSequencer_RestartsAtOneForEachSessionGeneration()
+    {
+        var sequencer = new RuntimeEventSequencer();
+
+        RuntimeEventStamp first = sequencer.Next(new(4), 10);
+        RuntimeEventStamp second = sequencer.Next(new(4), 11);
+        RuntimeEventStamp replacement = sequencer.Next(new(5), 12);
+
+        Assert.Equal(1UL, first.Sequence);
+        Assert.Equal(2UL, second.Sequence);
+        Assert.Equal(1UL, replacement.Sequence);
+        Assert.Equal(new RuntimeGenerationToken(5), replacement.Generation);
+    }
+
     [Fact]
     public void TraceRecorderNormalizesTypedDeltasWithoutRetainingOwners()
     {