@series-inc/rundot-syncplay 5.23.0-beta.8 → 5.23.0

package/dist/cjs/movement3d.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stepDeterministicKcc3D = stepDeterministicKcc3D;
+exports.stepDeterministicCarry3D = stepDeterministicCarry3D;
 exports.runDeterministicKcc3DFilterForceFixture = runDeterministicKcc3DFilterForceFixture;
 exports.runDeterministicKcc3DCallbackFilterFixture = runDeterministicKcc3DCallbackFilterFixture;
 exports.runDeterministicKcc3DCrowdFixture = runDeterministicKcc3DCrowdFixture;
@@ -8,6 +9,7 @@ exports.runDeterministicKcc3DAdversarialFixture = runDeterministicKcc3DAdversari
 exports.runDeterministicKcc3DGeometryFixture = runDeterministicKcc3DGeometryFixture;
 const canonical_js_1 = require("./canonical.js");
 const physics3d_js_1 = require("./physics3d.js");
+const physics3d_shared_js_1 = require("./physics3d-shared.js");
 function stepDeterministicKcc3D(body, input, world, options) {
     let next = applyProcessors(body, input, options.frame, options.processors ?? []);
     const events = [];
@@ -82,6 +84,9 @@ function stepDeterministicKcc3D(body, input, world, options) {
         coyoteFrames = 0;
         events.push(next.grounded ? 'jump' : 'coyote-jump');
     }
+    // The KCC's intended (pre-slide) horizontal position and velocity — push
+    // impulses are computed here because the slide blocks the KCC off the body.
+    const pushCandidate = { x, z, vx, vz };
     if (options.physics !== undefined) {
         const resolved = resolvePhysicsSlide3D(options.physics, next, { x, y, z, vx, vz }, new Set(options.ignoredPhysicsBodyIds ?? []), options.frame, options.collisionFilters ?? []);
         physicsQueryCount += resolved.queryCount;
@@ -96,6 +101,37 @@ function stepDeterministicKcc3D(body, input, world, options) {
             events.push(resolved.swept ? 'physics-sweep' : resolved.slid ? 'physics-slide' : 'physics-correction');
         }
     }
+    const geometryForInteraction = normalizeKccGeometry3D(next);
+    let physicsImpulses = [];
+    // Stand on a dynamic body directly beneath the feet: attach as a platform and
+    // inherit its per-frame delta (its velocity), mirroring the kinematic path.
+    if (options.physics !== undefined && options.standOnDynamicBodies === true && vy <= 0) {
+        const ground = dynamicGroundUnderKcc(options.physics, x, y, z, geometryForInteraction, new Set(options.ignoredPhysicsBodyIds ?? []));
+        if (ground !== undefined) {
+            y = ground.topY;
+            vy = 0;
+            grounded = true;
+            platformId = ground.bodyId;
+            // Carry the rider with the crate this frame (position delta) AND inherit its
+            // velocity, mirroring the kinematic moving-platform path — otherwise the
+            // rider lags one frame and slides off a moving crate.
+            x += ground.deltaX;
+            z += ground.deltaZ;
+            vx += ground.deltaX;
+            vz += ground.deltaZ;
+            events.push('stand-on-dynamic');
+            if (ground.deltaX !== 0 || ground.deltaZ !== 0) {
+                events.push('platform-velocity-transfer');
+            }
+        }
+    }
+    // Push the dynamic bodies the KCC walked into this frame.
+    if (options.physics !== undefined && (options.maxPushImpulse ?? 0) > 0) {
+        physicsImpulses = computeKccPushImpulses(options.physics, pushCandidate.x, y, pushCandidate.z, { vx: pushCandidate.vx, vz: pushCandidate.vz }, geometryForInteraction, options.maxPushImpulse ?? 0, new Set(options.ignoredPhysicsBodyIds ?? []));
+        if (physicsImpulses.length > 0) {
+            events.push('push-dynamic');
+        }
+    }
     const boundsCorrection = clampBodyToBounds({ x, y, z, vx, vy, vz, grounded, coyoteFrames, jumpBufferFrames, platformId }, world);
     if (boundsCorrection.corrected) {
         correctionCount += boundsCorrection.corrections;
@@ -114,9 +150,202 @@ function stepDeterministicKcc3D(body, input, world, options) {
         physicsQueryCount,
         collisionFilterCalls,
         collisionFilterRejectedHits,
-        checksum: (0, canonical_js_1.defaultChecksum)({ body: finalBody, events, correctionCount, physicsQueryCount, collisionFilterCalls, collisionFilterRejectedHits }),
+        physicsImpulses,
+        checksum: (0, canonical_js_1.defaultChecksum)({ body: finalBody, events, correctionCount, physicsQueryCount, collisionFilterCalls, collisionFilterRejectedHits, physicsImpulses }),
     };
 }
+const KCC_PUSH_MASS = 1;
+/** Dynamic physics bodies the KCC capsule overlaps at (x,y,z), sorted by id. */
+function overlappingDynamicBodies(physics, x, y, z, geometry, ignoredBodyIds) {
+    const query = {
+        shape: { type: 'capsule', radius: geometry.radius + geometry.skinWidth, halfHeight: geometry.halfHeight },
+        x,
+        y,
+        z,
+        hitStatics: false,
+        hitDynamics: true,
+        hitKinematics: false,
+    };
+    const hitIds = new Set((0, physics3d_js_1.overlapDeterministicPhysics3D)(physics, query));
+    return physics.bodies
+        .filter((body) => body.kind === 'dynamic' && hitIds.has(body.id) && !ignoredBodyIds.has(body.id))
+        .sort((left, right) => compareStrings(left.id, right.id));
+}
+function computeKccPushImpulses(physics, x, y, z, velocity, geometry, maxPushImpulse, ignoredBodyIds) {
+    const impulses = [];
+    for (const body of overlappingDynamicBodies(physics, x, y, z, geometry, ignoredBodyIds)) {
+        // push along the horizontal direction from the KCC toward the body, scaled
+        // by the KCC's horizontal speed, capped by maxPushImpulse.
+        const toBodyX = body.x - x;
+        const toBodyZ = body.z - z;
+        const dirLen = deterministicKccSqrtLength(toBodyX, toBodyZ);
+        const dirX = dirLen === 0 ? (velocity.vx >= 0 ? 1 : -1) : toBodyX / dirLen;
+        const dirZ = dirLen === 0 ? 0 : toBodyZ / dirLen;
+        const speedIntoBody = Math.max(0, velocity.vx * dirX + velocity.vz * dirZ);
+        if (speedIntoBody === 0) {
+            continue;
+        }
+        const magnitude = Math.min(speedIntoBody * KCC_PUSH_MASS, maxPushImpulse);
+        impulses.push({
+            bodyId: body.id,
+            impulse: { x: dirX * magnitude, y: 0, z: dirZ * magnitude },
+            point: { x: body.x, y, z: body.z },
+        });
+    }
+    return impulses;
+}
+function deterministicKccSqrtLength(dx, dz) {
+    const squared = dx * dx + dz * dz;
+    if (squared <= 0) {
+        return 0;
+    }
+    let estimate = 1;
+    let magnitude = squared;
+    while (magnitude >= 4) {
+        magnitude /= 4;
+        estimate *= 2;
+    }
+    if (magnitude > 1) {
+        estimate *= 2;
+    }
+    for (let iteration = 0; iteration < 8; iteration += 1) {
+        estimate = (estimate + squared / estimate) / 2;
+    }
+    return estimate;
+}
+/**
+ * World-space Y half-extent of a ground body's top surface, honoring full
+ * quaternion orientation (the feet probe is orientation-aware, so the snap height
+ * must be too, or a tilted prop would float/sink). Spheres are orientation
+ * invariant; box/capsule project their local extents onto world +Y.
+ */
+/**
+ * World-space top-surface Y of a body directly under the point (x,z), or
+ * undefined if (x,z) is outside the body's horizontal footprint (so a KCC beside
+ * a body — a side/wall contact — is not treated as standing on it). Compound
+ * bodies resolve per child, so an L-shaped prop reports the flat part's height
+ * when the KCC is over the flat part, not the tallest child's.
+ */
+function groundContactTopAt(body, x, z) {
+    const q = body.orientation ?? { x: 0, y: 0, z: 0, w: 1 };
+    const shape = body.shape;
+    if (shape.type === 'box' || shape.type === 'sphere' || shape.type === 'capsule') {
+        const ext = primitiveHalfExtent(shape, (0, physics3d_shared_js_1.quatToMat3)(q));
+        if (Math.abs(x - body.x) > ext.x || Math.abs(z - body.z) > ext.z) {
+            return undefined;
+        }
+        return body.y + ext.y;
+    }
+    if (shape.type === 'compound') {
+        let top;
+        for (const child of shape.children) {
+            const center = { x: body.x, y: body.y, z: body.z };
+            const worldOffset = (0, physics3d_shared_js_1.rotatePointByQuat)(q, child.offset);
+            const childCenterX = center.x + worldOffset.x;
+            const childCenterZ = center.z + worldOffset.z;
+            const childQ = (0, physics3d_shared_js_1.quatMultiply)(q, (0, physics3d_shared_js_1.quaternionFromQuarterTurns)(child.quarterTurns ?? { x: 0, y: 0, z: 0 }));
+            const childExt = primitiveHalfExtent(child.shape, (0, physics3d_shared_js_1.quatToMat3)(childQ));
+            if (Math.abs(x - childCenterX) > childExt.x || Math.abs(z - childCenterZ) > childExt.z) {
+                continue;
+            }
+            const childTop = center.y + worldOffset.y + childExt.y;
+            top = top === undefined ? childTop : Math.max(top, childTop);
+        }
+        return top;
+    }
+    return undefined; // mesh: static-only, not a stand-on platform
+}
+/** World half-extents (x,y,z) of a primitive shape under rotation matrix `m`. */
+function primitiveHalfExtent(shape, m) {
+    if (shape.type === 'sphere') {
+        return { x: shape.radius, y: shape.radius, z: shape.radius };
+    }
+    if (shape.type === 'box') {
+        return {
+            x: Math.abs(m[0]) * shape.halfX + Math.abs(m[1]) * shape.halfY + Math.abs(m[2]) * shape.halfZ,
+            y: Math.abs(m[3]) * shape.halfX + Math.abs(m[4]) * shape.halfY + Math.abs(m[5]) * shape.halfZ,
+            z: Math.abs(m[6]) * shape.halfX + Math.abs(m[7]) * shape.halfY + Math.abs(m[8]) * shape.halfZ,
+        };
+    }
+    // capsule: segment along local Y, spherical caps radius r
+    return {
+        x: Math.abs(m[1]) * shape.halfHeight + shape.radius,
+        y: Math.abs(m[4]) * shape.halfHeight + shape.radius,
+        z: Math.abs(m[7]) * shape.halfHeight + shape.radius,
+    };
+}
+/** A dynamic body directly under the KCC feet, with its per-frame delta. */
+function dynamicGroundUnderKcc(physics, x, y, z, geometry, ignoredBodyIds) {
+    const feetY = y - geometry.halfHeight - geometry.skinWidth;
+    const probe = {
+        shape: { type: 'sphere', radius: geometry.radius },
+        x,
+        y: feetY,
+        z,
+        hitStatics: false,
+        hitDynamics: true,
+        hitKinematics: false,
+    };
+    const hitIds = new Set((0, physics3d_js_1.overlapDeterministicPhysics3D)(physics, probe));
+    // The KCC must stand OVER the body's horizontal footprint, not beside it —
+    // otherwise walking into a crate's side (a feet-level overlap with a body whose
+    // top towers above the feet) would vault the capsule onto the top.
+    const grounds = physics.bodies
+        .filter((body) => body.kind === 'dynamic' && hitIds.has(body.id) && !ignoredBodyIds.has(body.id))
+        .map((body) => ({ body, top: groundContactTopAt(body, x, z) }))
+        .filter((candidate) => candidate.top !== undefined)
+        .sort((left, right) => right.top - left.top || compareStrings(left.body.id, right.body.id));
+    const ground = grounds[0];
+    if (ground === undefined) {
+        return undefined;
+    }
+    return {
+        bodyId: ground.body.id,
+        topY: ground.top + geometry.halfHeight + geometry.skinWidth,
+        deltaX: ground.body.vx,
+        deltaZ: ground.body.vz,
+    };
+}
+const CARRY_GRAB_MAX_FORCE = 40;
+/**
+ * Drive a `grab` joint target from a carrier pose (the pick-up/carry/throw loop).
+ * While held, returns the grab joint pointing at a hold point ahead of the
+ * carrier; on release, returns a throw impulse (carrier velocity + throw
+ * strength along forward).
+ */
+function stepDeterministicCarry3D(carry, carrierPose) {
+    const forwardLen = deterministicKccSqrtLength3(carrierPose.forwardX, carrierPose.forwardY, carrierPose.forwardZ);
+    const fx = forwardLen === 0 ? 0 : carrierPose.forwardX / forwardLen;
+    const fy = forwardLen === 0 ? 0 : carrierPose.forwardY / forwardLen;
+    const fz = forwardLen === 0 ? 0 : carrierPose.forwardZ / forwardLen;
+    if (carry.released === true) {
+        return {
+            throwImpulse: {
+                bodyId: carry.bodyId,
+                impulse: {
+                    x: carrierPose.vx + fx * carry.throwStrength,
+                    y: carrierPose.vy + fy * carry.throwStrength,
+                    z: carrierPose.vz + fz * carry.throwStrength,
+                },
+            },
+        };
+    }
+    return {
+        joint: {
+            id: `carry-${carry.bodyId}`,
+            type: 'grab',
+            body: carry.bodyId,
+            anchor: { x: 0, y: 0, z: 0 },
+            targetX: carrierPose.x + fx * carry.holdDistance,
+            targetY: carrierPose.y + fy * carry.holdDistance,
+            targetZ: carrierPose.z + fz * carry.holdDistance,
+            maxForce: CARRY_GRAB_MAX_FORCE,
+        },
+    };
+}
+function deterministicKccSqrtLength3(dx, dy, dz) {
+    return deterministicKccSqrtLength(deterministicKccSqrtLength(dx, dy), dz);
+}
 function runDeterministicKcc3DFilterForceFixture() {
     const first = runKcc3DFilterForceCases();
     const second = runKcc3DFilterForceCases();

package/dist/cjs/node.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stableEngineParityJson = exports.runEngineParitySuite = exports.explainEngineParityFixture = exports.runChaosCertificationSuite = exports.explainChaosFixture = exports.startLocalWebSocketProtocolServer = exports.runLocalWebSocketAdapterTest = exports.runNetworkedInputAuthoritySpike = exports.defaultNetworkedInputAuthoritySpikeOptions = exports.verifyReplay = exports.createSyncplaySession = exports.createOfflineSession = void 0;
+exports.stableEngineParityJson = exports.runEngineParitySuite = exports.explainEngineParityFixture = exports.runChaosCertificationSuite = exports.explainChaosFixture = exports.startLocalWebSocketProtocolServer = exports.runLocalWebSocketAdapterTest = exports.runNetworkedInputAuthoritySpike = exports.defaultNetworkedInputAuthoritySpikeOptions = exports.verifyReplayScoreAgainstTrustedRuntime = exports.verifyReplay = exports.createSyncplaySession = exports.createOfflineSession = void 0;
 __exportStar(require("./multiplayer-service.js"), exports);
 __exportStar(require("./input-authority.js"), exports);
 __exportStar(require("./local-authority-wire.js"), exports);
@@ -31,6 +31,8 @@ __exportStar(require("./session-promotion.js"), exports);
 var replay_js_1 = require("./replay.js");
 Object.defineProperty(exports, "verifyReplay", { enumerable: true, get: function () { return replay_js_1.verifyReplay; } });
 __exportStar(require("./replay-scoring.js"), exports);
+var replay_bundle_js_1 = require("./replay-bundle.js");
+Object.defineProperty(exports, "verifyReplayScoreAgainstTrustedRuntime", { enumerable: true, get: function () { return replay_bundle_js_1.verifyReplayScoreAgainstTrustedRuntime; } });
 __exportStar(require("./match-log.js"), exports);
 __exportStar(require("./authority-room.js"), exports);
 __exportStar(require("./ws-frame.js"), exports);

package/dist/cjs/physics-cert.js

@@ -37,6 +37,8 @@ exports.runPhysicsCert = runPhysicsCert;
 exports.runRapierPhysicsCert = runRapierPhysicsCert;
 const canonical_js_1 = require("./canonical.js");
 const collision_js_1 = require("./collision.js");
+const physics3d_js_1 = require("./physics3d.js");
+const physics3d_vehicle_js_1 = require("./physics3d-vehicle.js");
 const rapier2dCompatPackage = '@dimforge/rapier2d-compat';
 const physicsCertResults = {
     true: 'pass',
@@ -44,8 +46,9 @@ const physicsCertResults = {
 };
 function runPhysicsCert(options) {
     validateOptions(options);
-    const uninterrupted = runPhysicsSimulation(options, false);
-    const restored = runPhysicsSimulation(options, true);
+    const simulate = options.engine === 'builtin-rigid' ? runRigidSimulation : runPhysicsSimulation;
+    const uninterrupted = simulate(options, false);
+    const restored = simulate(options, true);
     const snapshotBytes = [...restored.snapshotBytes].sort((left, right) => left - right);
     const stepTimings = [...restored.stepTimings].sort((left, right) => left - right);
     const snapshotTimings = [...restored.snapshotTimings].sort((left, right) => left - right);
@@ -59,11 +62,11 @@ function runPhysicsCert(options) {
         snapshotHashStable;
     return {
         engine: options.engine,
-        engineVersion: 'builtin-fixed@1',
+        engineVersion: options.engine === 'builtin-rigid' ? 'builtin-rigid@1' : 'builtin-fixed@1',
         adapterVersion: 'physics-cert@1',
         shape: options.shape,
         players: options.players,
-        bodies: createInitialBodies(options).length,
+        bodies: options.engine === 'builtin-rigid' ? countRigidArenaBodies(options) : createInitialBodies(options).length,
         frames: options.frames,
         snapshotEvery: options.snapshotEvery,
         seed: options.seed,
@@ -267,6 +270,144 @@ function quantizeRapierNumber(value) {
 function countRapierDynamicBodies(options) {
     return options.players * (options.shape === 'fixed-arena' ? 2 : 4);
 }
+function arenaVehicleWheel(localAnchor, steered) {
+    return {
+        localAnchor,
+        suspensionDir: { x: 0, y: -1, z: 0 },
+        suspensionRestLength: 0.6,
+        suspensionMaxTravel: 0.3,
+        radius: 0.3,
+        stiffness: 60,
+        damping: 220,
+        grip: 1,
+        maxSteerAngleTurns: 0.1,
+        isSteered: steered,
+        isDriven: steered,
+    };
+}
+/** Scripted arena driving: launch, weave, then brake to a stop. */
+function arenaVehicleInput(frame) {
+    if (frame >= 400) {
+        return { throttle: 0, steer: 0, brake: 10 };
+    }
+    return { throttle: 10, steer: Math.trunc(frame / 32) % 2 === 0 ? 10 : -10, brake: 0 };
+}
+/**
+ * Mixed rigid arena exercising every solver feature the determinism gates must
+ * cover: a settling stack, a hinge door with a motor, a grab-target box, and a
+ * high-speed ccd projectile per player.
+ */
+function buildRigidArena(options) {
+    const bodies = [{
+            id: 'arena-floor', kind: 'static', x: 0, y: 0, z: 0, vx: 0, vy: 0, vz: 0,
+            shape: { type: 'box', halfX: 400, halfY: 0.5, halfZ: 400 }, layer: 1, mask: 1,
+            material: { friction: 10, restitution: 0 },
+        }];
+    const joints = [];
+    const ident = { x: 0, y: 0, z: 0, w: 1 };
+    for (let slot = 0; slot < options.players; slot += 1) {
+        const baseX = slot * 12 + (options.seed % 3);
+        // stack of 3 boxes
+        for (let layer = 0; layer < 3; layer += 1) {
+            bodies.push({
+                id: `stack-${slot}-${layer}`, kind: 'dynamic', x: baseX, y: 0.5 + 0.5 + layer, z: 0,
+                vx: 0, vy: 0, vz: 0, mass: 1, orientation: ident, angularVel: { x: 0, y: 0, z: 0 },
+                shape: { type: 'box', halfX: 0.5, halfY: 0.5, halfZ: 0.5 }, layer: 1, mask: 1,
+                material: { friction: 8, restitution: 0 },
+            });
+        }
+        // hinge door
+        bodies.push({ id: `frame-${slot}`, kind: 'static', x: baseX + 3, y: 2, z: 0, vx: 0, vy: 0, vz: 0, shape: { type: 'box', halfX: 0.1, halfY: 0.5, halfZ: 0.5 }, layer: 1, mask: 1 });
+        bodies.push({ id: `door-${slot}`, kind: 'dynamic', x: baseX + 4, y: 2, z: 0, vx: 0, vy: 0, vz: 0, mass: 1, orientation: ident, angularVel: { x: 0, y: 0, z: 0 }, shape: { type: 'box', halfX: 1, halfY: 0.5, halfZ: 0.1 }, layer: 1, mask: 1 });
+        joints.push({ id: `hinge-${slot}`, type: 'hinge', a: `frame-${slot}`, b: `door-${slot}`, anchorA: { x: 0, y: 0, z: 0 }, anchorB: { x: -1, y: 0, z: 0 }, axisA: { x: 0, y: 1, z: 0 }, motorSpeed: 0.02, maxMotorTorque: 50 });
+        // grab-target box
+        bodies.push({ id: `grab-${slot}`, kind: 'dynamic', x: baseX + 6, y: 3, z: 0, vx: 0, vy: 0, vz: 0, mass: 1, orientation: ident, angularVel: { x: 0, y: 0, z: 0 }, shape: { type: 'box', halfX: 0.5, halfY: 0.5, halfZ: 0.5 }, layer: 1, mask: 1 });
+        joints.push({ id: `carry-${slot}`, type: 'grab', body: `grab-${slot}`, anchor: { x: 0, y: 0, z: 0 }, targetX: baseX + 6, targetY: 4, targetZ: 0, maxForce: 20 });
+        // ccd projectile toward a thin wall
+        bodies.push({ id: `wall-${slot}`, kind: 'static', x: baseX + 9, y: 2, z: 0, vx: 0, vy: 0, vz: 0, shape: { type: 'box', halfX: 0.05, halfY: 2, halfZ: 2 }, layer: 1, mask: 1 });
+        bodies.push({ id: `bullet-${slot}`, kind: 'dynamic', x: baseX - 20, y: 2, z: 0, vx: 60, vy: 0, vz: 0, mass: 1, orientation: ident, angularVel: { x: 0, y: 0, z: 0 }, ccd: true, linearDamping: 1, angularDamping: 1, shape: { type: 'box', halfX: 0.2, halfY: 0.2, halfZ: 0.2 }, layer: 1, mask: 1 });
+        // soft spring: bob hung 2 below a static anchor, restLength 1 → oscillates and settles
+        bodies.push({ id: `spring-anchor-${slot}`, kind: 'static', x: baseX + 2, y: 6, z: 3, vx: 0, vy: 0, vz: 0, shape: { type: 'box', halfX: 0.1, halfY: 0.1, halfZ: 0.1 }, layer: 2, mask: 2 });
+        bodies.push({ id: `spring-bob-${slot}`, kind: 'dynamic', x: baseX + 2, y: 4, z: 3, vx: 0, vy: 0, vz: 0, mass: 1, orientation: ident, angularVel: { x: 0, y: 0, z: 0 }, shape: { type: 'box', halfX: 0.3, halfY: 0.3, halfZ: 0.3 }, layer: 2, mask: 2 });
+        joints.push({ id: `spring-${slot}`, type: 'spring', a: `spring-anchor-${slot}`, b: `spring-bob-${slot}`, anchorA: { x: 0, y: 0, z: 0 }, anchorB: { x: 0, y: 0, z: 0 }, restLength: 1, frequencyHz: 2, dampingRatio: 0.5 });
+    }
+    // raycast-wheel vehicle: dropped onto the floor, then driven by a scripted
+    // input sequence (see arenaVehicleInput), clear of the per-slot clutter
+    bodies.push({
+        id: 'arena-car', kind: 'dynamic', x: -6, y: 2.55, z: 12,
+        vx: 0, vy: 0, vz: 0, mass: 1200, orientation: ident, angularVel: { x: 0, y: 0, z: 0 },
+        shape: { type: 'box', halfX: 1, halfY: 0.25, halfZ: 2 }, layer: 1, mask: 1,
+    });
+    const vehicle = {
+        chassisId: 'arena-car',
+        driveForce: 12,
+        brakeForce: 40,
+        wheels: [
+            arenaVehicleWheel({ x: -0.9, y: -0.25, z: 1.5 }, true),
+            arenaVehicleWheel({ x: 0.9, y: -0.25, z: 1.5 }, true),
+            arenaVehicleWheel({ x: -0.9, y: -0.25, z: -1.5 }, false),
+            arenaVehicleWheel({ x: 0.9, y: -0.25, z: -1.5 }, false),
+        ],
+    };
+    return { world: (0, physics3d_js_1.createDeterministicPhysicsWorld3D)(bodies), joints, vehicle };
+}
+function countRigidArenaBodies(options) {
+    return 2 + options.players * 10; // floor + arena car + (3 stack + frame + door + grab + wall + bullet + spring anchor + spring bob)
+}
+function runRigidSimulation(options, withRestore) {
+    const { world: initialWorld, joints, vehicle } = buildRigidArena(options);
+    let world = initialWorld;
+    const collisionEvents = [];
+    const stepTimings = [];
+    const snapshotTimings = [];
+    const restoreTimings = [];
+    const snapshotBytes = [];
+    const snapshotChecksums = [];
+    let queryOrderStable = true;
+    for (let frame = 0; frame < options.frames; frame += 1) {
+        const stepStartedAt = performance.now();
+        const drive = (0, physics3d_vehicle_js_1.stepDeterministicVehicle3D)(vehicle, arenaVehicleInput(frame), world, { dtTicks: 1 });
+        world = (0, physics3d_js_1.applyDeterministicImpulses3D)(world, drive.impulses.map((impulse) => ({
+            bodyId: impulse.bodyId,
+            impulse: impulse.impulse,
+            worldPoint: impulse.point,
+        })));
+        const step = (0, physics3d_js_1.stepDeterministicPhysicsWorld3D)(world, { gravityY: -0.02, joints, computeChecksum: false });
+        world = step.world;
+        stepTimings.push(performance.now() - stepStartedAt);
+        for (const contact of step.contacts) {
+            collisionEvents.push(`${frame + 1}:${contact.pair}:${contact.type}`);
+        }
+        if (withRestore && frame % options.snapshotEvery === 0) {
+            const snapshotStartedAt = performance.now();
+            // snapshot the WHOLE world including contactCache/jointCache — dropping the
+            // cache here would diverge (the negative case the spike identified).
+            const snapshot = JSON.stringify(world);
+            snapshotTimings.push(performance.now() - snapshotStartedAt);
+            snapshotBytes.push(Buffer.byteLength(snapshot));
+            snapshotChecksums.push({ first: (0, canonical_js_1.defaultChecksum)(snapshot), second: (0, canonical_js_1.defaultChecksum)(JSON.stringify(world)) });
+            const restoreStartedAt = performance.now();
+            world = JSON.parse(snapshot);
+            restoreTimings.push(performance.now() - restoreStartedAt);
+        }
+        const hits = (0, physics3d_js_1.raycastDeterministicPhysics3D)(world, { x: -1000, y: 2, z: 0, dx: 1, dy: 0, dz: 0, maxDistance: 5000, layerMask: 1 });
+        for (let index = 1; index < hits.length; index += 1) {
+            if (hits[index].distance < hits[index - 1].distance) {
+                queryOrderStable = false;
+            }
+        }
+    }
+    return {
+        finalChecksum: (0, canonical_js_1.defaultChecksum)(world),
+        collisionEvents,
+        queryOrderStable,
+        stepTimings,
+        snapshotTimings,
+        restoreTimings,
+        snapshotBytes,
+        snapshotChecksums,
+    };
+}
 function runPhysicsSimulation(options, withRestore) {
     let state = {
         frame: 0,
@@ -396,8 +537,8 @@ function physicsCertResult(pass) {
     return physicsCertResults[String(pass)];
 }
 function validateOptions(options) {
-    if (options.engine !== 'builtin-fixed') {
-        throw new Error('physics certification currently supports engine=builtin-fixed');
+    if (options.engine !== 'builtin-fixed' && options.engine !== 'builtin-rigid') {
+        throw new Error('physics certification currently supports engine=builtin-fixed or engine=builtin-rigid');
     }
     validateCommonOptions(options);
 }

package/dist/cjs/physics2d.js

@@ -272,18 +272,22 @@ function separateDynamicPair(a, b) {
         const correctionA = Math.ceil(overlapX / 2);
         const correctionB = Math.ceil(overlapX / 2);
         return {
-            a: { ...a, x: a.x + direction * correctionA, vx: normalizeZero(Math.trunc((-a.vx * material.restitution) / 10)) },
-            b: { ...b, x: b.x - direction * correctionB, vx: normalizeZero(Math.trunc((-b.vx * material.restitution) / 10)) },
+            a: { ...a, x: a.x + direction * correctionA, vx: normalizeZero(Math.trunc((-a.vx * material.restitution) / 10)), vy: applyTangentFriction2D(a.vy, material.friction) },
+            b: { ...b, x: b.x - direction * correctionB, vx: normalizeZero(Math.trunc((-b.vx * material.restitution) / 10)), vy: applyTangentFriction2D(b.vy, material.friction) },
         };
     }
     const direction = a.y <= b.y ? -1 : 1;
     const correctionA = Math.ceil(overlapY / 2);
     const correctionB = Math.ceil(overlapY / 2);
     return {
-        a: { ...a, y: a.y + direction * correctionA, vy: normalizeZero(Math.trunc((-a.vy * material.restitution) / 10)) },
-        b: { ...b, y: b.y - direction * correctionB, vy: normalizeZero(Math.trunc((-b.vy * material.restitution) / 10)) },
+        a: { ...a, y: a.y + direction * correctionA, vy: normalizeZero(Math.trunc((-a.vy * material.restitution) / 10)), vx: applyTangentFriction2D(a.vx, material.friction) },
+        b: { ...b, y: b.y - direction * correctionB, vy: normalizeZero(Math.trunc((-b.vy * material.restitution) / 10)), vx: applyTangentFriction2D(b.vx, material.friction) },
     };
 }
+/** Integer tangential-friction scaling, mirroring physics3d's legacy pusher semantics. */
+function applyTangentFriction2D(velocity, friction) {
+    return normalizeZero(Math.trunc((velocity * Math.max(0, 10 - friction)) / 10));
+}
 function separateFromStatic(dynamicBody, staticBody) {
     const dynamicBounds = bodyBounds(dynamicBody);
     const staticBounds = bodyBounds(staticBody);
@@ -299,6 +303,7 @@ function separateFromStatic(dynamicBody, staticBody) {
             ...dynamicBody,
             x: dynamicBody.x + direction * overlapX,
             vx: normalizeZero(Math.trunc((-dynamicBody.vx * material.restitution) / 10)),
+            vy: applyTangentFriction2D(dynamicBody.vy, material.friction),
         };
     }
     const direction = dynamicBody.y < staticBody.y ? -1 : 1;
@@ -306,6 +311,7 @@ function separateFromStatic(dynamicBody, staticBody) {
         ...dynamicBody,
         y: dynamicBody.y + direction * overlapY,
         vy: normalizeZero(Math.trunc((-dynamicBody.vy * material.restitution) / 10)),
+        vx: applyTangentFriction2D(dynamicBody.vx, material.friction),
     };
 }
 function detectContacts(bodies) {