feat(runtime): C3c - production placement cutover: both hosts on the residence conductors (routes 1+8)

Campaign P remaining-physics-divergence, placement cutover slice C3c
(docs/plans/2026-08-02-placement-cutover.md). Both production hosts now
register every initial Create through the residence + continuation-
executor + first-entry-conductor machinery (C0-C3b):

- Graphical (route 1): RegisterEntityWithInitialResidence at Create; the
  shared RuntimeFirstEntryDriveController pumps both conductors from the
  placement-receipt flow; MaterializeProjection and RebucketLiveEntity
  are presentation-only while a residence is ACTIVE (ExecutorCompleted is
  the presentation-binding receipt); post-residence entities take the
  full legacy path including the prepare_to_enter_world clock edges.
  PlayerModeController attaches presentation to the Runtime-published
  controller; its legacy resolve/step-heights/host-construction path is
  deleted; presentation-only rollback (retail has no entry-flow rollback).
- Headless (route 8): OnSpawned registers with residence when a drive
  exists; content-less sessions keep the pre-flip direct registration;
  SynchronizeLocalPlayer/CreateController/ApplySetupStepHeights deleted;
  prepared-collision read failure is a typed AwaitingCollisionSource
  retry; far remotes outside the service window complete celless.
- RuntimeLocalPlayerMovementState.Controller setter sealed internal; all
  controller mutation flows through the publication lifecycle.

Fix slices landed within this cutover, each dual-gated:
- F1: live movement-stat/server-physics application routed through the
  Runtime ownership seam (post-logout ingest crash on the retired
  controller eliminated; RuntimeMovementSkillProjection deleted).
- F2: login activation wedge - collision-admission prefix gate factored
  out of the seal (reentrant-commit RejectedAuthority), rearm generation
  identity corrected, PlayerModeAutoEntry requires the Runtime-published
  controller (world reveal can no longer seal unmaterialized).
- F3: landblock-prefix 0-sentinel replaced by explicit absent-id guards;
  map-corner landblocks (grid row/col 0) fully legal through admission,
  park/rearm/retire, quiescence, and outdoor shadow seeds.
- F5: local-player first-entry ground contact seeded by the shared
  SpawnPlacementSettler (moved App->Core) at FinalizeActivation - the
  retail first-gravity-frame touch (enter_world 0x00516170 carries no
  seed); the legacy unconditional force-seed is overwritten by a real
  floor-found contact; airborne spawns stay airborne; outbound contact
  bit verified end-to-end. Fixes the standing-cast 'You can't do that
  while in the air!' rejections.
- R1 (dual-review round): login constraint leash armed at the committed
  placement (HandleReceivedPosition 0x00453FD0 analog); register rows
  AD-61 (settle-timing compression now covering the local player) and
  AD-42 (repointed off the deleted resolve split) in this commit;
  residence-conversion owner API; wire-landblock guards; drive-pending
  ledger in IsConverged; route attach/detach latch; executor-drain drift
  model documented + source-pinned.

Gates: Runtime 1,003, App 4,039/3 skips, Headless 79, complete solution
10,816/0 failed/4 skips (Release, -m:1); connected lifecycle/reconnect
gate PASS (logs/connected-world-gate-20260802-175401; graceful exits,
world-visible, zero airborne rejections). The nine-stop soak remains red
for the pre-existing 6b28ff99 whole-world collision-clone throughput
regression (attributed with evidence; scheduled as its own slice before
C5). Dual Opus reviews (retail-conformance + adversarial): delta PASS.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

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

@@ -198,6 +198,175 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
         Assert.True(body.InWorld);
     }
 
