feat(runtime): atomically replace collision generations

src/AcDream.Runtime/Physics/RuntimePhysicsState.cs

@@ -37,6 +37,8 @@ public readonly record struct RuntimePhysicsOwnershipSnapshot(
     bool IsCollisionReportDispatching,
     int CollisionPrefixQuiescenceCount,
     int PendingCollisionPrefixProjectionCount,
+    int CollisionPrefixMutationCount,
+    int CommittedCollisionPrefixMutationCount,
     int CollisionAdmissionCount,
     int CollisionGenerationCount,
     bool OwnsProductionDataCache,
@@ -75,6 +77,8 @@ public readonly record struct RuntimePhysicsOwnershipSnapshot(
         && !IsCollisionReportDispatching
         && CollisionPrefixQuiescenceCount == 0
         && PendingCollisionPrefixProjectionCount == 0
+        && CollisionPrefixMutationCount == 0
+        && CommittedCollisionPrefixMutationCount == 0
         && CollisionAdmissionCount == 0
         && CollisionGenerationCount == 0
         && OwnsProductionDataCache;
@@ -100,11 +104,13 @@ public sealed class RuntimeCollisionAdmission
     internal RuntimeCollisionAdmission(
         RuntimePhysicsState owner,
         uint landblockId,
-        ulong generation)
+        ulong generation,
+        ulong previousGeneration)
     {
         Owner = owner;
         LandblockId = landblockId;
         Generation = generation;
+        PreviousGeneration = previousGeneration;
     }
 
     internal RuntimePhysicsState Owner { get; }
@@ -112,6 +118,32 @@ public sealed class RuntimeCollisionAdmission
     internal bool Completed { get; set; }
     public uint LandblockId { get; }
     public ulong Generation { get; }
+    internal ulong PreviousGeneration { get; }
+}
+
+internal enum RuntimeCollisionPrefixMutationKind : byte
+{
+    Activation,
+    Demotion,
+    Withdrawal,
+}
+
+internal sealed class RuntimeCollisionPrefixMutation
+{
+    internal required RuntimeCollisionPrefixMutationKind Kind { get; init; }
+    internal required uint LandblockId { get; init; }
+    internal required ulong PreviousGeneration { get; init; }
+    internal required ulong TargetGeneration { get; init; }
+    internal ulong InvalidatedGeneration { get; init; }
+    internal required RuntimeCollisionPrefixQuiescenceToken Quiescence
+        { get; init; }
+    internal RuntimeCollisionAdmission? Admission { get; init; }
+    internal PreparedLandblockCollisionGeneration? Prepared { get; init; }
+    internal RuntimeCollisionPrefixMutationPermission Permission { get; set; }
+    internal bool EngineMutationCommitted { get; set; }
+    internal bool CancellationRequested { get; set; }
+    internal bool WasResident { get; set; }
+    internal bool Ready { get; set; }
 }
 
 public readonly record struct RuntimeCollisionAcknowledgement(
@@ -120,11 +152,23 @@ public readonly record struct RuntimeCollisionAcknowledgement(
     bool WasResident,
     bool Ready);
 
+public readonly record struct RuntimeCollisionMutationResult(
+    RuntimeCollisionAcknowledgement Acknowledgement,
+    bool Completed)
+{
+    public uint LandblockId => Acknowledgement.LandblockId;
+    public ulong Generation => Acknowledgement.Generation;
+    public bool WasResident => Acknowledgement.WasResident;
+    public bool Ready => Acknowledgement.Ready;
+}
+
 public readonly record struct RuntimeCollisionGenerationCommit(
     RuntimeCollisionAcknowledgement Acknowledgement,
-    uint[] DirtyRetainedOwnerIds)
+    uint[] DirtyRetainedOwnerIds,
+    bool EngineCommitted,
+    bool Completed)
 {
-    public bool Committed => Acknowledgement.Ready;
+    public bool Committed => Completed;
 }
 
 public readonly record struct RuntimeCollisionGenerationCommitted(
@@ -1045,6 +1089,8 @@ public sealed class RuntimePhysicsState : IDisposable
         _collisionAdmissions = new();
     private readonly Dictionary<uint, PreparedLandblockCollisionGeneration>
         _preparedCollisionGenerations = new();
+    private readonly Dictionary<uint, RuntimeCollisionPrefixMutation>
+        _collisionPrefixMutations = new();
     private readonly CollisionOwnerMutationJournal _collisionOwnerJournal = new();
     private readonly Dictionary<uint, List<PreparedLandblockCollisionGeneration>>
         _collisionOwnerSubscribers = new();
@@ -1175,6 +1221,9 @@ public sealed class RuntimePhysicsState : IDisposable
             collisionReports.IsDispatching,
             setPosition.CollisionPrefixQuiescenceCount,
             setPosition.PendingQuiescenceProjectionCount,
+            _collisionPrefixMutations.Count,
+            _collisionPrefixMutations.Values.Count(
+                mutation => mutation.EngineMutationCommitted),
             _collisionAdmissions.Count,
             _collisionGenerations.Count,
             ReferenceEquals(Engine.DataCache, DataCache),
@@ -1907,6 +1956,29 @@ public sealed class RuntimePhysicsState : IDisposable
         _spatialRoots.Clear();
     }
 
