@series-inc/rundot-syncplay 5.24.0-beta.1 → 5.24.0-beta.2

package/dist/cjs/input-authority.js

@@ -11,6 +11,7 @@ function createInputAuthority(config) {
     const retainedConfirmedFrames = config.retainedConfirmedFrames ?? 512;
     const pending = new Map();
     const pendingCommands = new Map();
+    const occupiedSlotsByTick = new Map();
     const lastConfirmedInput = Array.from({ length: playerCount }, () => config.neutralInput);
     const retained = new Map();
     let confirmedThrough = -1;
@@ -23,6 +24,19 @@ function createInputAuthority(config) {
             const frame = frames[index];
             (0, errors_js_1.invariant)(Number.isInteger(frame.tick) && (index === 0 || frame.tick === frames[index - 1].tick + 1), 'restoreFrom frames must be tick-contiguous', 'input-authority.restore-gap');
             (0, errors_js_1.invariant)(frame.inputs.length === playerCount, 'restoreFrom frame inputs must cover every player slot', 'input-authority.restore-inputs');
+            if (frame.occupiedSlots !== undefined) {
+                (0, errors_js_1.invariant)(frame.occupiedSlots.every((slot, slotIndex, slots) => (Number.isInteger(slot) &&
+                    slot >= 0 &&
+                    slot < playerCount &&
+                    (slotIndex === 0 || slots[slotIndex - 1] < slot))), 'restoreFrom occupied slots must be sorted unique valid slots', 'input-authority.restore-occupied-slots');
+                const checksumPayload = {
+                    tick: frame.tick,
+                    inputs: frame.inputs,
+                    occupiedSlots: frame.occupiedSlots,
+                    ...((frame.commands?.length ?? 0) === 0 ? {} : { commands: frame.commands }),
+                };
+                (0, errors_js_1.invariant)(frame.checksum === String((0, canonical_js_1.defaultChecksum)(checksumPayload)), 'restoreFrom occupied-slot checksum mismatch', 'input-authority.restore-occupied-checksum');
+            }
             retained.set(frame.tick, (0, canonical_js_1.cloneCanonical)(frame));
         }
         (0, errors_js_1.invariant)(frames[frames.length - 1].tick === restoredThrough, 'restoreFrom frames must end at the restored frontier', 'input-authority.restore-frontier');
@@ -80,12 +94,21 @@ function createInputAuthority(config) {
             .map((command) => (0, canonical_js_1.cloneCanonical)(command))
             .sort(compareAuthorityCommands);
         pendingCommands.delete(tick);
+        const occupiedSlots = occupiedSlotsByTick.get(tick);
+        occupiedSlotsByTick.delete(tick);
+        const checksumPayload = {
+            tick,
+            inputs,
+            ...(occupiedSlots === undefined ? {} : { occupiedSlots }),
+            ...(commands.length === 0 ? {} : { commands }),
+        };
         const frame = {
             tick,
             inputs,
             substitutedSlots,
+            ...(occupiedSlots === undefined ? {} : { occupiedSlots }),
             ...(commands.length === 0 ? {} : { commands }),
-            checksum: String((0, canonical_js_1.defaultChecksum)(commands.length === 0 ? { tick, inputs } : { tick, inputs, commands })),
+            checksum: String((0, canonical_js_1.defaultChecksum)(checksumPayload)),
         };
         retained.set(tick, frame);
         if (earliestRetained === -1) {
@@ -122,6 +145,15 @@ function createInputAuthority(config) {
             return confirmedThrough;
         },
         receiveInput,
+        recordOccupiedSlots(tick, slots) {
+            (0, errors_js_1.invariant)(Number.isInteger(tick) && tick >= 0, 'presence tick must be a non-negative integer', 'input-authority.presence-tick');
+            const sorted = [...slots].sort((a, b) => a - b);
+            (0, errors_js_1.invariant)(sorted.every((slot, index) => (Number.isInteger(slot) &&
+                slot >= 0 &&
+                slot < playerCount &&
+                (index === 0 || sorted[index - 1] !== slot))), 'occupied slots must be unique valid slots', 'input-authority.presence-slots');
+            occupiedSlotsByTick.set(tick, sorted);
+        },
         queueCommand(tick, command) {
             (0, errors_js_1.invariant)(Number.isInteger(tick) && tick >= 0, 'command tick must be a non-negative integer', 'input-authority.command-tick');
             (0, errors_js_1.invariant)(tick > confirmedThrough, `command tick ${tick} is already confirmed`, 'input-authority.command-confirmed');

package/dist/cjs/math.js

@@ -130,6 +130,25 @@ function createDeterministicMath(fixedScale = 1_000, minFixed = DEFAULT_MIN_FIXE
             }
             return saturate(x, minFixed, maxFixed);
         },
+        integerSqrt(value) {
+            if (!Number.isSafeInteger(value) || value < 0) {
+                throw new Error('DeterministicMath.integerSqrt: value must be a non-negative safe integer');
+            }
+            if (value < 2)
+                return value;
+            let low = 1;
+            let high = Math.min(value, 94_906_266);
+            while (low <= high) {
+                const mid = low + Math.trunc((high - low) / 2);
+                if (mid <= Math.trunc(value / mid)) {
+                    low = mid + 1;
+                }
+                else {
+                    high = mid - 1;
+                }
+            }
+            return high;
+        },
         abs(value) {
             assertFixed(value);
             return saturate(value < 0 ? -value : value, minFixed, maxFixed);
@@ -265,10 +284,14 @@ function createDeterministicMath(fixedScale = 1_000, minFixed = DEFAULT_MIN_FIXE
             const ay = y < 0 ? -y : y;
             const swap = ay > ax;
             const z = this.div(swap ? ax : ay, swap ? ay : ax);
+            // rdm-ignore-next-line determinism/no-float-format: this.toFixed is the deterministic fixed-point conversion helper on this math instance, not Number.prototype.toFixed
             const K1 = this.toFixed(Math.PI / 4);
+            // rdm-ignore-next-line determinism/no-float-format: this.toFixed is the deterministic fixed-point conversion helper on this math instance, not Number.prototype.toFixed
             const K2 = this.toFixed(0.2447);
+            // rdm-ignore-next-line determinism/no-float-format: this.toFixed is the deterministic fixed-point conversion helper on this math instance, not Number.prototype.toFixed
             const K3 = this.toFixed(0.0663);
             const atanRad = this.add(this.mul(K1, z), this.mul(this.mul(z, this.sub(fixedScale, z)), this.add(K2, this.mul(K3, z))));
+            // rdm-ignore-next-line determinism/no-float-format: this.toFixed is the deterministic fixed-point conversion helper on this math instance, not Number.prototype.toFixed
             let turn = this.mul(atanRad, this.toFixed(1 / (2 * Math.PI)));
             if (swap) {
                 turn = this.sub(fixedScale / 4, turn);
@@ -288,6 +311,11 @@ function createDeterministicMath(fixedScale = 1_000, minFixed = DEFAULT_MIN_FIXE
             }
             return ((full % fixedScale) + fixedScale) % fixedScale;
         },
+        atan2Signed(y, x) {
+            const turn = this.atan2(y, x);
+            const half = fixedScale / 2;
+            return turn >= half ? turn - fixedScale : turn;
+        },
         wrapTurns(t) {
             assertFixed(t);
             return ((t % fixedScale) + fixedScale) % fixedScale;
@@ -304,10 +332,12 @@ function createDeterministicMath(fixedScale = 1_000, minFixed = DEFAULT_MIN_FIXE
         },
         turnsToRadians(t) {
             assertFixed(t);
+            // rdm-ignore-next-line determinism/no-float-format: this.toFixed is the deterministic fixed-point conversion helper on this math instance, not Number.prototype.toFixed
             return saturate(Math.trunc((t * this.toFixed(2 * Math.PI)) / fixedScale), minFixed, maxFixed);
         },
         radiansToTurns(r) {
             assertFixed(r);
+            // rdm-ignore-next-line determinism/no-float-format: this.toFixed is the deterministic fixed-point conversion helper on this math instance, not Number.prototype.toFixed
             return saturate(Math.trunc((r * fixedScale) / this.toFixed(2 * Math.PI)), minFixed, maxFixed);
         },
         hypot(x, y) {

package/dist/cjs/networked-client.js

@@ -35,6 +35,12 @@ const TRANSFER_SENDS_PER_PUMP = 2;
 function createNetworkedSyncplayClient(options) {
     const sessionMsgType = options.sessionMsgType ?? DEFAULT_MSG_TYPE;
     const maxPredictionTicks = options.maxPredictionTicks ?? DEFAULT_MAX_PREDICTION;
+    if (options.maxSnapshotBytes !== undefined && (!Number.isInteger(options.maxSnapshotBytes) || options.maxSnapshotBytes < 1)) {
+        throw new Error(`createNetworkedSyncplayClient: maxSnapshotBytes must be a positive integer, received ${options.maxSnapshotBytes}`);
+    }
+    const snapshotCollectorOptions = options.maxSnapshotBytes === undefined
+        ? {}
+        : { maxSnapshotBytes: options.maxSnapshotBytes };
     const checksumCadenceTicks = options.checksumCadenceTicks ?? DEFAULT_CHECKSUM_CADENCE_TICKS;
     const pingIntervalMs = options.pacing?.pingIntervalMs ?? DEFAULT_PING_INTERVAL_MS;
     const targetLeadTicks = options.pacing?.targetLeadTicks ?? DEFAULT_TARGET_LEAD_TICKS;
@@ -83,6 +89,7 @@ function createNetworkedSyncplayClient(options) {
     const ownInputs = new Map();
     const confirmed = new Map();
     let lastConfirmedBySlot = [];
+    let confirmedPlayerPresence = [];
     let confirmationQueue;
     let secretFailure;
     let secrets;
@@ -93,7 +100,7 @@ function createNetworkedSyncplayClient(options) {
     let schemaHash = '';
     const reportedTicks = [];
     let lastAutoReportedTick = -1;
-    let transferCollector = (0, session_snapshot_js_1.createSnapshotTransferCollector)();
+    let transferCollector = (0, session_snapshot_js_1.createSnapshotTransferCollector)(snapshotCollectorOptions);
     const outgoingTransferQueue = [];
     let donorTransferCounter = 0;
     let readyResolve;
@@ -121,6 +128,7 @@ function createNetworkedSyncplayClient(options) {
             seed = message.seed;
             playerCount = message.playerCount;
             lastConfirmedBySlot = Array.from({ length: playerCount }, () => null);
+            confirmedPlayerPresence = unknownPresence();
             appliedThrough = -1;
             predictedThrough = 0;
             timeline.length = 0;
@@ -128,7 +136,7 @@ function createNetworkedSyncplayClient(options) {
             confirmed.clear();
             reportedTicks.length = 0;
             lastAutoReportedTick = -1;
-            transferCollector = (0, session_snapshot_js_1.createSnapshotTransferCollector)();
+            transferCollector = (0, session_snapshot_js_1.createSnapshotTransferCollector)(snapshotCollectorOptions);
             outgoingTransferQueue.length = 0;
             tickRateHz = message.tickRateHz;
             frameMs = tickRateHz > 0 ? 1000 / tickRateHz : 0;
@@ -445,7 +453,12 @@ function createNetworkedSyncplayClient(options) {
     function applyConfirmedFrames(frames) {
         for (const frame of frames) {
             if (frame.tick > appliedThrough) {
-                confirmed.set(frame.tick, { inputs: frame.inputs, commands: frame.commands ?? [] });
+                confirmed.set(frame.tick, {
+                    inputs: frame.inputs,
+                    commands: frame.commands ?? [],
+                    substitutedSlots: frame.substitutedSlots,
+                    ...(frame.occupiedSlots === undefined ? {} : { occupiedSlots: frame.occupiedSlots }),
+                });
             }
         }
         while (confirmed.has(appliedThrough + 1)) {
@@ -453,7 +466,8 @@ function createNetworkedSyncplayClient(options) {
             const confFrame = confirmed.get(tick);
             const confInputs = confFrame.inputs;
             const predFrame = timeline[tick];
-            if (predFrame === undefined || (0, canonical_js_1.canonicalStringify)(confFrame) !== (0, canonical_js_1.canonicalStringify)(predFrame)) {
+            const simulationFrame = { inputs: confFrame.inputs, commands: confFrame.commands };
+            if (predFrame === undefined || (0, canonical_js_1.canonicalStringify)(simulationFrame) !== (0, canonical_js_1.canonicalStringify)(predFrame)) {
                 timeline[tick] = { inputs: confInputs.slice(), commands: confFrame.commands };
                 if (predictedThrough > tick) {
                     // Rollback: we had already predicted this tick and the confirmed inputs differ.
@@ -473,9 +487,24 @@ function createNetworkedSyncplayClient(options) {
                 lastConfirmedBySlot[s] = confInputs[s];
             }
             appliedThrough = tick;
+            confirmedPlayerPresence = classifyPresence(confFrame);
         }
         autoReportCrossedCadences();
     }
+    function unknownPresence() {
+        return Object.freeze(Array.from({ length: playerCount }, () => 'unknown'));
+    }
+    function classifyPresence(frame) {
+        if (frame.occupiedSlots === undefined)
+            return unknownPresence();
+        const occupied = new Set(frame.occupiedSlots);
+        const substituted = new Set(frame.substitutedSlots);
+        return Object.freeze(Array.from({ length: playerCount }, (_, playerSlot) => {
+            if (!occupied.has(playerSlot))
+                return 'empty';
+            return substituted.has(playerSlot) ? 'substituted' : 'human';
+        }));
+    }
     // ── M5.5: cadence-aligned checksum reports (quorum food + desync telemetry) ──
     function autoReportCrossedCadences() {
         let next = (Math.floor(lastAutoReportedTick / checksumCadenceTicks) + 1) * checksumCadenceTicks;
@@ -670,6 +699,7 @@ function createNetworkedSyncplayClient(options) {
             });
         }
         appliedThrough = snapshot.tick;
+        confirmedPlayerPresence = unknownPresence();
         predictedThrough = snapshot.tick + 1;
         // Never send input for ticks at/below the hydration point — they are
         // already confirmed. Anything the cursor had scheduled beyond it stands.
@@ -709,6 +739,9 @@ function createNetworkedSyncplayClient(options) {
         get rollbacks() {
             return rollbacks;
         },
+        get confirmedPlayerPresence() {
+            return confirmedPlayerPresence;
+        },
         get netStats() {
             return {
                 rttMs: rttMs < 0 ? -1 : Math.round(rttMs),

package/dist/cjs/physics3d-destruction-cert.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDeterministicPhysics3DDestructionCert = runDeterministicPhysics3DDestructionCert;
+const canonical_js_1 = require("./canonical.js");
+const physics3d_js_1 = require("./physics3d.js");
+const physics3d_shared_js_1 = require("./physics3d-shared.js");
+const physics3d_voxel_js_1 = require("./physics3d-voxel.js");
+const CELL = 1;
+/**
+ * Deterministically carved chunk: a solid cube cooks to a single box, which
+ * under-represents real destruction debris. Dropping every cell where
+ * (x + 2y + 3z) % 5 === 0 forces multi-child merged compounds while keeping
+ * ~80% of the mass.
+ */
+function carvedChunk(side) {
+    const occupancy = Array(side * side * side).fill(1);
+    for (let z = 0; z < side; z += 1) {
+        for (let y = 0; y < side; y += 1) {
+            for (let x = 0; x < side; x += 1) {
+                if ((x + 2 * y + 3 * z) % 5 === 0) {
+                    occupancy[x + side * (y + side * z)] = 0;
+                }
+            }
+        }
+    }
+    if (!occupancy.includes(1)) {
+        throw new Error('destruction cert: carved chunk lost every voxel');
+    }
+    return { dimX: side, dimY: side, dimZ: side, cellSize: CELL, occupancy };
+}
+function chunkBody(id, x, y, z, chunk, mass) {
+    return {
+        id, kind: 'dynamic', x, y, z, vx: 0, vy: 0, vz: 0,
+        orientation: { x: 0, y: 0, z: 0, w: 1 },
+        angularVel: { x: 0, y: 0, z: 0 },
+        mass,
+        shape: (0, physics3d_voxel_js_1.cookDeterministicVoxelChunkCollider3D)(chunk),
+        layer: 1, mask: 0xffff,
+    };
+}
+/**
+ * Split occupancy along the largest axis of the OCCUPIED bounding box, cutting
+ * at that box's midpoint so both halves are guaranteed at least one voxel
+ * (carved chunks can have fully-empty grid halves — cutting the raw grid would
+ * cook an empty compound and throw). Returns null when the occupied box is a
+ * single cell on every axis (chip instead of split).
+ */
+function splitChunk(chunk) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let maxZ = -Infinity;
+    for (let z = 0; z < chunk.dimZ; z += 1) {
+        for (let y = 0; y < chunk.dimY; y += 1) {
+            for (let x = 0; x < chunk.dimX; x += 1) {
+                if (chunk.occupancy[x + chunk.dimX * (y + chunk.dimY * z)] !== 0) {
+                    minX = Math.min(minX, x);
+                    maxX = Math.max(maxX, x);
+                    minY = Math.min(minY, y);
+                    maxY = Math.max(maxY, y);
+                    minZ = Math.min(minZ, z);
+                    maxZ = Math.max(maxZ, z);
+                }
+            }
+        }
+    }
+    if (minX === Infinity) {
+        throw new Error('destruction cert: cannot split an empty chunk');
+    }
+    const extents = { x: maxX - minX + 1, y: maxY - minY + 1, z: maxZ - minZ + 1 };
+    const axis = extents.x >= extents.y && extents.x >= extents.z ? 'x' : extents.y >= extents.z ? 'y' : 'z';
+    if (extents[axis] < 2) {
+        return null;
+    }
+    const start = axis === 'x' ? minX : axis === 'y' ? minY : minZ;
+    // Occupied cells exist at both bbox extremes along `axis`, and
+    // start < cut <= start + extent - 1, so both slices keep >= 1 voxel.
+    const cut = start + Math.floor(extents[axis] / 2);
+    const dims = { x: chunk.dimX, y: chunk.dimY, z: chunk.dimZ };
+    const slice = (from, to) => {
+        const dimX = axis === 'x' ? to - from : chunk.dimX;
+        const dimY = axis === 'y' ? to - from : chunk.dimY;
+        const dimZ = axis === 'z' ? to - from : chunk.dimZ;
+        const occupancy = Array(dimX * dimY * dimZ).fill(0);
+        for (let z = 0; z < dimZ; z += 1) {
+            for (let y = 0; y < dimY; y += 1) {
+                for (let x = 0; x < dimX; x += 1) {
+                    const sx = axis === 'x' ? x + from : x;
+                    const sy = axis === 'y' ? y + from : y;
+                    const sz = axis === 'z' ? z + from : z;
+                    occupancy[x + dimX * (y + dimY * z)] = chunk.occupancy[sx + chunk.dimX * (sy + chunk.dimY * sz)];
+                }
+            }
+        }
+        return { dimX, dimY, dimZ, cellSize: chunk.cellSize, occupancy };
+    };
+    return { lower: slice(0, cut), upper: slice(cut, dims[axis]), axis, offset: cut * chunk.cellSize };
+}
+function occupiedCount(chunk) {
+    return chunk.occupancy.reduce((sum, cell) => sum + (cell !== 0 ? 1 : 0), 0);
+}
+function runDeterministicPhysics3DDestructionCert(options = {}) {
+    const chunks = options.chunks ?? 64;
+    const side = options.chunkSide ?? 4;
+    const piles = options.piles ?? 8;
+    const warmupFrames = options.warmupFrames ?? 300;
+    const measuredFrames = options.measuredFrames ?? 1_800;
+    const fractureEveryFrames = options.fractureEveryFrames ?? 30;
+    // Derived from measuredFrames (the 1800-frame default still lands on 900), so a
+    // caller that only lowers measuredFrames does not trip the [0, measuredFrames)
+    // validation below.
+    const snapshotAtMeasuredFrame = options.snapshotAtMeasuredFrame ?? Math.floor(measuredFrames / 2);
+    const tickRateHz = options.tickRateHz ?? 30;
+    const now = options.now ?? (() => performance.now());
+    for (const [name, value] of [
+        ['chunks', chunks], ['chunkSide', side], ['piles', piles], ['measuredFrames', measuredFrames],
+        ['fractureEveryFrames', fractureEveryFrames], ['tickRateHz', tickRateHz],
+    ]) {
+        if (!Number.isInteger(value) || value < 1) {
+            throw new Error(`runDeterministicPhysics3DDestructionCert: ${name} must be a positive integer, received ${value}`);
+        }
+    }
+    // The carve zeroes every cell where (x + 2y + 3z) % 5 === 0, which for side 1
+    // is the chunk's only voxel — reject it here rather than failing later inside
+    // the carve with an error that does not name the offending option.
+    if (side < 2) {
+        throw new Error(`runDeterministicPhysics3DDestructionCert: chunkSide must be at least 2 (the carve pattern empties a 1x1x1 chunk), received ${side}`);
+    }
+    if (!Number.isInteger(warmupFrames) || warmupFrames < 0) {
+        throw new Error(`runDeterministicPhysics3DDestructionCert: warmupFrames must be a non-negative integer, received ${warmupFrames}`);
+    }
+    if (!Number.isInteger(snapshotAtMeasuredFrame) || snapshotAtMeasuredFrame < 0 || snapshotAtMeasuredFrame >= measuredFrames) {
+        throw new Error(`runDeterministicPhysics3DDestructionCert: snapshotAtMeasuredFrame must be an integer in [0, measuredFrames), received ${snapshotAtMeasuredFrame}`);
+    }
+    const gravityY = -9.8 / (tickRateHz * tickRateHz);
+    const build = (reversed) => {
+        const meta = new Map();
+        const bodies = [{
+                id: 'floor', kind: 'static', x: 0, y: -1, z: 0, vx: 0, vy: 0, vz: 0,
+                shape: { type: 'box', halfX: 400, halfY: 1, halfZ: 400 }, layer: 1, mask: 0xffff,
+            }];
+        const chunkSpan = side * CELL;
+        for (let index = 0; index < chunks; index += 1) {
+            const pile = index % piles;
+            const level = Math.floor(index / piles);
+            const chunk = carvedChunk(side);
+            const id = `c${String(index).padStart(3, '0')}`;
+            meta.set(id, { chunk });
+            bodies.push(chunkBody(id, (pile % 4) * (chunkSpan + 1) + (level % 2) * 0.4, 0.5 + level * (chunkSpan + 0.2), Math.floor(pile / 4) * (chunkSpan + 1) + (level % 3) * 0.3, chunk, occupiedCount(chunk)));
+        }
+        const authored = reversed ? [...bodies].reverse() : bodies;
+        return { world: (0, physics3d_js_1.createDeterministicPhysicsWorld3D)(authored), meta, fractures: 0, peakBodyCount: authored.length, peakContactPairs: 0, peakSleepingCount: 0 };
+    };
+    const fracture = (state, reversed) => {
+        // Explicit comparator: this ordering picks the fracture target, so it feeds
+        // straight into the run checksum — never leave it to the default sort.
+        const alive = state.world.bodies
+            .filter((entry) => entry.kind === 'dynamic' && state.meta.has(entry.id))
+            .map((entry) => entry.id)
+            .sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
+        if (alive.length === 0) {
+            return;
+        }
+        const targetId = alive[state.fractures % alive.length];
+        const target = state.world.bodies.find((entry) => entry.id === targetId);
+        if (target === undefined) {
+            throw new Error(`destruction cert: fracture target ${targetId} missing`);
+        }
+        const split = splitChunk(state.meta.get(targetId).chunk);
+        state.fractures += 1;
+        if (split === null) {
+            // single-voxel chunk: chip it out of the simulation entirely
+            state.meta.delete(targetId);
+            state.world = (0, physics3d_js_1.applyDeterministicWorldEdit3D)(state.world, { remove: [targetId] });
+            return;
+        }
+        const axisVector = { x: split.axis === 'x' ? split.offset : 0, y: split.axis === 'y' ? split.offset : 0, z: split.axis === 'z' ? split.offset : 0 };
+        const shifted = (0, physics3d_shared_js_1.rotatePointByQuat)(target.orientation ?? { x: 0, y: 0, z: 0, w: 1 }, axisVector);
+        const kick = 0.02;
+        const lowerBody = {
+            ...chunkBody(`${targetId}a`, target.x, target.y, target.z, split.lower, occupiedCount(split.lower)),
+            vx: target.vx - (split.axis === 'x' ? kick : 0), vy: target.vy, vz: target.vz - (split.axis === 'z' ? kick : 0),
+            orientation: target.orientation, angularVel: target.angularVel,
+        };
+        const upperBody = {
+            ...chunkBody(`${targetId}b`, target.x + shifted.x, target.y + shifted.y, target.z + shifted.z, split.upper, occupiedCount(split.upper)),
+            vx: target.vx + (split.axis === 'x' ? kick : 0), vy: target.vy, vz: target.vz + (split.axis === 'z' ? kick : 0),
+            orientation: target.orientation, angularVel: target.angularVel,
+        };
+        state.meta.delete(targetId);
+        state.meta.set(lowerBody.id, { chunk: split.lower });
+        state.meta.set(upperBody.id, { chunk: split.upper });
+        const added = reversed ? [upperBody, lowerBody] : [lowerBody, upperBody];
+        state.world = (0, physics3d_js_1.applyDeterministicWorldEdit3D)(state.world, { remove: [targetId], add: added });
+    };
+    const stepOnce = (state) => {
+        state.world = (0, physics3d_js_1.stepDeterministicPhysicsWorld3D)(state.world, { gravityY, computeChecksum: false }).world;
+        state.peakBodyCount = Math.max(state.peakBodyCount, state.world.bodies.length);
+        state.peakContactPairs = Math.max(state.peakContactPairs, state.world.activePairs.length);
+        state.peakSleepingCount = Math.max(state.peakSleepingCount, state.world.bodies.filter((entry) => entry.sleeping === true).length);
+    };
+    const runMeasured = (state, reversed, timings) => {
+        let snapshot = state.world;
+        let snapshotMeta = new Map(state.meta);
+        let snapshotFractures = state.fractures;
+        for (let frame = 0; frame < measuredFrames; frame += 1) {
+            if (frame === snapshotAtMeasuredFrame) {
+                snapshot = (0, canonical_js_1.cloneCanonical)(state.world);
+                snapshotMeta = new Map([...state.meta.entries()].map(([id, entry]) => [id, { chunk: (0, canonical_js_1.cloneCanonical)(entry.chunk) }]));
+                snapshotFractures = state.fractures;
+            }
+            // Timed window covers the whole frame — fracture (world edit + re-cooking)
+            // is a cost the game pays inside its tick, not free.
+            const startedAt = timings === undefined ? 0 : now();
+            if (frame % fractureEveryFrames === 0) {
+                fracture(state, reversed);
+            }
+            stepOnce(state);
+            if (timings !== undefined) {
+                timings.push(now() - startedAt);
+            }
+        }
+        return { snapshot, snapshotMeta, snapshotFractures };
+    };
+    const initialChunkColliderChildren = (0, physics3d_voxel_js_1.cookDeterministicVoxelChunkCollider3D)(carvedChunk(side)).children.length;
+    // primary run (timed)
+    const primary = build(false);
+    for (let frame = 0; frame < warmupFrames; frame += 1) {
+        stepOnce(primary);
+    }
+    const timings = [];
+    const { snapshot, snapshotMeta, snapshotFractures } = runMeasured(primary, false, timings);
+    const finalChecksum = (0, canonical_js_1.defaultChecksum)(primary.world);
+    const snapshotBytes = new TextEncoder().encode((0, canonical_js_1.canonicalStringify)(snapshot)).length;
+    // restore + resimulate from the snapshot with the same schedule
+    const restored = { world: (0, canonical_js_1.cloneCanonical)(snapshot), meta: snapshotMeta, fractures: snapshotFractures, peakBodyCount: 0, peakContactPairs: 0, peakSleepingCount: 0 };
+    for (let frame = snapshotAtMeasuredFrame; frame < measuredFrames; frame += 1) {
+        if (frame % fractureEveryFrames === 0) {
+            fracture(restored, false);
+        }
+        stepOnce(restored);
+    }
+    const restoredChecksum = (0, canonical_js_1.defaultChecksum)(restored.world);
+    // reversed-authoring-order rerun (untimed)
+    const reversedRun = build(true);
+    for (let frame = 0; frame < warmupFrames; frame += 1) {
+        stepOnce(reversedRun);
+    }
+    runMeasured(reversedRun, true, undefined);
+    const reversedOrderChecksum = (0, canonical_js_1.defaultChecksum)(reversedRun.world);
+    const sorted = [...timings].sort((left, right) => left - right);
+    const pick = (rank) => sorted.length === 0 ? 0 : sorted[Math.min(sorted.length - 1, Math.floor((rank / 100) * sorted.length))];
+    const rollbackEquivalent = finalChecksum === restoredChecksum;
+    const stableUnderAuthoringOrderPermutation = finalChecksum === reversedOrderChecksum;
+    return {
+        result: rollbackEquivalent && stableUnderAuthoringOrderPermutation ? 'pass' : 'fail',
+        finalChecksum,
+        restoredChecksum,
+        rollbackEquivalent,
+        reversedOrderChecksum,
+        stableUnderAuthoringOrderPermutation,
+        p50StepMs: pick(50),
+        p95StepMs: pick(95),
+        p99StepMs: pick(99),
+        maxStepMs: sorted.length === 0 ? 0 : sorted[sorted.length - 1],
+        measuredFrames,
+        fractures: primary.fractures,
+        initialChunkColliderChildren,
+        finalBodyCount: primary.world.bodies.length,
+        peakBodyCount: primary.peakBodyCount,
+        finalSleepingCount: primary.world.bodies.filter((entry) => entry.sleeping === true).length,
+        peakSleepingCount: primary.peakSleepingCount,
+        finalContactPairs: primary.world.activePairs.length,
+        peakContactPairs: primary.peakContactPairs,
+        snapshotBytes,
+    };
+}