+    /// <summary>
+    /// C3c-F5: retail seeds the local player's ground contact from the first
+    /// gravity frame after <c>enter_world</c> (SmartBox::HandleCreateObject
+    /// 0x00454C80 → init_player 0x00455010 → CPhysicsObj::enter_world
+    /// 0x00516170; SetPosition records no touch), which the activation
+    /// compresses through the shared #270 settle sweep. Spawn (1,2,3) with a
+    /// flat floor at 2.7 — feet 0.3 m above it, inside the 0.5 m settle
+    /// reach — and the production human bottom-sphere origin (0.475) so the
+    /// authored placement itself stands clear of the floor.
+    /// </summary>
+    [Fact]
+    public void CommitActivationOnFlatGroundSeedsRetailFirstGravityFrameContact()
+    {
+        using var fixture = new Fixture(
+            residentWorld: true,
+            terrainHeight: 2.7f,
+            moverSphereOriginZ: 0.475f);
+        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 _));
+
+        PhysicsBody body = Assert.IsType<PhysicsBody>(fixture.Record.PhysicsBody);
+        Assert.True(body.InWorld);
+        Assert.True(body.InContact);
+        Assert.True(body.OnWalkable);
+        Assert.True(body.ContactPlaneValid);
+        Assert.True(body.ContactPlane.Normal.Z > 0.9f);
+        // The settle snapped the feet onto the floor, exactly like retail's
+        // first gravity frame.
+        Assert.InRange(body.Position.Z, 2.65f, 2.76f);
+        PlayerMovementController controller =
+            Assert.IsType<PlayerMovementController>(
+                fixture.Movement.Controller);
+        // The exact outbound predicate LocalPlayerOutboundController
+        // serializes as the wire contact bit (InContact && OnWalkable).
+        Assert.True(controller.CanSendPositionEvent);
+        Assert.True(controller.CaptureMovementResult(
+            mouseLookEvent: false).IsOnGround);
+    }
+
+    /// <summary>
+    /// C3c-F5 counterpart: a spawn with no floor within the settle's reach
+    /// (flat terrain at 0, feet at 3) must stay genuinely airborne — the
+    /// seed only ever commits contact the sweep actually found, exactly
+    /// like retail's fall after enter_world.
+    /// </summary>
+    [Fact]
+    public void CommitActivationOverVoidLeavesFirstEntryGenuinelyAirborne()
+    {
+        using var fixture = new Fixture(
+            residentWorld: true,
+            moverSphereOriginZ: 0.475f);
+        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 _));
+
+        PhysicsBody body = Assert.IsType<PhysicsBody>(fixture.Record.PhysicsBody);
+        Assert.True(body.InWorld);
+        Assert.False(body.InContact);
+        Assert.False(body.OnWalkable);
+        Assert.False(body.ContactPlaneValid);
+        Assert.Equal(3f, body.Position.Z);
+        PlayerMovementController controller =
+            Assert.IsType<PlayerMovementController>(
+                fixture.Movement.Controller);
+        Assert.False(controller.CanSendPositionEvent);
+        Assert.False(controller.CaptureMovementResult(
+            mouseLookEvent: false).IsOnGround);
+    }
+
+    /// <summary>
+    /// C3c-R1 review R1: the login constraint leash. Retail arms the leash
+    /// at every accepted-position event (SmartBox::HandleReceivedPosition
+    /// 0x00453FD0); the flip deleted the App-side login arm
+    /// (CommitPreparedPosition), so the dormant activation's final commit
+    /// must arm it — anchored at the committed placement (already
+    /// floor-snapped by the faithful placement transaction), before the
+    /// compressed first-gravity-frame settle runs, exactly like retail arms
+    /// at the received position and only then simulates the first frame.
+    /// </summary>
+    [Fact]
+    public void CommitActivationArmsTheLoginConstraintLeashAtTheCommittedPlacement()
+    {
+        using var fixture = new Fixture(
+            residentWorld: true,
+            terrainHeight: 2.7f,
+            moverSphereOriginZ: 0.475f);
+        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 _));
+
+        PlayerMovementController controller =
+            Assert.IsType<PlayerMovementController>(
+                fixture.Movement.Controller);
+        ConstraintManager? constraint =
+            controller.PositionManager?.Constraint;
+        Assert.NotNull(constraint);
+        Assert.True(constraint!.IsConstrained);
+        // The anchor cell is the placement's committed containing cell.
+        Assert.Equal(
+            controller.PhysicsBody.CellPosition.ObjCellId,
+            constraint.ConstraintPos.ObjCellId);
+        // Anchored at the committed (floor-snapped) placement pose.
+        Assert.InRange(
+            constraint.ConstraintPos.Frame.Origin.Z, 2.65f, 2.76f);
+        Assert.InRange(
+            controller.PhysicsBody.Position.Z, 2.65f, 2.76f);
+        Assert.Equal(
+            ConstraintDistance.GetStartConstraintDistance(
+                constraint.ConstraintPos.ObjCellId),
+            constraint.ConstraintDistanceStart);
+        Assert.Equal(
+            ConstraintDistance.GetMaxConstraintDistance(
+                constraint.ConstraintPos.ObjCellId),
+            constraint.ConstraintDistanceMax);
+    }
+
+    /// <summary>
+    /// C3c-R1 review R1: the arm is exactly-once — the successful final
+    /// commit nulls the activation envelope, so a stale CommitActivation
+    /// retry is RejectedAuthority and can never re-arm the leash.
+    /// </summary>
+    [Fact]
+    public void CommitActivationNeverRearmsTheLeashOnAStaleRetry()
+    {
+        using var fixture = new Fixture(
+            residentWorld: true,
+            terrainHeight: 2.7f,
+            moverSphereOriginZ: 0.475f);
+        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 _));
+        PlayerMovementController controller =
+            Assert.IsType<PlayerMovementController>(
+                fixture.Movement.Controller);
+        Assert.True(
+            controller.PositionManager!.Constraint!.IsConstrained);
+
+        controller.PositionManager.UnConstrain();
+        Assert.Equal(RuntimeDormantSetPositionCommitStatus.RejectedAuthority,
+            fixture.Owner.CommitActivation(evaluation, out _));
+
+        Assert.False(
+            controller.PositionManager.Constraint.IsConstrained);
+    }
+
     [Fact]
     public void DeferredActivationEvaluationLeavesExactOwnedGraphDormantAndRetryable()
     {
@@ -356,10 +525,117 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
         Assert.Equal(1, fixture.Owner.CaptureOwnership()
             .PendingActivationCount);
 
-        const ulong generation = 1UL;
-        fixture.Lifetime.Physics.SetPosition.BeginCollisionGeneration(
-            Cell & 0xFFFF0000u,
-            generation);
+        // C3c-F2: the wake is driven through the SAME owner production uses
+        // (RuntimePhysicsState's collision admission), not through the raw
+        // SetPosition seam. Driving SetPosition directly leaves the admission
+        // ledger empty, which is a state production can never be in and which
+        // hid the login rearm wedge this test is supposed to cover.
+        CommitProductionCollisionGeneration(fixture, Cell & 0xFFFF0000u);
+
+        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 DeferredCommitRearmsAfterProductionAdmissionCommitsItsGeneration()
+    {
+        // C3c-F2 regression (the connected-gate login wedge). The sibling
+        // test above wakes the parked lease by calling BeginCollisionGeneration
+        // / CommitCollisionGeneration DIRECTLY on the SetPosition state, which
+        // leaves RuntimePhysicsState's admission ledger empty. PRODUCTION
+        // always wakes through BeginCollisionAdmission -> stage ->
+        // CommitCollisionGeneration, and that path retires the admission the
+        // instant the generation commits — after which
+        // ExpectedCollisionGeneration names the NEXT, never-begun generation.
+        // The rearm must key off the generation the collision world now HOLDS.
+        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.False(fixture.Movement.Controller!.IsRuntimePublished);
+        Assert.Equal(1, fixture.Owner.CaptureOwnership()
+            .PendingActivationCount);
+
+        RuntimeCollisionAdmission admission = fixture.Lifetime.Physics
+            .BeginCollisionAdmission(Cell & 0xFFFF0000u);
+        // While the destination admission is in flight the lease must simply
+        // keep waiting — never a rejection, never an early rearm.
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.DeferredCell,
+            fixture.Owner.EvaluateActivation(token, out var waiting));
+        Assert.False(waiting.IsValid);
+        using PreparedLandblockCollisionGeneration prepared = fixture
+            .Lifetime.Physics.PrepareCollisionGeneration(admission);
+        fixture.Lifetime.Physics.StageCollisionAssets(
+            admission,
+            prepared,
+            CollisionAssets(Cell & 0xFFFF0000u));
+        Assert.True(CommitPrepared(
+            fixture.Lifetime.Physics,
+            admission,
+            prepared).Committed);
+
+        // The exact divergence this test pins: the committed authority is the
+        // generation the lease parked on; "expected" has already moved past it.
+        Assert.Equal(
+            admission.Generation,
+            fixture.Lifetime.Physics.CollisionGenerationAuthority(Cell));
+        Assert.NotEqual(
+            admission.Generation,
+            fixture.Lifetime.Physics.ExpectedCollisionGeneration(Cell));
+
+        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.NotNull(fixture.Record.PhysicsHost);
+        Assert.True(fixture.Movement.Controller!.IsRuntimePublished);
+        Assert.Equal(0, fixture.Owner.CaptureOwnership()
+            .PendingActivationCount);
+    }
+
+    [Fact]
+    public void DeferredCommitStaysParkedWhileTheCommittingAdmissionIsStillRegistered()
+    {
+        // C3c-F2, the link the live probe caught: the collision-generation
+        // commit marks the parked lease ready and only THEN retires its
+        // admission (RuntimePhysicsState.cs:2503 vs :2552-2558). Production
+        // reenters the first-entry pump inside that window. Rearming there
+        // moves the lease out of AwaitingCell and its very next evaluation
+        // fails the seal on the still-registered admission — after which
+        // EvaluateActivation can no longer answer DeferredCell and reports
+        // RejectedAuthority, which is TERMINAL for the conductor. The lease
+        // must stay parked and retryable instead.
+        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 _));
+
+        RuntimeCollisionAdmission admission = fixture.Lifetime.Physics
+            .BeginCollisionAdmission(Cell & 0xFFFF0000u);
+        // Reconstruct the exact production instant: the landblock is in the
+        // engine and the parked lease has been marked ready by the SAME call
+        // RuntimePhysicsState.cs:2503 makes, while the admission that is
+        // committing has not yet been retired (:2552-2558).
         fixture.Lifetime.Physics.Engine.AddLandblock(
             Cell & 0xFFFF0000u,
             new TerrainSurface(new byte[81], new float[256]),
@@ -369,8 +645,39 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
             worldOffsetY: 0f);
         fixture.Lifetime.Physics.SetPosition.CommitCollisionGeneration(
             Cell & 0xFFFF0000u,
-            generation,
+            admission.Generation,
             ready: true);