+    internal void ResetSessionPhysics()
+    {
+        EnsureNotDisposed();
+        // GameRuntime serializes reset after the host update loop has stopped.
+        // Reset may therefore run on the lifecycle/disposal thread rather than
+        // the retired generation's update thread. It clears every mutation
+        // owner before releasing affinity so the next generation can bind its
+        // own update thread without admitting concurrent mutation.
+        foreach ((_, PreparedLandblockCollisionGeneration prepared) in
+                 _preparedCollisionGenerations)
+        {
+            prepared.Dispose();
+        }
+        _preparedCollisionGenerations.Clear();
+        _collisionPrefixMutations.Clear();
+        _collisionAdmissions.Clear();
+        SetPosition.ResetSession();
+        CollisionReports.ResetSession();
+        TrimCollisionOwnerJournal();
+        AdvanceCollisionWorldAuthority();
+        Volatile.Write(ref _collisionMutationThreadId, 0);
+    }
+
     internal RuntimeCollisionPrefixQuiescenceToken
         BeginCollisionPrefixQuiescence(
             uint landblockId,
@@ -1957,25 +2029,29 @@ public sealed class RuntimePhysicsState : IDisposable
             successorReady);
     }
 
-    internal bool CompleteCollisionPrefixQuiescence(
-        in RuntimeCollisionPrefixMutationPermission permission)
-    {
-        EnsureNotDisposed();
-        EnsureCollisionMutationThread();
-        return SetPosition.CompleteCollisionPrefixQuiescence(permission);
-    }
-
     public RuntimeCollisionAdmission BeginCollisionAdmission(
         uint landblockId)
     {
         EnsureNotDisposed();
         EnsureCollisionMutationThread();
         uint canonical = CanonicalLandblock(landblockId);
+        if (_collisionPrefixMutations.ContainsKey(canonical))
+        {
+            throw new InvalidOperationException(
+                $"Collision prefix 0x{canonical:X8} is still completing its previous mutation transaction.");
+        }
+        ulong currentGeneration = _collisionGenerations.TryGetValue(
+            canonical,
+            out ulong current)
+                ? current
+                : 0UL;
+        ulong previousGeneration = currentGeneration;
         AdvanceCollisionWorldAuthority();
         if (_collisionAdmissions.Remove(
                 canonical,
                 out RuntimeCollisionAdmission? superseded))
         {
+            previousGeneration = superseded.PreviousGeneration;
             SetPosition.CancelCollisionGeneration(
                 canonical,
                 superseded.Generation);
@@ -1986,16 +2062,13 @@ public sealed class RuntimePhysicsState : IDisposable
                 prepared.Dispose();
             }
         }
-        ulong generation = _collisionGenerations.TryGetValue(
-            canonical,
-            out ulong current)
-                ? checked(current + 1UL)
-                : 1UL;
+        ulong generation = checked(currentGeneration + 1UL);
         _collisionGenerations[canonical] = generation;
         var admission = new RuntimeCollisionAdmission(
             this,
             canonical,
-            generation);
+            generation,
+            previousGeneration);
         _collisionAdmissions[canonical] = admission;
         SetPosition.BeginCollisionGeneration(canonical, generation);
         return admission;
