feat(runtime): commit dormant SetPosition activation

tests/AcDream.Runtime.Tests/Gameplay/RuntimeLocalPlayerPhysicsPublicationStateTests.cs

@@ -45,6 +45,30 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
         Assert.True(token.IsValid);
     }
 
+    [Fact]
+    public void ActivationIdExhaustionMutatesNoCandidateOrCanonicalOwner()
+    {
+        using var fixture = new Fixture();
+        typeof(RuntimeLocalPlayerPhysicsPublicationState)
+            .GetField(
+                "_nextActivationId",
+                System.Reflection.BindingFlags.Instance
+                    | System.Reflection.BindingFlags.NonPublic)!
+            .SetValue(fixture.Owner, ulong.MaxValue);
+
+        Assert.Throws<OverflowException>(() => fixture.Prepare());
+
+        Assert.Null(fixture.Record.PhysicsBody);
+        Assert.Null(fixture.Movement.Controller);
+        Assert.Equal(0, fixture.Owner.CaptureOwnership().CandidateCount);
+        Assert.Equal(0, fixture.Owner.CaptureOwnership().PendingActivationCount);
+        Assert.True(fixture.Lifetime.Physics.SetPosition
+            .IsExactPreparedPlacementCurrent(
+                fixture.Record,
+                fixture.Placement,
+                fixture.Command));
+    }
+
     [Fact]
     public void CommitOwnsExactDormantBodyAndControllerWithoutWorldEdges()
     {
@@ -115,6 +139,39 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
             fixture.Owner.Commit(token));
     }
 
+    [Fact]
+    public void InitialPhysicsVectorsAndCoefficientsSeedCanonicalActivation()
+    {
+        Vector3 omega = new(1f, 2f, 3f);
+        using var fixture = new Fixture(
+            residentWorld: true,
+            initialVelocity: new Vector3(100f, 0f, 0f),
+            initialOmega: omega,
+            initialFriction: 0.25f,
+            initialElasticity: 0.08f);
+
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(fixture.Prepare(), out var token));
+        PhysicsBody body = Assert.IsType<PhysicsBody>(fixture.Record.PhysicsBody);
+        Assert.Equal(new Vector3(50f, 0f, 0f), body.Velocity);
+        Assert.Equal(omega, body.Omega);
+        Assert.Equal(0.25f, body.Friction);
+        Assert.Equal(0.08f, body.Elasticity);
+        Assert.False(body.InWorld);
+        Assert.False(body.TransientState.HasFlag(TransientStateFlags.Active));
+
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
+            fixture.Owner.EvaluateActivation(token, out var evaluation));
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
+            fixture.Owner.CommitActivation(evaluation, out _));
+
+        Assert.Equal(new Vector3(50f, 0f, 0f), body.Velocity);
+        Assert.Equal(omega, body.Omega);
+        Assert.Equal(0.25f, body.Friction);
+        Assert.Equal(0.08f, body.Elasticity);
+        Assert.True(body.InWorld);
+    }
+
     [Fact]
     public void DeferredActivationEvaluationLeavesExactOwnedGraphDormantAndRetryable()
     {
@@ -198,6 +255,752 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
         AssertNotLive(fixture.Movement.Controller!);
     }
 