+        Assert.Equal(
+            admission.Generation,
+            fixture.Lifetime.Physics.CollisionGenerationAuthority(Cell));
+        Assert.Equal(
+            admission.Generation,
+            fixture.Lifetime.Physics.ExpectedCollisionGeneration(Cell));
+        Assert.False(fixture.Lifetime.Physics
+            .IsCollisionEvaluationPrefixAdmissible(Cell));
+
+        Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.DeferredCell,
+            fixture.Owner.EvaluateActivation(token, out var stillWaiting));
+        Assert.False(stillWaiting.IsValid);
+        Assert.Equal(1, fixture.Owner.CaptureOwnership()
+            .PendingActivationCount);
+        Assert.False(fixture.Record.PhysicsBody!.InWorld);
+        Assert.False(fixture.Movement.Controller!.IsRuntimePublished);
+
+        using (PreparedLandblockCollisionGeneration prepared = fixture
+            .Lifetime.Physics.PrepareCollisionGeneration(admission))
+        {
+            fixture.Lifetime.Physics.StageCollisionAssets(
+                admission,
+                prepared,
+                CollisionAssets(Cell & 0xFFFF0000u));
+            Assert.True(CommitPrepared(
+                fixture.Lifetime.Physics,
+                admission,
+                prepared).Committed);
+        }
+        Assert.True(fixture.Lifetime.Physics
+            .IsCollisionEvaluationPrefixAdmissible(Cell));
 
         Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
             fixture.Owner.EvaluateActivation(token, out var ready));