@@ -2047,7 +2120,7 @@ public sealed class RuntimePhysicsState : IDisposable
     /// collision world is never withdrawn. A stale receipt may dispose its
     /// own staging storage but cannot invalidate a newer admission.
     /// </summary>
-    internal void CancelCollisionGeneration(
+    internal bool CancelCollisionGeneration(
         RuntimeCollisionAdmission admission,
         PreparedLandblockCollisionGeneration? prepared = null)
     {
@@ -2067,6 +2140,38 @@ public sealed class RuntimePhysicsState : IDisposable
                 nameof(prepared));
         }
 
+        if (_collisionPrefixMutations.TryGetValue(
+                admission.LandblockId,
+                out RuntimeCollisionPrefixMutation? mutation))
+        {
+            if (mutation.Kind is not RuntimeCollisionPrefixMutationKind.Activation
+                || !ReferenceEquals(mutation.Admission, admission)
+                || (prepared is not null
+                    && !ReferenceEquals(mutation.Prepared, prepared)))
+            {
+                return false;
+            }
+            if (mutation.EngineMutationCommitted)
+                return AdvanceCommittedActivation(mutation).Committed;
+
+            mutation.CancellationRequested = true;
+            bool previousReady = mutation.PreviousGeneration != 0UL
+                && Engine.IsLandblockTerrainResident(
+                    mutation.LandblockId);
+            bool released = mutation.PreviousGeneration == 0UL
+                ? SetPosition.CancelCollisionPrefixQuiescenceToUnavailable(
+                    mutation.Quiescence)
+                : CancelCollisionPrefixQuiescence(
+                    mutation.Quiescence,
+                    mutation.PreviousGeneration,
+                    previousReady);
+            if (!released)
+            {
+                return false;
+            }
+            _collisionPrefixMutations.Remove(mutation.LandblockId);
+        }
+
         prepared?.Dispose();
         if (prepared is not null
             && _preparedCollisionGenerations.TryGetValue(
@@ -2090,6 +2195,7 @@ public sealed class RuntimePhysicsState : IDisposable
             AdvanceCollisionWorldAuthority();
         }
         TrimCollisionOwnerJournal();
+        return true;
     }
 
     internal void StageCollisionAssets(
@@ -2261,8 +2367,29 @@ public sealed class RuntimePhysicsState : IDisposable
         RuntimeCollisionAdmission admission,
         PreparedLandblockCollisionGeneration prepared)
     {
-        ValidateAdmission(admission);
+        EnsureNotDisposed();
         EnsureCollisionMutationThread();
+        ArgumentNullException.ThrowIfNull(admission);
+        ArgumentNullException.ThrowIfNull(prepared);
+
+        if (_collisionPrefixMutations.TryGetValue(
+                admission.LandblockId,
+                out RuntimeCollisionPrefixMutation? pending))
+        {
+            if (pending.Kind is not RuntimeCollisionPrefixMutationKind.Activation
+                || !ReferenceEquals(pending.Admission, admission)
+                || !ReferenceEquals(pending.Prepared, prepared))
+            {
+                throw new InvalidOperationException(
+                    "A different collision-prefix mutation owns this landblock.");
+            }
+            if (pending.EngineMutationCommitted)
+                return AdvanceCommittedActivation(pending);
+            if (pending.CancellationRequested)
+                return PendingActivation(pending);
+        }
+
+        ValidateAdmission(admission);
         ValidatePreparedGeneration(admission, prepared);
         if (!admission.AssetsPrepared)
         {
@@ -2292,8 +2419,62 @@ public sealed class RuntimePhysicsState : IDisposable
                     admission.Generation,
                     Engine.IsLandblockTerrainResident(admission.LandblockId),
                     Ready: false),
-                Array.Empty<uint>());
+                Array.Empty<uint>(),
+                EngineCommitted: false,
+                Completed: false);
         }