+    [Fact]
+    public void CommitActivationPublishesExactLiveRuntimeGraphOnce()
+    {
+        using var fixture = new Fixture(residentWorld: true);
+        bool callbackSawExactGraph = false;
+        var placements = new PlacementObserver(delta =>
+        {
+            if (delta.Placement.Kind is not RuntimePlacementProjectionKind.Place)
+                return;
+            callbackSawExactGraph = fixture.Record.PhysicsBody is { InWorld: true }
+                && fixture.Record.PhysicsHost is not null
+                && fixture.Movement.Controller is { IsRuntimePublished: true }
+                && fixture.Movement.Controller.Movement.MoveTo is not null
+                && fixture.Record.ObjectClock.IsActive
+                && fixture.Lifetime.Physics.IsSpatialRoot(fixture.Record);
+        });
+        using IDisposable subscription = fixture.Lifetime.Events
+            .SubscribePlacement(placements);
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(
+                fixture.Prepare(),
+                out RuntimeLocalPlayerPhysicsActivationToken token));
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
+            fixture.Owner.EvaluateActivation(token, out var evaluation));
+        ulong clockEpoch = fixture.Record.ObjectClockEpoch;
+
+        RuntimeDormantSetPositionCommitStatus status = fixture.Owner
+            .CommitActivation(evaluation, out var projection);
+
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed, status);
+        Assert.True(projection.IsValid);
+        PhysicsBody body = Assert.IsType<PhysicsBody>(fixture.Record.PhysicsBody);
+        Assert.True(body.InWorld);
+        Assert.True(body.TransientState.HasFlag(TransientStateFlags.Active));
+        Assert.NotNull(fixture.Record.PhysicsHost);
+        Assert.True(fixture.Lifetime.Physics.IsSpatialRoot(fixture.Record));
+        Assert.True(fixture.Record.ObjectClock.IsActive);
+        Assert.Equal(clockEpoch + 1UL, fixture.Record.ObjectClockEpoch);
+        Assert.True(fixture.Movement.Controller!.IsRuntimePublished);
+        RuntimePlacementDelta place = Assert.Single(placements.Deltas);
+        Assert.Equal(RuntimePlacementProjectionKind.Place,
+            place.Placement.Kind);
+        Assert.Equal(projection.Sequence,
+            place.Placement.Token.Sequence);
+        Assert.True(callbackSawExactGraph);
+        Assert.Equal(0, fixture.Owner.CaptureOwnership()
+            .PendingActivationCount);
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.RejectedAuthority,
+            fixture.Owner.CommitActivation(evaluation, out _));
+        Assert.Single(placements.Deltas);
+    }
+
+    [Fact]
+    public void DeferredCommitWaitsThenRearmsSameLeaseAfterExactGenerationWake()
+    {
+        using var fixture = new Fixture();
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(
+                fixture.Prepare(),
+                out RuntimeLocalPlayerPhysicsActivationToken token));
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.DeferredCell,
+            fixture.Owner.EvaluateActivation(token, out var deferred));
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.DeferredCell,
+            fixture.Owner.CommitActivation(deferred, out var noProjection));
+        Assert.False(noProjection.IsValid);
+        Assert.False(fixture.Record.PhysicsBody!.InWorld);
+        Assert.Equal(1, fixture.Owner.CaptureOwnership()
+            .PendingActivationCount);
+
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.DeferredCell,
+            fixture.Owner.EvaluateActivation(token, out var waiting));
+        Assert.False(waiting.IsValid);
+        Assert.Equal(1, fixture.Owner.CaptureOwnership()
+            .PendingActivationCount);
+
+        const ulong generation = 1UL;
+        fixture.Lifetime.Physics.SetPosition.BeginCollisionGeneration(
+            Cell & 0xFFFF0000u,
+            generation);
+        fixture.Lifetime.Physics.Engine.AddLandblock(
+            Cell & 0xFFFF0000u,
+            new TerrainSurface(new byte[81], new float[256]),
+            Array.Empty<CellSurface>(),
+            Array.Empty<PortalPlane>(),
+            worldOffsetX: 0f,
+            worldOffsetY: 0f);
+        fixture.Lifetime.Physics.SetPosition.CommitCollisionGeneration(
+            Cell & 0xFFFF0000u,
+            generation,
+            ready: true);
+
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
+            fixture.Owner.EvaluateActivation(token, out var ready));
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
+            fixture.Owner.CommitActivation(ready, out var projection));
+        Assert.True(projection.IsValid);
+        Assert.True(fixture.Record.PhysicsBody!.InWorld);
+        Assert.Equal(0, fixture.Owner.CaptureOwnership()
+            .PendingActivationCount);
+    }
+
+    [Fact]
+    public void RejectedCommitAppliesResponseOnceAndRetainsRetryableLease()
+    {
+        using var fixture = new Fixture(residentWorld: true);
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(
+                fixture.Prepare(),
+                out RuntimeLocalPlayerPhysicsActivationToken token));
+        PhysicsBody body = fixture.Record.PhysicsBody!;
+        Vector3 position = body.Position;
+        uint fullCell = fixture.Record.FullCellId;
+        fixture.Lifetime.Physics.Engine.TransitionCellCollisionTestHook =
+            static (_, phase, _, observed) => phase
+                is TransitionCellCollisionPhase.Objects
+                    ? TransitionState.Collided
+                    : observed;
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.RejectedPlacement,
+            fixture.Owner.EvaluateActivation(token, out var rejected));
+
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.RejectedPlacement,
+            fixture.Owner.CommitActivation(rejected, out var projection));
+        Assert.True(fixture.Lifetime.Physics.SetPosition
+            .TryCaptureDormantLocalActivationResult(
+                token.Placement,
+                out PhysicsSetPositionResult rejectedResult));
+        Assert.Equal(PhysicsSetPositionError.NoValidPosition,
+            rejectedResult.Error);
+        Assert.False(rejectedResult.CollisionHandlerResult);
+        Assert.False(projection.IsValid);
+        Assert.Equal(position, body.Position);
+        Assert.Equal(fullCell, fixture.Record.FullCellId);
+        Assert.False(body.InWorld);
+        Assert.Null(fixture.Record.PhysicsHost);
+        Assert.False(fixture.Lifetime.Physics.IsSpatialRoot(fixture.Record));
+        Assert.Equal(1, fixture.Owner.CaptureOwnership()
+            .PendingActivationCount);
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.RejectedAuthority,
+            fixture.Owner.CommitActivation(rejected, out _));
+
+        fixture.Lifetime.Physics.Engine.TransitionCellCollisionTestHook = null;
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
+            fixture.Owner.EvaluateActivation(token, out var retry));
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
+            fixture.Owner.CommitActivation(retry, out projection));
+        Assert.True(projection.IsValid);
+    }
+
+    [Fact]
+    public void UndefinedShadowDispositionIsRejectedBeforeCandidateConstruction()
+    {
+        using var fixture = new Fixture(residentWorld: true);
+        var invalid = new RuntimeLocalPlayerPhysicsActivationPreparation(
+            0.48f,
+            1.835f,
+            (RuntimeLocalPlayerShadowDisposition)0x7F);
+
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.RejectedAuthority,
+            fixture.Owner.Prepare(
+                fixture.Record,
+                fixture.Placement,
+                fixture.Command,
+                PlayerMovementConstructionOptions.Fallback,
+                invalid,
+                out var token));
+        Assert.False(token.IsValid);
+        Assert.Null(fixture.Record.PhysicsBody);
+        Assert.Null(fixture.Movement.Controller);
+        Assert.Equal(0, fixture.Owner.CaptureOwnership().CandidateCount);
+    }
+
+    [Fact]
+    public void RejectedCommitMapsEligibleEnvironmentCallbackToCollided()
+    {
+        using var fixture = new Fixture(residentWorld: true);
+        fixture.Lifetime.Physics.Engine.TransitionCellCollisionTestHook =
+            static (transition, _, _, _) =>
+            {
+                transition.CollisionInfo.CollidedWithEnvironment = true;
+                return TransitionState.Collided;
+            };
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(
+                fixture.Prepare(),
+                out RuntimeLocalPlayerPhysicsActivationToken token));
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.RejectedPlacement,
+            fixture.Owner.EvaluateActivation(token, out var rejected));
+
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.RejectedPlacement,
+            fixture.Owner.CommitActivation(rejected, out _));
+        Assert.True(fixture.Lifetime.Physics.SetPosition
+            .TryCaptureDormantLocalActivationResult(
+                token.Placement,
+                out PhysicsSetPositionResult result));
+        Assert.Equal(PhysicsSetPositionError.Collided, result.Error);
+        Assert.True(result.CollisionHandlerResult);
+        Assert.Equal(1, fixture.Lifetime.Physics.CollisionReports
+            .CaptureOwnership().OwnerCount);
+
+        Assert.True(fixture.Owner.DiscardActivation(token));
+
+        Assert.Null(fixture.Record.PhysicsBody);
+        Assert.Null(fixture.Movement.Controller);
+        Assert.Equal(0, fixture.Lifetime.Physics.SetPosition
+            .CaptureOwnership().ActiveOperationCount);
+        RuntimeCollisionReportingOwnershipSnapshot ownership = fixture.Lifetime
+            .Physics.CollisionReports.CaptureOwnership();
+        Assert.Equal(0, ownership.OwnerCount);
+        Assert.Equal(0, ownership.TrackedObjectCount);
+        Assert.Equal(0, ownership.ReversePeerCount);
+        Assert.Equal(0, ownership.PendingSetPositionDispatchCount);
+    }
+
+    [Fact]
+    public void RegisteredAuthoredShadowActivatesAndMovesExactRows()
+    {
+        using var fixture = new Fixture(
+            residentWorld: true,
+            shadowDisposition:
+                RuntimeLocalPlayerShadowDisposition.RegisteredAuthoredPayload);
+        uint localId = fixture.Record.Key!.Value.LocalEntityId;
+        fixture.Lifetime.Physics.Engine.ShadowObjects.Register(
+            localId,
+            SetupId,
+            fixture.Command.Physics.Position + Vector3.UnitX,
+            Quaternion.Identity,
+            0.48f,
+            0f,
+            0f,
+            Cell & 0xFFFF0000u,
+            ShadowCollisionType.Sphere,
+            state: (uint)fixture.Record.FinalPhysicsState,
+            seedCellId: Cell,
+            isStatic: false);
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(
+                fixture.Prepare(),
+                out RuntimeLocalPlayerPhysicsActivationToken token));
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
+            fixture.Owner.EvaluateActivation(token, out var evaluation));
+
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
+            fixture.Owner.CommitActivation(evaluation, out _));
+
+        ShadowEntry row = Assert.Single(fixture.Lifetime.Physics.Engine
+            .ShadowObjects.AllEntriesForDebug(),
+            entry => entry.EntityId == localId);
+        Assert.Equal(fixture.Record.PhysicsBody!.Position, row.Position);
+    }
+
+    [Fact]
+    public void DeferredAuthoredActivationSuspendsRowsAndExactWakeRestoresThem()
+    {
+        using var fixture = new Fixture(
+            shadowDisposition:
+                RuntimeLocalPlayerShadowDisposition.RegisteredAuthoredPayload);
+        uint localId = fixture.Record.Key!.Value.LocalEntityId;
+        fixture.Lifetime.Physics.Engine.ShadowObjects.Register(
+            localId, SetupId, fixture.Command.Physics.Position,
+            Quaternion.Identity, 0.48f, 0f, 0f,
+            Cell & 0xFFFF0000u, ShadowCollisionType.Sphere,
+            state: (uint)fixture.Record.FinalPhysicsState,
+            seedCellId: Cell, isStatic: false);
+        Assert.Contains(fixture.Lifetime.Physics.Engine.ShadowObjects
+            .AllEntriesForDebug(), row => row.EntityId == localId);
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(fixture.Prepare(), out var token));
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.DeferredCell,
+            fixture.Owner.EvaluateActivation(token, out var deferred));
+
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.DeferredCell,
+            fixture.Owner.CommitActivation(deferred, out _));
+
+        Assert.False(fixture.Record.PhysicsBody!.InWorld);
+        Assert.DoesNotContain(fixture.Lifetime.Physics.Engine.ShadowObjects
+            .AllEntriesForDebug(), row => row.EntityId == localId);
+        Assert.Equal(1, fixture.Lifetime.Physics.Engine.ShadowObjects
+            .SuspendedRegistrationCount);
+        Assert.Equal(0, fixture.Lifetime.Physics.Engine.ShadowObjects
+            .PendingSetPositionDispatchCount);
+
+        const ulong generation = 1UL;
+        fixture.Lifetime.Physics.SetPosition.BeginCollisionGeneration(
+            Cell & 0xFFFF0000u, generation);
+        fixture.Lifetime.Physics.Engine.AddLandblock(
+            Cell & 0xFFFF0000u,
+            new TerrainSurface(new byte[81], new float[256]),
+            Array.Empty<CellSurface>(), Array.Empty<PortalPlane>(), 0f, 0f);
+        fixture.Lifetime.Physics.SetPosition.CommitCollisionGeneration(
+            Cell & 0xFFFF0000u, generation, ready: true);
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
+            fixture.Owner.EvaluateActivation(token, out var ready));
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
+            fixture.Owner.CommitActivation(ready, out _));
+        Assert.Contains(fixture.Lifetime.Physics.Engine.ShadowObjects
+            .AllEntriesForDebug(), row => row.EntityId == localId);
+    }
+
+    [Fact]
+    public void DeferredDiscardTransfersSuspendedShadowToEntityForLaterReuse()
+    {
+        using var fixture = new Fixture(
+            shadowDisposition:
+                RuntimeLocalPlayerShadowDisposition.RegisteredAuthoredPayload);
+        uint localId = fixture.Record.Key!.Value.LocalEntityId;
+        ShadowObjectRegistry shadows = fixture.Lifetime.Physics.Engine
+            .ShadowObjects;
+        shadows.Register(
+            localId, SetupId, fixture.Command.Physics.Position,
+            Quaternion.Identity, 0.48f, 0f, 0f,
+            Cell & 0xFFFF0000u, ShadowCollisionType.Sphere,
+            state: (uint)fixture.Record.FinalPhysicsState,
+            seedCellId: Cell, isStatic: false);
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(fixture.Prepare(), out var token));
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.DeferredCell,
+            fixture.Owner.EvaluateActivation(token, out var deferred));
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.DeferredCell,
+            fixture.Owner.CommitActivation(deferred, out _));
+
+        Assert.True(fixture.Owner.DiscardActivation(token));
+
+        Assert.Null(fixture.Record.PhysicsBody);
+        Assert.Null(fixture.Movement.Controller);
+        Assert.Equal(0, fixture.Lifetime.Physics.SetPosition
+            .CaptureOwnership().ActiveOperationCount);
+        Assert.Equal(1, shadows.SuspendedRegistrationCount);
+        Assert.Equal(0, shadows.PendingSetPositionDispatchCount);
+        Assert.DoesNotContain(shadows.AllEntriesForDebug(),
+            row => row.EntityId == localId);
+
+        const ulong generation = 1UL;
+        fixture.Lifetime.Physics.SetPosition.BeginCollisionGeneration(
+            Cell & 0xFFFF0000u, generation);
+        fixture.Lifetime.Physics.Engine.AddLandblock(
+            Cell & 0xFFFF0000u,
+            new TerrainSurface(new byte[81], new float[256]),
+            Array.Empty<CellSurface>(), Array.Empty<PortalPlane>(), 0f, 0f);
+        fixture.Lifetime.Physics.SetPosition.CommitCollisionGeneration(
+            Cell & 0xFFFF0000u, generation, ready: true);
+        fixture.RepreparePlacement();
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(fixture.Prepare(), out var retry));
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
+            fixture.Owner.EvaluateActivation(retry, out var ready));
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
+            fixture.Owner.CommitActivation(ready, out _));
+
+        Assert.Equal(0, shadows.SuspendedRegistrationCount);
+        Assert.Contains(shadows.AllEntriesForDebug(),
+            row => row.EntityId == localId);
+    }
+
+    [Fact]
+    public void CollisionCallbackDeleteRetiresPrephaseWithoutShadowOrPlace()
+    {
+        using var fixture = new Fixture(residentWorld: true);
+        fixture.Lifetime.Physics.Engine.TransitionCellCollisionTestHook =
+            static (transition, phase, _, observed) =>
+            {
+                if (phase is TransitionCellCollisionPhase.Environment)
+                    transition.CollisionInfo.CollidedWithEnvironment = true;
+                return observed;
+            };
+        var placements = new PlacementObserver();
+        using IDisposable placementSubscription = fixture.Lifetime.Events
+            .SubscribePlacement(placements);
+        bool deleted = false;
+        var collisions = new PublicationCollisionObserver(ignoredReport =>
+        {
+            if (deleted)
+                return;
+            deleted = true;
+            Assert.True(fixture.Lifetime.TryAcceptDelete(
+                new DeleteObject.Parsed(
+                    fixture.Record.ServerGuid,
+                    fixture.Record.Incarnation),
+                isLocalPlayer: false,
+                removeRetainedObject: false,
+                out RuntimeEntityDeleteAcceptance acceptance));
+            fixture.Lifetime.CompleteAcceptedDelete(acceptance);
+            Assert.Null(fixture.Lifetime.RetireCanonicalOnly(fixture.Record));
+        });
+        using IDisposable collisionSubscription = fixture.Lifetime.Physics
+            .CollisionReports.Subscribe(collisions);
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(fixture.Prepare(), out var token));
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
+            fixture.Owner.EvaluateActivation(token, out var evaluation));
+
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.RejectedAuthority,
+            fixture.Owner.CommitActivation(evaluation, out var projection));
+
+        Assert.True(deleted);
+        Assert.False(projection.IsValid);
+        Assert.DoesNotContain(placements.Deltas,
+            delta => delta.Placement.Kind is RuntimePlacementProjectionKind.Place);
+        Assert.Equal(0, fixture.Owner.CaptureOwnership().PendingActivationCount);
+        Assert.Null(fixture.Movement.Controller);
+        Assert.Equal(0, fixture.Lifetime.Physics.CollisionReports
+            .CaptureOwnership().PendingSetPositionDispatchCount);
+        Assert.Equal(0, fixture.Lifetime.Physics.Engine.ShadowObjects
+            .PendingSetPositionDispatchCount);
+    }
+
+    [Fact]
+    public void CollisionCallbackVectorRefreshesDormantBodyWithRetailClamp()
+    {
+        using var fixture = new Fixture(residentWorld: true);
+        fixture.Lifetime.Physics.Engine.TransitionCellCollisionTestHook =
+            static (transition, phase, _, observed) =>
+            {
+                if (phase is TransitionCellCollisionPhase.Environment)
+                    transition.CollisionInfo.CollidedWithEnvironment = true;
+                return observed;
+            };
+        bool updated = false;
+        Vector3 omega = new(1f, 2f, 3f);
+        var collisions = new PublicationCollisionObserver(ignoredReport =>
+        {
+            if (updated)
+                return;
+            updated = true;
+            Assert.True(fixture.Lifetime.TryApplyVector(
+                new VectorUpdate.Parsed(
+                    fixture.Record.ServerGuid,
+                    new Vector3(100f, 0f, 0f),
+                    omega,
+                    InstanceSequence: fixture.Record.Incarnation,
+                    VectorSequence: 2),
+                acknowledgeProjection: null,
+                out _));
+            _ = ignoredReport;
+        });
+        using IDisposable subscription = fixture.Lifetime.Physics
+            .CollisionReports.Subscribe(collisions);
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(fixture.Prepare(), out var token));
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
+            fixture.Owner.EvaluateActivation(token, out var evaluation));
+
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
+            fixture.Owner.CommitActivation(evaluation, out _));
+
+        Assert.True(updated);
+        Assert.Equal(new Vector3(50f, 0f, 0f),
+            fixture.Record.PhysicsBody!.Velocity);
+        Assert.Equal(omega, fixture.Record.PhysicsBody.Omega);
+    }
+
+    [Fact]
+    public void CollisionCallbackAuthorityChangeRetiresInstalledTracking()
+    {
+        using var fixture = new Fixture(residentWorld: true);
+        fixture.Lifetime.Physics.Engine.TransitionCellCollisionTestHook =
+            static (transition, phase, _, observed) =>
+            {
+                if (phase is TransitionCellCollisionPhase.Environment)
+                    transition.CollisionInfo.CollidedWithEnvironment = true;
+                return observed;
+            };
+        bool invalidated = false;
+        var collisions = new PublicationCollisionObserver(_ =>
+        {
+            if (invalidated)
+                return;
+            invalidated = true;
+            fixture.Lifetime.Entities.AdvanceObjDescAuthority(fixture.Record);
+        });
+        using IDisposable subscription = fixture.Lifetime.Physics
+            .CollisionReports.Subscribe(collisions);
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(fixture.Prepare(), out var token));
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
+            fixture.Owner.EvaluateActivation(token, out var evaluation));
+
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.RejectedAuthority,
+            fixture.Owner.CommitActivation(evaluation, out _));
+
+        RuntimeCollisionReportingOwnershipSnapshot ownership = fixture.Lifetime
+            .Physics.CollisionReports.CaptureOwnership();
+        Assert.True(invalidated);
+        Assert.Equal(0, ownership.OwnerCount);
+        Assert.Equal(0, ownership.TrackedObjectCount);
+        Assert.Equal(0, ownership.ReversePeerCount);
+        Assert.Equal(0, ownership.PendingSetPositionDispatchCount);
+    }
+
+    [Fact]
+    public void CollisionCallbackNewerPositionSuppressesReciprocalAndPreservesNewLease()
+    {
+        using var fixture = new Fixture(residentWorld: true);
+        RuntimeEntityRecord target = fixture.Lifetime.RegisterEntity(
+            Spawn(0x70003002u, incarnation: 1)).Canonical!;
+        fixture.Lifetime.Entities.SetFullCell(
+            target, Cell, Cell & 0xFFFF0000u);
+        fixture.Lifetime.Entities.SetFinalPhysicsState(
+            target, PhysicsStateFlags.ReportCollisions);
+        var targetBody = new PhysicsBody
+        {
+            Position = new Vector3(1f, 2f, 3f),
+            Orientation = Quaternion.Identity,
+            State = PhysicsStateFlags.ReportCollisions,
+            InWorld = true,
+        };
+        targetBody.SnapToCell(Cell, targetBody.Position, targetBody.Position);
+        fixture.Lifetime.Entities.SetPhysicsBody(target, targetBody);
+        fixture.Lifetime.Physics.AcknowledgeSpatialProjection(
+            target, spatial: true);
+        fixture.Lifetime.Physics.Engine.ShadowObjects.Register(
+            target.Key!.Value.LocalEntityId,
+            SetupId,
+            targetBody.Position,
+            Quaternion.Identity,
+            0.48f,
+            0f,
+            0f,
+            Cell & 0xFFFF0000u,
+            ShadowCollisionType.Sphere,
+            (uint)targetBody.State,
+            Cell,
+            isStatic: false);
+        fixture.Lifetime.Physics.Engine.TransitionCellCollisionTestHook =
+            (transition, phase, _, observed) =>
+            {
+                if (phase is TransitionCellCollisionPhase.Environment)
+                {
+                    transition.CollisionInfo.CollideObjectGuids.Add(
+                        target.Key.Value.LocalEntityId);
+                }
+                return observed;
+            };
+        bool updated = false;
+        RuntimeEntityPlacementToken newer = default;
+        var reports = new List<RuntimeCollisionReport>();
+        var collisions = new PublicationCollisionObserver(report =>
+        {
+            reports.Add(report);
+            if (updated || report.Kind is not RuntimeCollisionReportKind.ObjectCollision)
+                return;
+            updated = true;
+            Assert.True(fixture.Lifetime.TryApplyPosition(
+                new WorldSession.EntityPositionUpdate(
+                    fixture.Record.ServerGuid,
+                    new CreateObject.ServerPosition(
+                        Cell, 4f, 5f, 3f, 1f, 0f, 0f, 0f),
+                    Velocity: null,
+                    PlacementId: null,
+                    IsGrounded: true,
+                    InstanceSequence: fixture.Record.Incarnation,
+                    PositionSequence: 2,
+                    TeleportSequence: 0,
+                    ForcePositionSequence: 0),
+                isLocalPlayer: true,
+                forcePositionRotation: null,
+                currentLocalVelocity: null,
+                projectionRequiresTeleportHook: false,
+                acknowledgeProjection: null,
+                out _,
+                out _,
+                out _));
+            newer = fixture.Lifetime.Physics.SetPosition.BeginAuthoredPlacement(
+                fixture.Record,
+                fixture.Record.PositionAuthorityVersion,
+                RuntimeSetPositionOperationKind.LocalAuthoritative);
+            Assert.True(newer.IsValid);
+        });
+        using IDisposable subscription = fixture.Lifetime.Physics
+            .CollisionReports.Subscribe(collisions);
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(fixture.Prepare(), out var token));
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.RejectedPlacement,
+            fixture.Owner.EvaluateActivation(token, out var evaluation));
+
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.RejectedAuthority,
+            fixture.Owner.CommitActivation(evaluation, out _));
+
+        Assert.True(updated);
+        Assert.DoesNotContain(reports, report =>
+            report.Kind is RuntimeCollisionReportKind.ObjectCollision
+            && report.Recipient == target.Key);
+        Assert.Equal(1, fixture.Lifetime.Physics.SetPosition
+            .CaptureOwnership().ActiveOperationCount);
+        RuntimeCollisionReportingOwnershipSnapshot ownership = fixture.Lifetime
+            .Physics.CollisionReports.CaptureOwnership();
+        Assert.Equal(0, ownership.OwnerCount);
+        Assert.Equal(0, ownership.TrackedObjectCount);
+        Assert.Equal(0, ownership.ReversePeerCount);
+    }
+
+    [Fact]
+    public void HitGroundReapplyStaysDormantUntilFinalActivationTail()
+    {
+        using var fixture = new Fixture(residentWorld: true);
+        fixture.Lifetime.Physics.Engine.TransitionCellCollisionTestHook =
+            static (transition, phase, _, observed) =>
+            {
+                if (phase is TransitionCellCollisionPhase.Environment)
+                {
+                    transition.CollisionInfo.SetContactPlane(
+                        new Plane(Vector3.UnitZ, -3f), Cell, isWater: false);
+                }
+                return observed;
+            };
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(fixture.Prepare(), out var token));
+        PlayerMovementController controller = fixture.Movement.Controller!;
+        bool observedDormant = false;
+        controller.BeginDormantSetPositionGroundPhase();
+        controller.Motion.InterpretedState.ForwardCommand =
+            MotionCommand.RunForward;
+        controller.Motion.InterpretedState.ForwardSpeed = 1f;
+        controller.Motion.DefaultSink = new CallbackMotionSink(() =>
+        {
+            observedDormant = true;
+            Assert.False(fixture.Record.PhysicsBody!.InWorld);
+            Assert.False(fixture.Record.PhysicsBody.TransientState
+                .HasFlag(TransientStateFlags.Active));
+            Assert.Null(fixture.Record.PhysicsHost);
+            Assert.False(fixture.Lifetime.Physics.IsSpatialRoot(fixture.Record));
+            Assert.False(fixture.Record.ObjectClock.IsActive);
+        });
+        controller.EndDormantSetPositionGroundPhase();
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
+            fixture.Owner.EvaluateActivation(token, out var evaluation));
+
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
+            fixture.Owner.CommitActivation(evaluation, out var projection));
+
+        Assert.True(observedDormant);
+        Assert.True(projection.IsValid);
+        Assert.True(fixture.Record.PhysicsBody!.InWorld);
+        Assert.NotNull(fixture.Record.PhysicsHost);
+        Assert.True(fixture.Lifetime.Physics.IsSpatialRoot(fixture.Record));
+        Assert.True(fixture.Record.ObjectClock.IsActive);
+        Assert.True(controller.IsRuntimePublished);
+    }
+
+    [Fact]
+    public void HitGroundInvalidationRetiresInstalledBatchBeforeDispatch()
+    {
+        using var fixture = new Fixture(residentWorld: true);
+        RuntimeEntityRecord target = fixture.Lifetime.RegisterEntity(
+            Spawn(0x70003003u, incarnation: 1)).Canonical!;
+        fixture.Lifetime.Entities.SetFullCell(
+            target, Cell, Cell & 0xFFFF0000u);
+        fixture.Lifetime.Entities.SetFinalPhysicsState(
+            target, PhysicsStateFlags.ReportCollisions);
+        var targetBody = new PhysicsBody
+        {
+            Position = new Vector3(100f, 100f, 3f),
+            Orientation = Quaternion.Identity,
+            State = PhysicsStateFlags.ReportCollisions,
+            InWorld = true,
+            TransientState = TransientStateFlags.Active,
+        };
+        targetBody.SnapToCell(Cell, targetBody.Position, targetBody.Position);
+        fixture.Lifetime.Entities.SetPhysicsBody(target, targetBody);
+        fixture.Lifetime.Physics.AcknowledgeSpatialProjection(target, true);
+        fixture.Lifetime.Physics.Engine.ShadowObjects.Register(
+            target.Key!.Value.LocalEntityId, SetupId, targetBody.Position,
+            Quaternion.Identity, 0.48f, 0f, 0f, Cell & 0xFFFF0000u,
+            ShadowCollisionType.Sphere, (uint)targetBody.State, Cell,
+            isStatic: false);
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(fixture.Prepare(), out var token));
+        PhysicsBody ownerBody = fixture.Record.PhysicsBody!;
+        ownerBody.InWorld = true;
+        ownerBody.TransientState |= TransientStateFlags.Active;
+        Assert.True(fixture.Lifetime.Physics.CollisionReports.HandleReports(
+            fixture.Record, ownerBody, 9d, false, false, false,
+            [target.Key.Value.LocalEntityId]));
+        ownerBody.InWorld = false;
+        ownerBody.TransientState &= ~TransientStateFlags.Active;
+        Assert.Equal(1, fixture.Lifetime.Physics.CollisionReports
+            .CaptureOwnership().TrackedObjectCount);
+        fixture.Lifetime.Physics.Engine.TransitionCellCollisionTestHook =
+            static (transition, phase, _, observed) =>
+            {
+                if (phase is TransitionCellCollisionPhase.Environment)
+                {
+                    transition.CollisionInfo.SetContactPlane(
+                        new Plane(Vector3.UnitZ, -3f), Cell, isWater: false);
+                }
+                return observed;
+            };
+        PlayerMovementController controller = fixture.Movement.Controller!;
+        bool invalidated = false;
+        controller.BeginDormantSetPositionGroundPhase();
+        controller.Motion.InterpretedState.ForwardCommand =
+            MotionCommand.RunForward;
+        controller.Motion.DefaultSink = new CallbackMotionSink(() =>
+        {
+            if (invalidated)
+                return;
+            invalidated = true;
+            fixture.Lifetime.Entities.AdvanceObjDescAuthority(fixture.Record);
+        });
+        controller.EndDormantSetPositionGroundPhase();
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
+            fixture.Owner.EvaluateActivation(token, out var evaluation));
+
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.RejectedAuthority,
+            fixture.Owner.CommitActivation(evaluation, out _));
+
+        Assert.True(invalidated);
+        RuntimeCollisionReportingOwnershipSnapshot ownership = fixture.Lifetime
+            .Physics.CollisionReports.CaptureOwnership();
+        Assert.Equal(0, ownership.OwnerCount);
+        Assert.Equal(0, ownership.TrackedObjectCount);
+        Assert.Equal(0, ownership.ReversePeerCount);
+        Assert.Equal(0, ownership.PendingSetPositionDispatchCount);
+        Assert.Equal(0, fixture.Lifetime.Physics.Engine.ShadowObjects
+            .PendingSetPositionDispatchCount);
+        Assert.Equal(0, fixture.Lifetime.Physics.SetPosition
+            .CaptureOwnership().ActiveOperationCount);
+    }
+
+    [Fact]
+    public void HiddenNoDrawStateDoesNotCancelDormantActivation()
+    {
+        using var fixture = new Fixture(residentWorld: true);
+        PhysicsStateFlags hidden = fixture.Record.FinalPhysicsState
+            | PhysicsStateFlags.Hidden
+            | PhysicsStateFlags.NoDraw;
+        fixture.Lifetime.Entities.SetFinalPhysicsState(fixture.Record, hidden);
+        fixture.RepreparePlacement();
+        Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
+            fixture.Owner.Commit(
+                fixture.Prepare(),
+                out RuntimeLocalPlayerPhysicsActivationToken token));
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
+            fixture.Owner.EvaluateActivation(token, out var evaluation));
+
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
+            fixture.Owner.CommitActivation(evaluation, out var projection));
+
+        Assert.True(projection.IsValid);
+        Assert.True(fixture.Record.PhysicsBody!.InWorld);
+        Assert.True(fixture.Record.PhysicsBody.State.HasFlag(
+            PhysicsStateFlags.Hidden));
+        Assert.True(fixture.Record.PhysicsBody.State.HasFlag(
+            PhysicsStateFlags.NoDraw));
+        Assert.True(fixture.Lifetime.Physics.IsSpatialRoot(fixture.Record));
+    }
+
     [Fact]
     public void RejectedPlacementReceiptIsPureAndRetryableUnderSameLease()
     {
@@ -813,6 +1616,7 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
                 fixture.Placement,
                 fixture.Command,
                 PlayerMovementConstructionOptions.Fallback,
+                fixture.ActivationPreparation,
                 out _));
         Assert.Equal(1, fixture.Owner.CaptureOwnership()
             .PendingActivationCount);