@@ -378,6 +685,7 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
             fixture.Owner.CommitActivation(ready, out var projection));
         Assert.True(projection.IsValid);
         Assert.True(fixture.Record.PhysicsBody!.InWorld);
+        Assert.True(fixture.Movement.Controller!.IsRuntimePublished);
         Assert.Equal(0, fixture.Owner.CaptureOwnership()
             .PendingActivationCount);
     }
@@ -562,15 +870,9 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
         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);
+        // C3c-F2: production wake path (collision admission), see
+        // CommitProductionCollisionGeneration.
+        CommitProductionCollisionGeneration(fixture, Cell & 0xFFFF0000u);
         Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
             fixture.Owner.EvaluateActivation(token, out var ready));
         Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
@@ -2192,6 +2494,11 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
     private sealed class Fixture : IDisposable
     {
         private bool _lifetimeDisposed;
+        // C3c-F5: default 0 keeps every pre-existing test's mover shape
+        // byte-identical; the first-entry settle tests pass the production
+        // human Setup's bottom-sphere origin (0.475) so an authored
+        // placement can stand clear of a floor the settle then reaches.
+        private readonly float _moverSphereOriginZ;
 
         internal Fixture(
             bool preparePlacement = true,
@@ -2199,11 +2506,13 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
             RuntimeLocalPlayerShadowDisposition shadowDisposition =
                 RuntimeLocalPlayerShadowDisposition.ProvenShapeless,
             float terrainHeight = 0f,
+            float moverSphereOriginZ = 0f,
             Vector3? initialVelocity = null,
             Vector3? initialOmega = null,
             float? initialFriction = null,
             float? initialElasticity = null)
         {
+            _moverSphereOriginZ = moverSphereOriginZ;
             if (residentWorld)
             {
                 var engine = new PhysicsEngine
@@ -2269,7 +2578,9 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
             Assert.True(Placement.IsValid);
             var setup = new FlatSetupCollision(
                 ImmutableArray<FlatCollisionCylinder>.Empty,
-                [new FlatCollisionSphere(Vector3.Zero, 0.48f)],
+                [new FlatCollisionSphere(
+                    new Vector3(0f, 0f, _moverSphereOriginZ),
+                    0.48f)],
                 height: 0f,
                 radius: 0f,
                 stepUpHeight: 0.4f,
@@ -2537,6 +2848,31 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
             "Collision generation did not complete its Runtime mutation transaction.");
     }
 
+    /// <summary>
+    /// C3c-F2: publishes one landblock collision generation through the exact
+    /// production owner chain — BeginCollisionAdmission -> prepare -> stage ->
+    /// CommitCollisionGeneration. Waking a parked activation any other way
+    /// (calling the SetPosition seam directly) leaves RuntimePhysicsState's
+    /// admission ledger empty, a state production can never reach.
+    /// </summary>
+    private static void CommitProductionCollisionGeneration(
+        Fixture fixture,
+        uint landblockId)
+    {
+        RuntimeCollisionAdmission admission = fixture.Lifetime.Physics
+            .BeginCollisionAdmission(landblockId);
+        using PreparedLandblockCollisionGeneration prepared = fixture
+            .Lifetime.Physics.PrepareCollisionGeneration(admission);
+        fixture.Lifetime.Physics.StageCollisionAssets(
+            admission,
+            prepared,
+            CollisionAssets(landblockId));
+        Assert.True(CommitPrepared(
+            fixture.Lifetime.Physics,
+            admission,
+            prepared).Committed);
+    }
+
     private static RuntimeLandblockCollisionAssets CollisionAssets(
         uint landblockId) => new(
             landblockId,