+
+        RuntimeCollisionPrefixMutation mutation;
+        if (!_collisionPrefixMutations.TryGetValue(
+                admission.LandblockId,
+                out mutation!))
+        {
+            RuntimeCollisionPrefixQuiescenceToken token =
+                BeginCollisionPrefixQuiescence(
+                    admission.LandblockId,
+                    admission.Generation,
+                    includeOutdoorCells: true);
+            mutation = new RuntimeCollisionPrefixMutation
+            {
+                Kind = RuntimeCollisionPrefixMutationKind.Activation,
+                LandblockId = admission.LandblockId,
+                PreviousGeneration = admission.PreviousGeneration,
+                TargetGeneration = admission.Generation,
+                Quiescence = token,
+                Admission = admission,
+                Prepared = prepared,
+                WasResident = Engine.IsLandblockTerrainResident(
+                    admission.LandblockId),
+            };
+            _collisionPrefixMutations.Add(admission.LandblockId, mutation);
+
+            // The first poll deliberately closes the prefix and marks its
+            // resident-parking pass complete, even when the prefix is empty.
+            // A later poll alone may consume mutation permission; affected
+            // residents also require their exact Withdraw acknowledgements.
+        }
+
+        if (!TryAcquireCollisionPrefixMutationPermission(
+                mutation.Quiescence,
+                out RuntimeCollisionPrefixMutationPermission permission))
+        {
+            return PendingActivation(mutation);
+        }
+        mutation.Permission = permission;
+
+        // Parking a live owner writes to the canonical shadow journal. The
+        // prepared replacement must be resealed against that exact journal
+        // tail before permission can be consumed.
+        if (!IsCollisionPrefixMutationPermissionCurrent(permission)
+            || !prepared.IsOwnerMutationReconciliationCurrent
+            || !prepared.IsReadyForActivation
+            || HasOlderPreparedGeneration(prepared)
+            || prepared.HasPendingCommittedRebase
+            || prepared.HasPendingRetirement)
+        {
+            return PendingActivation(mutation);
+        }
+
         PhysicsEngine.PreparedPhysicsEngineLandblock replacement =
             prepared.TakeSealedReplacement();
         bool suppressOwnerJournal = _suppressCollisionOwnerJournal;
@@ -2313,20 +2494,70 @@ public sealed class RuntimePhysicsState : IDisposable
             if (later.Sequence > prepared.Sequence)
                 later.EnqueueCommittedRebase(replacement);
         }
-        admission.Completed = true;
-        _collisionAdmissions.Remove(admission.LandblockId);
         _preparedCollisionGenerations.Remove(admission.LandblockId);
         prepared.MarkCommitted();
-        TrimCollisionOwnerJournal();
-        var acknowledgement = new RuntimeCollisionAcknowledgement(
-            admission.LandblockId,
-            admission.Generation,
-            Engine.IsLandblockTerrainResident(admission.LandblockId),
-            Ready: Engine.IsLandblockTerrainResident(admission.LandblockId));
+        mutation.EngineMutationCommitted = true;
+        mutation.Ready = Engine.IsLandblockTerrainResident(
+            admission.LandblockId);
+        mutation.WasResident = mutation.Ready;
         SetPosition.CommitCollisionGeneration(
-            acknowledgement.LandblockId,
-            acknowledgement.Generation,
-            acknowledgement.Ready);
+            mutation.LandblockId,
+            mutation.TargetGeneration,
+            mutation.Ready);
+        RuntimeCollisionGenerationCommit completed =
+            AdvanceCommittedActivation(mutation);
+        return completed;
+    }
+
+    private RuntimeCollisionGenerationCommit PendingActivation(
+        RuntimeCollisionPrefixMutation mutation) => new(
+        new RuntimeCollisionAcknowledgement(
+            mutation.LandblockId,
+            mutation.TargetGeneration,
+            mutation.WasResident,
+            Ready: mutation.EngineMutationCommitted && mutation.Ready),
+        Array.Empty<uint>(),
+        EngineCommitted: mutation.EngineMutationCommitted,
+        Completed: false);
+
+    private RuntimeCollisionGenerationCommit AdvanceCommittedActivation(
+        RuntimeCollisionPrefixMutation mutation)
+    {
+        if (!mutation.EngineMutationCommitted)
+            throw new InvalidOperationException(
+                "Collision activation cannot release before its engine transaction commits.");
+
+        bool completed = SetPosition.ReleaseCollisionPrefixAfterMutation(
+            mutation.Quiescence,
+            mutation.TargetGeneration,
+            mutation.Ready);
+        var acknowledgement = new RuntimeCollisionAcknowledgement(
+            mutation.LandblockId,
+            mutation.TargetGeneration,
+            mutation.WasResident,
+            mutation.Ready);
+        if (!completed)
+        {
+            return new RuntimeCollisionGenerationCommit(
+                acknowledgement,
+                Array.Empty<uint>(),
+                EngineCommitted: true,
+                Completed: false);
+        }
+
+        RuntimeCollisionAdmission admission = mutation.Admission
+            ?? throw new InvalidOperationException(
+                "Collision activation lost its admission owner.");
+        admission.Completed = true;
+        if (_collisionAdmissions.TryGetValue(
+                mutation.LandblockId,
+                out RuntimeCollisionAdmission? current)
+            && ReferenceEquals(current, admission))
+        {
+            _collisionAdmissions.Remove(mutation.LandblockId);
+        }
+        _collisionPrefixMutations.Remove(mutation.LandblockId);
+        TrimCollisionOwnerJournal();
         PublishCollisionGenerationCommitted(
             new RuntimeCollisionGenerationCommitted(
                 acknowledgement.LandblockId,
@@ -2334,67 +2565,179 @@ public sealed class RuntimePhysicsState : IDisposable
                 acknowledgement.Ready));
         return new RuntimeCollisionGenerationCommit(
             acknowledgement,
-            Array.Empty<uint>());
+            Array.Empty<uint>(),
+            EngineCommitted: true,
+            Completed: true);
     }
 