@@ -820,12 +1624,14 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
         Assert.True(fixture.Owner.DiscardActivation(token));
         Assert.Equal(0, fixture.Owner.CaptureOwnership()
             .PendingActivationCount);
+        fixture.RepreparePlacement();
         Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Prepared,
             fixture.Owner.Prepare(
                 fixture.Record,
                 fixture.Placement,
                 fixture.Command,
                 PlayerMovementConstructionOptions.Fallback,
+                fixture.ActivationPreparation,
                 out _));
     }
 
@@ -1077,6 +1883,7 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
                 fixture.Placement,
                 fixture.Command,
                 PlayerMovementConstructionOptions.Fallback,
+                fixture.ActivationPreparation,
                 out RuntimeLocalPlayerPhysicsPublicationToken token));
         Assert.False(token.IsValid);
         Assert.Equal(0, fixture.Owner.CaptureOwnership().CandidateCount);
@@ -1095,6 +1902,7 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
                 fixture.Placement,
                 fixture.Command,
                 PlayerMovementConstructionOptions.Fallback,
+                fixture.ActivationPreparation,
                 out _));
     }
 
@@ -1111,6 +1919,7 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
                 fixture.Placement,
                 fixture.Command,
                 PlayerMovementConstructionOptions.Fallback,
+                fixture.ActivationPreparation,
                 out _));
     }
 