-    public RuntimeCollisionAcknowledgement DemoteCollisionToTerrain(
+    private static RuntimeCollisionMutationResult PendingRetirement(
+        RuntimeCollisionPrefixMutation mutation) => new(
+        new RuntimeCollisionAcknowledgement(
+            mutation.LandblockId,
+            mutation.TargetGeneration,
+            mutation.WasResident,
+            Ready: mutation.EngineMutationCommitted && mutation.Ready),
+        Completed: false);
+
+    private void CommitCollisionInvalidation(
+        RuntimeCollisionPrefixMutation mutation)
+    {
+        _collisionGenerations[mutation.LandblockId] =
+            mutation.TargetGeneration;
+        SetPosition.CancelCollisionGeneration(
+            mutation.LandblockId,
+            mutation.InvalidatedGeneration);
+        if (_collisionAdmissions.TryGetValue(
+                mutation.LandblockId,
+                out RuntimeCollisionAdmission? currentAdmission)
+            && ReferenceEquals(currentAdmission, mutation.Admission))
+        {
+            _collisionAdmissions.Remove(mutation.LandblockId);
+        }
+        if (_preparedCollisionGenerations.TryGetValue(
+                mutation.LandblockId,
+                out PreparedLandblockCollisionGeneration? currentPrepared)
+            && ReferenceEquals(currentPrepared, mutation.Prepared))
+        {
+            _preparedCollisionGenerations.Remove(mutation.LandblockId);
+            currentPrepared.Dispose();
+        }
+    }
+
+    public RuntimeCollisionMutationResult DemoteCollisionToTerrain(
         uint landblockId)
+        => AdvanceCollisionRetirementMutation(
+            landblockId,
+            RuntimeCollisionPrefixMutationKind.Demotion);
+
+    public RuntimeCollisionMutationResult WithdrawCollision(
+        uint landblockId)
+        => AdvanceCollisionRetirementMutation(
+            landblockId,
+            RuntimeCollisionPrefixMutationKind.Withdrawal);
+
+    private RuntimeCollisionMutationResult AdvanceCollisionRetirementMutation(
+        uint landblockId,
+        RuntimeCollisionPrefixMutationKind kind)
     {
         EnsureNotDisposed();
         EnsureCollisionMutationThread();
         uint canonical = CanonicalLandblock(landblockId);
-        bool resident = Engine.IsLandblockTerrainResident(canonical);
-        InvalidateCollisionAdmission(canonical);
-        bool suppressOwnerJournal = _suppressCollisionOwnerJournal;
-        _suppressCollisionOwnerJournal = true;
-        try
-        {
-            Engine.DemoteLandblockToTerrain(canonical);
-        }
-        finally
-        {
-            _suppressCollisionOwnerJournal = suppressOwnerJournal;
-        }
-        foreach ((_, PreparedLandblockCollisionGeneration prepared) in
-                 _preparedCollisionGenerations)
-        {
-            prepared.RecordDemotion(canonical);
-        }
-        return new RuntimeCollisionAcknowledgement(
-            canonical,
-            _collisionGenerations[canonical],
-            resident,
-            Ready: Engine.IsLandblockTerrainResident(canonical));
-    }
+        if (canonical == 0u)
+            throw new ArgumentOutOfRangeException(nameof(landblockId));
+        if (kind is RuntimeCollisionPrefixMutationKind.Activation)
+            throw new ArgumentOutOfRangeException(nameof(kind));
 
-    public RuntimeCollisionAcknowledgement WithdrawCollision(
-        uint landblockId)
-    {
-        EnsureNotDisposed();
-        EnsureCollisionMutationThread();
-        uint canonical = CanonicalLandblock(landblockId);
-        bool resident = Engine.IsLandblockTerrainResident(canonical);
-        InvalidateCollisionAdmission(canonical);
-        bool suppressOwnerJournal = _suppressCollisionOwnerJournal;
-        _suppressCollisionOwnerJournal = true;
-        try
+        if (!_collisionPrefixMutations.TryGetValue(
+                canonical,
+                out RuntimeCollisionPrefixMutation? mutation))
         {
-            Engine.RemoveLandblock(canonical);
+            ulong currentGeneration = _collisionGenerations.TryGetValue(
+                canonical,
+                out ulong current)
+                    ? current
+                    : 0UL;
+            RuntimeCollisionAdmission? admission =
+                _collisionAdmissions.GetValueOrDefault(canonical);
+            ulong previousGeneration = admission?.PreviousGeneration
+                ?? currentGeneration;
+            ulong invalidatedGeneration = admission is not null
+                    ? admission.Generation
+                    : checked(currentGeneration + 1UL);
+            ulong targetGeneration = checked(
+                Math.Max(currentGeneration, invalidatedGeneration) + 1UL);
+            SetPosition.BeginCollisionGeneration(
+                canonical,
+                targetGeneration);
+            RuntimeCollisionPrefixQuiescenceToken token =
+                BeginCollisionPrefixQuiescence(
+                    canonical,
+                    targetGeneration,
+                    includeOutdoorCells:
+                        kind is RuntimeCollisionPrefixMutationKind.Withdrawal);
+            mutation = new RuntimeCollisionPrefixMutation
+            {
+                Kind = kind,
+                LandblockId = canonical,
+                PreviousGeneration = previousGeneration,
+                InvalidatedGeneration = invalidatedGeneration,
+                TargetGeneration = targetGeneration,
+                Quiescence = token,
+                Admission = admission,
+                Prepared = _preparedCollisionGenerations.GetValueOrDefault(
+                    canonical),
+                WasResident = Engine.IsLandblockTerrainResident(canonical),
+            };
+            _collisionPrefixMutations.Add(canonical, mutation);
         }
-        finally
+        if (mutation.Kind != kind)
         {
-            _suppressCollisionOwnerJournal = suppressOwnerJournal;
+            throw new InvalidOperationException(
+                "A different collision-prefix mutation owns this landblock.");
         }
-        foreach ((_, PreparedLandblockCollisionGeneration prepared) in
-                 _preparedCollisionGenerations)
+
+        if (!mutation.EngineMutationCommitted)
         {
-            prepared.RecordWithdrawal(canonical);
+            if (!TryAcquireCollisionPrefixMutationPermission(
+                    mutation.Quiescence,
+                    out RuntimeCollisionPrefixMutationPermission permission)
+                || !IsCollisionPrefixMutationPermissionCurrent(permission))
+            {
+                return PendingRetirement(mutation);
+            }
+            mutation.Permission = permission;
+            CommitCollisionInvalidation(mutation);
+
+            bool suppressOwnerJournal = _suppressCollisionOwnerJournal;
+            _suppressCollisionOwnerJournal = true;
+            try
+            {
+                if (kind is RuntimeCollisionPrefixMutationKind.Demotion)
+                    Engine.DemoteLandblockToTerrain(canonical);
+                else
+                    Engine.RemoveLandblock(canonical);
+                AdvanceCollisionWorldAuthority();
+            }
+            finally
+            {
+                _suppressCollisionOwnerJournal = suppressOwnerJournal;
+            }
+            foreach ((_, PreparedLandblockCollisionGeneration prepared) in
+                     _preparedCollisionGenerations)
+            {
+                if (kind is RuntimeCollisionPrefixMutationKind.Demotion)
+                    prepared.RecordDemotion(canonical);
+                else
+                    prepared.RecordWithdrawal(canonical);
+            }
+            mutation.EngineMutationCommitted = true;
+            mutation.Ready = kind is RuntimeCollisionPrefixMutationKind.Demotion
+                && Engine.IsLandblockTerrainResident(canonical);
+            if (mutation.Ready)
+            {
+                SetPosition.CommitCollisionGeneration(
+                    canonical,
+                    mutation.TargetGeneration,
+                    ready: true);
+            }
         }
-        return new RuntimeCollisionAcknowledgement(
-            canonical,
-            _collisionGenerations[canonical],
-            resident,
-            Ready: false);
+
+        bool completed = SetPosition.ReleaseCollisionPrefixAfterMutation(
+            mutation.Quiescence,
+            mutation.TargetGeneration,
+            mutation.Ready);
+        if (completed)
+        {
+            _collisionPrefixMutations.Remove(canonical);
+            TrimCollisionOwnerJournal();
+        }
+        return new RuntimeCollisionMutationResult(
+            new RuntimeCollisionAcknowledgement(
+                canonical,
+                mutation.TargetGeneration,
+                mutation.WasResident,
+                mutation.Ready),
+            completed);
     }
 
     public void Dispose()
@@ -2419,6 +2762,7 @@ public sealed class RuntimePhysicsState : IDisposable
         _spatialRemotes.Clear();
         _spatialProjectiles.Clear();
         _spatialRoots.Clear();
+        _collisionPrefixMutations.Clear();
         _collisionAdmissions.Clear();
         _collisionGenerations.Clear();
         CellCommitted = null;
@@ -2570,35 +2914,6 @@ public sealed class RuntimePhysicsState : IDisposable
         }
     }
 