@@ -1360,7 +2169,14 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
 
         internal Fixture(
             bool preparePlacement = true,
-            bool residentWorld = false)
+            bool residentWorld = false,
+            RuntimeLocalPlayerShadowDisposition shadowDisposition =
+                RuntimeLocalPlayerShadowDisposition.ProvenShapeless,
+            float terrainHeight = 0f,
+            Vector3? initialVelocity = null,
+            Vector3? initialOmega = null,
+            float? initialFriction = null,
+            float? initialElasticity = null)
         {
             if (residentWorld)
             {
@@ -1370,7 +2186,9 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
                 };
                 engine.AddLandblock(
                     Cell & 0xFFFF0000u,
-                    new TerrainSurface(new byte[81], new float[256]),
+                    new TerrainSurface(
+                        new byte[81],
+                        Enumerable.Repeat(terrainHeight, 256).ToArray()),
                     Array.Empty<CellSurface>(),
                     Array.Empty<PortalPlane>(),
                     worldOffsetX: 0f,
@@ -1390,8 +2208,18 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
                 Identity);
             Movement.AttachPhysicsPublication(Owner);
             Record = Lifetime.RegisterEntity(
-                Spawn(0x70003001u, incarnation: 1)).Canonical!;
+                Spawn(
+                    0x70003001u,
+                    incarnation: 1,
+                    initialVelocity,
+                    initialOmega,
+                    initialFriction,
+                    initialElasticity)).Canonical!;
             Identity.ServerGuid = Record.ServerGuid;