-    private void InvalidateCollisionAdmission(uint landblockId)
-    {
-        AdvanceCollisionWorldAuthority();
-        ulong currentGeneration = _collisionGenerations.TryGetValue(
-            landblockId,
-            out ulong current)
-                ? current
-                : 0UL;
-        ulong invalidatedGeneration = _collisionAdmissions.TryGetValue(
-            landblockId,
-            out RuntimeCollisionAdmission? admission)
-                ? admission.Generation
-                : checked(currentGeneration + 1UL);
-        ulong generation = checked(
-            Math.Max(currentGeneration, invalidatedGeneration) + 1UL);
-        _collisionGenerations[landblockId] = generation;
-        SetPosition.CancelCollisionGeneration(
-            landblockId,
-            invalidatedGeneration);
-        _collisionAdmissions.Remove(landblockId);
-        if (_preparedCollisionGenerations.Remove(
-                landblockId,
-                out PreparedLandblockCollisionGeneration? prepared))
-        {
-            prepared.Dispose();
-        }
-        TrimCollisionOwnerJournal();
-    }
-
     internal bool TryPrepareSpatialRootAdmission(RuntimeEntityRecord record)
     {
         EnsureNotDisposed();
@@ -2960,7 +3275,13 @@ public sealed class RuntimePhysicsState : IDisposable
         {
             return;
         }
-        subscribers.Remove(prepared);
+        for (int index = 0; index < subscribers.Count; index++)
+        {
+            if (!ReferenceEquals(subscribers[index], prepared))
+                continue;
+            subscribers.RemoveAt(index);
+            break;
+        }
         if (subscribers.Count == 0)
             _collisionOwnerSubscribers.Remove(ownerId);
     }