+            ActivationPreparation = new(
+                Radius: 0.48f,
+                Height: 1.835f,
+                shadowDisposition);
             if (preparePlacement)
                 RepreparePlacement();
         }
@@ -1403,6 +2231,8 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
         internal RuntimeEntityRecord Record { get; }
         internal RuntimeEntityPlacementToken Placement { get; private set; }
         internal RuntimeSetPositionCommand Command { get; private set; }
+        internal RuntimeLocalPlayerPhysicsActivationPreparation
+            ActivationPreparation { get; }
 
         internal void RepreparePlacement()
         {
@@ -1440,6 +2270,7 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
                     Placement,
                     Command,
                     PlayerMovementConstructionOptions.Fallback,
+                    ActivationPreparation,
                     out RuntimeLocalPlayerPhysicsPublicationToken token));
             Assert.Equal(Record.Key, token.Entity);
             Assert.Equal(Placement, token.Placement);
@@ -1464,7 +2295,50 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
         }
     }
 
-    private static WorldSession.EntitySpawn Spawn(uint guid, ushort incarnation)
+    private sealed class PlacementObserver(
+        Action<RuntimePlacementDelta>? onPlacement = null)
+        : IRuntimePlacementObserver
+    {
+        internal List<RuntimePlacementDelta> Deltas { get; } = [];
+
+        public void OnPlacement(in RuntimePlacementDelta delta)
+        {
+            Deltas.Add(delta);
+            onPlacement?.Invoke(delta);
+        }
+    }
+
+    private sealed class PublicationCollisionObserver(
+        Action<RuntimeCollisionReport> onReport)
+        : IRuntimeCollisionReportObserver
+    {
+        public void OnCollisionReport(in RuntimeCollisionReport report) =>
+            onReport(report);
+    }
+
+    private sealed class CallbackMotionSink(Action onApply)
+        : IInterpretedMotionSink
+    {
+        public bool ApplyMotion(uint motion, float speed)
+        {
+            onApply();
+            return true;
+        }
+
+        public bool StopMotion(uint motion)
+        {
+            onApply();
+            return true;
+        }
+    }
+
+    private static WorldSession.EntitySpawn Spawn(
+        uint guid,
+        ushort incarnation,
+        Vector3? initialVelocity = null,
+        Vector3? initialOmega = null,
+        float? initialFriction = null,
+        float? initialElasticity = null)
     {
         var position = new CreateObject.ServerPosition(
             Cell,
@@ -1498,12 +2372,12 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
             Parent: null,
             Children: null,
             Scale: 1f,
-            Friction: null,
-            Elasticity: null,
+            Friction: initialFriction,
+            Elasticity: initialElasticity,
             Translucency: null,
-            Velocity: null,
+            Velocity: initialVelocity,
             Acceleration: null,
-            AngularVelocity: null,
+            AngularVelocity: initialOmega,
             DefaultScriptType: null,
             DefaultScriptIntensity: null,
             Timestamps: timestamps);
@@ -1522,6 +2396,8 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
             MotionTableId: 0x09000001u,
             PhysicsState: physics.RawState,
             ObjectDescriptionFlags: 0x8u,
+            Friction: initialFriction,
+            Elasticity: initialElasticity,
             InstanceSequence: incarnation,
             MovementSequence: 1,
             ServerControlSequence: 1,