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

package/dist/cli.js

@@ -3123,7 +3123,7 @@ async function runProjectCertify(args) {
     if (manifest.creatorEntrypoints !== undefined || requiredSections.includes('creator-boundary')) {
         sections.push(await certifyProjectCreatorBoundary(manifest, manifestDir));
     }
-    sections.push(await certifyProjectStatic(manifest, manifestDir, schemaStateFields));
+    sections.push(await certifyProjectStatic(manifest, manifestDir, schemaStateFields, requiredSections.includes('static-determinism')));
     const sectionFailures = sections.flatMap((section) => section.failures.map((failure) => `${section.section}: ${failure}`));
     failures.push(...sectionFailures);
     const skippedRequiredSections = requiredSections.filter((section) => !projectRequirementSatisfied(section, sections));
@@ -3267,7 +3267,9 @@ async function runProjectCheck(args) {
     const browserJsonPath = readString(args, 'browser-json') ?? (browserRuntime === undefined ? undefined : join(outDir, `project-browser-proof-${browserRuntime}.json`));
     process.exitCode = undefined;
     await runProjectCertify(projectSubcommandArgs('project:certify', [manifestPath], {
-        require: readString(args, 'require'),
+        // project:check is the deployable preflight, so it must certify a
+        // file-backed simulation module even when the caller passes no --require.
+        require: readString(args, 'require') ?? 'static-determinism',
         frames: readString(args, 'frames'),
         agents: readString(args, 'agents'),
         slots: readString(args, 'slots'),
@@ -6258,9 +6260,27 @@ async function certifyProjectAnimations(manifest, manifestDir, frames) {
     }
     return sections;
 }
-async function certifyProjectStatic(manifest, manifestDir, schemaStateFields) {
+async function certifyProjectStatic(manifest, manifestDir, schemaStateFields, required) {
     const paths = manifest.staticPaths ?? [];
     if (paths.length === 0) {
+        // A deployable project must prove its simulation is a real, file-backed
+        // module. When the caller requires this section but the manifest lists no
+        // staticPaths, fail loudly with a pointed message instead of silently
+        // skipping. Advisory runs (section not required) still skip.
+        if (required) {
+            return {
+                section: 'static-determinism',
+                result: 'fail',
+                metrics: {
+                    checkedPaths: 0,
+                    diagnostics: 0,
+                    errors: 0,
+                    warnings: 0,
+                    parser: getDeterminismParserKind(),
+                },
+                failures: ['static-determinism requires at least one staticPaths entry'],
+            };
+        }
         return skippedProjectSection('static-determinism');
     }
     const resolvedPaths = paths.map((path) => resolveManifestPath(manifestDir, path));
@@ -6484,6 +6504,14 @@ async function certifyProjectReplayRuntime(manifest, manifestDir, outDir, frames
             projectAuthoredSystemFrames: authoredSystemFrames,
             projectAuthoredSystemChecksum: authoredSystemChecksum,
             frames: replayFrames,
+            // Game identity for the M8.5 deploy-time verification manifest: the
+            // cloud-run deploy interceptor keys the stored trusted manifest by
+            // deterministicVersion and the score re-run gates on all three. They live
+            // on the game descriptor (not the runtimeReplay sub-object), so they are
+            // copied into the bundle metadata explicitly here.
+            deterministicVersion: projectDescriptor?.deterministicVersion ?? '',
+            inputSchemaId: projectDescriptor?.input.id ?? '',
+            stateSchemaId: projectDescriptor?.state.id ?? '',
         },
     });
     const verification = verifyDeterministicFrameRuntimeReplayBundle(bundle, {
@@ -8841,7 +8869,7 @@ async function runOfflineReplay(args) {
         checksums: checksumCount,
         mismatches: 0,
         finalChecksum,
-        replayRecordingMode: retainReplay ? 'memory' : 'metrics',
+        replayRecordingMode: retainReplay ? 'memory' : 'none',
         replayBytes,
         inputBytesPerTick: (inputBytes / frames).toFixed(2),
         packedInputBytesPerTick: (packedInputBytes / frames).toFixed(2),
@@ -9271,7 +9299,7 @@ async function runReplayVerifyBrowser(args) {
             return;
         }
         const page = await browser.newPage();
-        await page.goto(`${baseUrl}/dist/browser.js`);
+        await page.goto(`${baseUrl}/dist/testing.js`);
         const result = await page.evaluate(async ({ moduleUrl, replay: browserReplay }) => {
             const mod = (await import(moduleUrl));
             return mod.verifyReplay({
@@ -9283,7 +9311,7 @@ async function runReplayVerifyBrowser(args) {
                 deterministicVersion: '0.0.0-source',
                 hydrateInput: mod.hydrateLabInput,
             });
-        }, { moduleUrl: `${baseUrl}/dist/browser.js`, replay });
+        }, { moduleUrl: `${baseUrl}/dist/testing.js`, replay });
         const elapsedMs = performance.now() - startedAt;
         const replayHash = defaultChecksum(replayText);
         const browserBundleHash = defaultChecksum(await readFile(resolve(packageRoot, 'dist/browser.js'), 'utf8'));
@@ -9369,11 +9397,11 @@ async function runNumberBrowser(args) {
             return;
         }
         const page = await browser.newPage();
-        await page.goto(`${baseUrl}/dist/browser.js`);
+        await page.goto(`${baseUrl}/dist/testing.js`);
         const browserResult = await page.evaluate(async ({ moduleUrl, mode, frames, seed }) => {
             const mod = (await import(moduleUrl));
             return mod.runNumberLab({ mode, frames, seed });
-        }, { moduleUrl: `${baseUrl}/dist/browser.js`, mode, frames, seed });
+        }, { moduleUrl: `${baseUrl}/dist/testing.js`, mode, frames, seed });
         const elapsedMs = performance.now() - startedAt;
         const checksumMatch = nodeResult.finalChecksum === browserResult.finalChecksum;
         const valueMatch = Object.is(nodeResult.finalValue, browserResult.finalValue);
@@ -9453,11 +9481,11 @@ async function runEngineCoreBrowser(args) {
             return;
         }
         const page = await browser.newPage();
-        await page.goto(`${baseUrl}/dist/browser.js`);
+        await page.goto(`${baseUrl}/dist/testing.js`);
         const browserProof = await page.evaluate(async ({ moduleUrl, players, frames, seed }) => {
             const mod = (await import(moduleUrl));
             return mod.runDeterministicEngineCoreNumericProof({ players, frames, seed });
-        }, { moduleUrl: `${baseUrl}/dist/browser.js`, players, frames, seed });
+        }, { moduleUrl: `${baseUrl}/dist/testing.js`, players, frames, seed });
         const elapsedMs = performance.now() - startedAt;
         const browserBundleHash = defaultChecksum(await readFile(resolve(packageRoot, 'dist/browser.js'), 'utf8'));
         const packageBuildHash = defaultChecksum(await readFile(resolve(packageRoot, 'dist/index.js'), 'utf8'));
@@ -10805,8 +10833,8 @@ function readOptionalProjectBrowserRuntime(args) {
 }
 function readPhysicsCertEngine(args) {
     const engine = readString(args, 'engine') ?? 'builtin-fixed';
-    if (engine !== 'builtin-fixed' && engine !== 'rapier2d-compat') {
-        throw new Error('--engine must be builtin-fixed or rapier2d-compat');
+    if (engine !== 'builtin-fixed' && engine !== 'builtin-rigid' && engine !== 'rapier2d-compat') {
+        throw new Error('--engine must be builtin-fixed, builtin-rigid, or rapier2d-compat');
     }
     return engine;
 }

package/dist/collision.d.ts

@@ -1,3 +1,4 @@
+import type { DeterministicMath } from './math.js';
 export type FixedVec2 = {
     readonly x: number;
     readonly y: number;
@@ -23,3 +24,14 @@ export declare function translateAabb(aabb: FixedAabb, delta: FixedVec2): FixedA
 export declare function sortAabbsByStableId<T extends {
     readonly id: string;
 }>(items: readonly T[]): readonly T[];
+/**
+ * Orientation of the ordered triple (a, b, c): +1 counter-clockwise, -1
+ * clockwise, 0 collinear. Pure integer cross-product; scale-free.
+ */
+export declare function orientation(a: FixedVec2, b: FixedVec2, c: FixedVec2): -1 | 0 | 1;
+/** True when p lies within the axis-aligned bounding box of segment [a, b]. */
+export declare function pointOnSegment(p: FixedVec2, a: FixedVec2, b: FixedVec2): boolean;
+export declare function segmentsIntersect(a0: FixedVec2, a1: FixedVec2, b0: FixedVec2, b1: FixedVec2): boolean;
+export declare function closestPointOnSegment(p: FixedVec2, a: FixedVec2, b: FixedVec2, math: DeterministicMath): FixedVec2;
+export declare function segmentPointDistance(p: FixedVec2, a: FixedVec2, b: FixedVec2, math: DeterministicMath): number;
+export declare function segmentSegmentDistance(a0: FixedVec2, a1: FixedVec2, b0: FixedVec2, b1: FixedVec2, math: DeterministicMath): number;

package/dist/collision.js

@@ -83,3 +83,55 @@ function assertInteger(value, name) {
         throw new Error(`${name} must be an integer fixed-point value`);
     }
 }
+/**
+ * Orientation of the ordered triple (a, b, c): +1 counter-clockwise, -1
+ * clockwise, 0 collinear. Pure integer cross-product; scale-free.
+ */
+export function orientation(a, b, c) {
+    const v = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+    return v > 0 ? 1 : v < 0 ? -1 : 0;
+}
+/** True when p lies within the axis-aligned bounding box of segment [a, b]. */
+export function pointOnSegment(p, a, b) {
+    return (p.x >= Math.min(a.x, b.x) &&
+        p.x <= Math.max(a.x, b.x) &&
+        p.y >= Math.min(a.y, b.y) &&
+        p.y <= Math.max(a.y, b.y));
+}
+export function segmentsIntersect(a0, a1, b0, b1) {
+    const d1 = orientation(a0, a1, b0);
+    const d2 = orientation(a0, a1, b1);
+    const d3 = orientation(b0, b1, a0);
+    const d4 = orientation(b0, b1, a1);
+    if (d1 === 0 && pointOnSegment(b0, a0, a1))
+        return true;
+    if (d2 === 0 && pointOnSegment(b1, a0, a1))
+        return true;
+    if (d3 === 0 && pointOnSegment(a0, b0, b1))
+        return true;
+    if (d4 === 0 && pointOnSegment(a1, b0, b1))
+        return true;
+    return d1 !== d2 && d3 !== d4;
+}
+export function closestPointOnSegment(p, a, b, math) {
+    const abx = b.x - a.x;
+    const aby = b.y - a.y;
+    const abLenSq = math.mul(abx, abx) + math.mul(aby, aby);
+    if (abLenSq === 0) {
+        return { x: a.x, y: a.y };
+    }
+    const apx = p.x - a.x;
+    const apy = p.y - a.y;
+    const t = math.clamp(math.div(math.mul(apx, abx) + math.mul(apy, aby), abLenSq), 0, math.fixedScale);
+    return { x: a.x + math.mul(abx, t), y: a.y + math.mul(aby, t) };
+}
+export function segmentPointDistance(p, a, b, math) {
+    const c = closestPointOnSegment(p, a, b, math);
+    return math.hypot(p.x - c.x, p.y - c.y);
+}
+export function segmentSegmentDistance(a0, a1, b0, b1, math) {
+    if (segmentsIntersect(a0, a1, b0, b1)) {
+        return 0;
+    }
+    return math.min(math.min(segmentPointDistance(a0, b0, b1, math), segmentPointDistance(a1, b0, b1, math)), math.min(segmentPointDistance(b0, a0, a1, math), segmentPointDistance(b1, a0, a1, math)));
+}

package/dist/creator.d.ts

@@ -7,7 +7,7 @@ export { createSessionFromPromotionSnapshot, exportPromotionSnapshot } from './s
 export { verifyReplay, verifyReplayWithDescriptor } from './replay.js';
 export { defineSyncplayGame } from './schema.js';
 export { createSchemaArtifacts } from './schema-artifacts.js';
-export { createSyncplayOfflineRuntime } from './sdk-offline.js';
+export { createSyncplayOfflineRuntime, createSyncplayOfflineRuntime as createSyncplayGameRuntime } from './sdk-offline.js';
 export { runSyncplaySynctest } from './synctest.js';
 export type { SyncplaySynctestConfig, SyncplaySynctestDivergence, SyncplaySynctestInputFuzz, SyncplaySynctestPhase, SyncplaySynctestResult, } from './synctest.js';
 export type { CanonicalValue } from './canonical.js';

package/dist/creator.js

@@ -7,5 +7,5 @@ export { createSessionFromPromotionSnapshot, exportPromotionSnapshot } from './s
 export { verifyReplay, verifyReplayWithDescriptor } from './replay.js';
 export { defineSyncplayGame } from './schema.js';
 export { createSchemaArtifacts } from './schema-artifacts.js';
-export { createSyncplayOfflineRuntime } from './sdk-offline.js';
+export { createSyncplayOfflineRuntime, createSyncplayOfflineRuntime as createSyncplayGameRuntime } from './sdk-offline.js';
 export { runSyncplaySynctest } from './synctest.js';

package/dist/engine-complete.js

@@ -17,7 +17,8 @@ import { runDeterministicLocalAuthorityWireFixture } from './local-authority-wir
 import { runDeterministicMulticlientAuthorityFixture } from './multiclient-authority.js';
 import { runDeterministicKcc3DAdversarialFixture, runDeterministicKcc3DCallbackFilterFixture, runDeterministicKcc3DCrowdFixture, runDeterministicKcc3DFilterForceFixture, runDeterministicKcc3DGeometryFixture, stepDeterministicKcc3D } from './movement3d.js';
 import { cookDeterministicNavmesh, findDeterministicNavmeshPath, runDeterministicNavmeshImportTraversalFixture, runDeterministicNavmeshLayered3DFixture, runDeterministicNavmeshStress, runDeterministicNavmeshVelocityObstacleFixture, stepDeterministicNavmeshAgents } from './navmesh.js';
-import { createDeterministicPhysicsWorld3D, runDeterministicPhysics3DCallbackMaskFixture, runDeterministicPhysics3DDetailFixture, runDeterministicPhysics3DMaterialFixture, runDeterministicPhysics3DQueryOptionsFixture, runDeterministicPhysics3DStackFixture, runDeterministicPhysics3DStress, stepDeterministicPhysicsWorld3D, } from './physics3d.js';
+import { createDeterministicPhysicsWorld3D, runDeterministicPhysics3DCallbackMaskFixture, runDeterministicPhysics3DDetailFixture, runDeterministicPhysics3DMaterialFixture, runDeterministicPhysics3DQueryOptionsFixture, runDeterministicPhysics3DStackFixture, runDeterministicPhysics3DStress, applyDeterministicImpulses3D, stepDeterministicPhysicsWorld3D, } from './physics3d.js';
+import { stepDeterministicVehicle3D, } from './physics3d-vehicle.js';
 import { runDeterministicSignalFixture } from './signals.js';
 import { runDeterministicSparseSetFixture } from './sparse-set.js';
 import { runDeterministicLifecycleFixture } from './system-lifecycle.js';
@@ -1217,6 +1218,11 @@ function physicsCategory(bodies, requestedFrames, executedFrames, enforceThresho
     const lagComp3DApi = runDeterministicLagCompensation3DApiFixture();
     const authoritativeLagComp3D = runDeterministicAuthoritativeLagCompensation3DFixture();
     const fullStep = runPhysics3DFullStepMeasurementFixture(Math.min(requestedFrames, 300));
+    // 128-dynamic-body interacting-pile timing sample. Only sampled on long
+    // benchmark runs (>= 2000 frames) so its fixed wall-clock cost amortizes below
+    // the per-frame mean budget; short ad-hoc runs skip it (gates default true).
+    const rigidPile = benchmark && requestedFrames >= 2000 ? runPhysics3DRigidPileMeasurementFixture(128, 200) : undefined;
+    const vehicleFleet = benchmark && requestedFrames >= 2000 ? runVehicle3DFleetMeasurementFixture(16, 200) : undefined;
     const highBodySample512 = requestedFrames > 512 ? runDeterministicPhysics3DStress(512, 128) : undefined;
     const highBodySample2048 = requestedFrames > 512 ? runDeterministicPhysics3DStress(2048, 32) : undefined;
     return categoryReport('physics3d', defaultChecksum({
@@ -1265,11 +1271,15 @@ function physicsCategory(bodies, requestedFrames, executedFrames, enforceThresho
             && stack.settledDynamicBodies === stack.stackLayers,
         stackRollbackEquivalent: stack.rollbackEquivalent,
         stackAuthoringOrderStable: stack.stableUnderAuthoringOrderPermutation,
+        // Rigid-solver material response (impulse-based) — combine semantics unchanged
+        // (floor-average friction, max restitution); the bounce/friction velocity
+        // magnitudes come from the sequential-impulse solver, not the legacy pusher.
         materialResponseCovered: materials.combinedFriction === 3
             && materials.combinedRestitution === 7
-            && materials.normalVelocityAfterBounce === -2
-            && materials.tangentVelocityAfterFrictionY === 7
-            && materials.tangentVelocityAfterFrictionZ === -7,
+            && materials.normalVelocityAfterBounce > 0
+            && materials.tangentVelocityAfterFrictionY < 10
+            && materials.tangentVelocityAfterFrictionZ > -10
+            && materials.tangentVelocityAfterFrictionZ < 0,
         materialRollbackEquivalent: materials.rollbackEquivalent,
         callbackLifecycleCovered: callbackMasks.collisionEnter > 0
             && callbackMasks.collisionStay > 0
@@ -1309,6 +1319,17 @@ function physicsCategory(bodies, requestedFrames, executedFrames, enforceThresho
             && fullStep.p95MeasuredStepMs > 0
             && fullStep.p99MeasuredStepMs > 0,
         fullStepRollbackEquivalent: fullStep.rollbackEquivalent,
+        rigidPileMeasuredTimingCovered: rigidPile === undefined ? true : rigidPile.bodies === 128 && rigidPile.p99MeasuredStepMs > 0,
+        rigidPileRollbackEquivalent: rigidPile === undefined ? true : rigidPile.rollbackEquivalent,
+        vehicleFleetMeasuredTimingCovered: vehicleFleet === undefined
+            ? true
+            : vehicleFleet.vehicles === 16 && vehicleFleet.groundedWheelSamples > 0 && vehicleFleet.p99MeasuredStepMs > 0,
+        vehicleFleetRollbackEquivalent: vehicleFleet === undefined ? true : vehicleFleet.rollbackEquivalent,
+        vehicleFleetP99WithinBudget: enforceThresholds && vehicleFleet !== undefined ? vehicleFleet.p99MeasuredStepMs <= 25 : true,
+        // Measured wall-clock (never in checksummed state). The pooled clip scratch
+        // + constraint pool (provenance pass 6) pulled the burst p99 to ~1.5 ms
+        // locally; the 10 ms gate keeps generous headroom for CI variance.
+        rigidPileP99WithinBudget: enforceThresholds && rigidPile !== undefined ? rigidPile.p99MeasuredStepMs <= 10 : true,
         fullStepContactsAndQueriesCovered: fullStep.contactCount > 0 && fullStep.queryCount === fullStep.frames,
         executedRequestedFrames: metrics.frames === requestedFrames,
         ...(metrics.extrapolatedStress ? {} : {
@@ -1435,6 +1456,13 @@ function physicsCategory(bodies, requestedFrames, executedFrames, enforceThresho
         highBodySample512Frames: highBodySample512?.frames ?? 0,
         highBodySample2048Checksum: highBodySample2048?.checksum ?? '',
         highBodySample2048Frames: highBodySample2048?.frames ?? 0,
+        vehicleFleetChecksum: vehicleFleet?.checksum ?? '',
+        vehicleFleetVehicles: vehicleFleet?.vehicles ?? 0,
+        vehicleFleetFrames: vehicleFleet?.frames ?? 0,
+        vehicleFleetGroundedWheelSamples: vehicleFleet?.groundedWheelSamples ?? 0,
+        vehicleFleetP95MeasuredStepMs: vehicleFleet?.p95MeasuredStepMs ?? 0,
+        vehicleFleetP99MeasuredStepMs: vehicleFleet?.p99MeasuredStepMs ?? 0,
+        vehicleFleetMaxMeasuredStepMs: vehicleFleet?.maxMeasuredStepMs ?? 0,
     }, requestedFrames, metrics.frames));
 }
 function kccCategory(players, requestedFrames, executedFrames, benchmark, noFastStress) {
@@ -1616,6 +1644,188 @@ function runPhysics3DFullStepMeasurementFixture(frames) {
         wallClockElapsedMs: roundMetric(engineCompleteNowMs() - startedAt, 4),
     };
 }
+function createRigidPileBodies3D(bodies) {
+    const out = [{
+            id: 'pile-floor', kind: 'static', x: 0, y: 0, z: 0, vx: 0, vy: 0, vz: 0,
+            shape: { type: 'box', halfX: 40, halfY: 0.5, halfZ: 40 }, layer: 1, mask: 1,
+            material: { friction: 8, restitution: 0 },
+        }];
+    const perRow = 8;
+    for (let index = 0; index < bodies; index += 1) {
+        const column = index % perRow;
+        const rowInLayer = Math.floor(index / perRow) % perRow;
+        const layer = Math.floor(index / (perRow * perRow));
+        out.push({
+            id: `pile-${String(index).padStart(3, '0')}`,
+            kind: 'dynamic',
+            x: (column - perRow / 2) * 1.1,
+            y: 1 + layer * 1.05,
+            z: (rowInLayer - perRow / 2) * 1.1,
+            vx: 0, vy: 0, vz: 0, mass: 1,
+            orientation: { x: 0, y: 0, z: 0, w: 1 }, 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 },
+        });
+    }
+    return out;
+}
+/**
+ * 128-dynamic-body interacting-pile step-cost sample, timed via wall clock
+ * (never enters checksummed state). CI-gated at measured p99 <= 10 ms
+ * (rigidPileP99WithinBudget) — headroom over the ~1.5 ms local burst cost
+ * after the pooled clip scratch + constraint pool (provenance pass 6).
+ */
+function runPhysics3DRigidPileMeasurementFixture(bodies, frames) {
+    const initial = createDeterministicPhysicsWorld3D(createRigidPileBodies3D(bodies));
+    let world = initial;
+    let snapshot = initial;
+    const timings = [];
+    const half = Math.floor(frames / 2);
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === half) {
+            snapshot = world;
+        }
+        const stepStartedAt = engineCompleteNowMs();
+        world = stepDeterministicPhysicsWorld3D(world, { gravityY: -0.02, computeChecksum: false }).world;
+        timings.push(engineCompleteNowMs() - stepStartedAt);
+    }
+    const checksum = defaultChecksum(world);
+    let restored = snapshot;
+    for (let frame = half; frame < frames; frame += 1) {
+        restored = stepDeterministicPhysicsWorld3D(restored, { gravityY: -0.02, computeChecksum: false }).world;
+    }
+    return {
+        checksum,
+        rollbackEquivalent: checksum === defaultChecksum(restored),
+        bodies: world.bodies.filter((body) => body.kind === 'dynamic').length,
+        frames,
+        p95MeasuredStepMs: roundMetric(percentileNumber(timings, 95), 6),
+        p99MeasuredStepMs: roundMetric(percentileNumber(timings, 99), 6),
+        maxMeasuredStepMs: roundMetric(timings.reduce((max, value) => Math.max(max, value), 0), 6),
+    };
+}
+function fleetVehicleWheel(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,
+    };
+}
+/**
+ * Measured wall-clock sample of an N-car raycast-vehicle fleet running the full
+ * controller→impulse→physics loop per frame. Timings never enter checksummed
+ * state; the p99 is gated within the global 25 ms budget.
+ */
+function runVehicle3DFleetMeasurementFixture(vehicleCount, frames) {
+    const bodies = [{
+            id: 'fleet-ground',
+            kind: 'static',
+            x: 0,
+            y: 0,
+            z: 0,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            shape: { type: 'box', halfX: 200, halfY: 0.5, halfZ: 200 },
+            layer: 1,
+            mask: 1,
+            material: { friction: 8, restitution: 0 },
+        }];
+    const vehicles = [];
+    for (let index = 0; index < vehicleCount; index += 1) {
+        const id = `fleet-car-${index}`;
+        bodies.push({
+            id,
+            kind: 'dynamic',
+            x: (index % 4) * 12 - 18,
+            y: 2.55,
+            z: Math.floor(index / 4) * 12 - 18,
+            vx: 0,
+            vy: 0,
+            vz: 0,
+            mass: 1200,
+            orientation: { x: 0, y: 0, z: 0, w: 1 },
+            angularVel: { x: 0, y: 0, z: 0 },
+            shape: { type: 'box', halfX: 1, halfY: 0.25, halfZ: 2 },
+            layer: 1,
+            mask: 1,
+        });
+        vehicles.push({
+            chassisId: id,
+            driveForce: 12,
+            brakeForce: 40,
+            wheels: [
+                fleetVehicleWheel({ x: -0.9, y: -0.25, z: 1.5 }, true),
+                fleetVehicleWheel({ x: 0.9, y: -0.25, z: 1.5 }, true),
+                fleetVehicleWheel({ x: -0.9, y: -0.25, z: -1.5 }, false),
+                fleetVehicleWheel({ x: 0.9, y: -0.25, z: -1.5 }, false),
+            ],
+        });
+    }
+    const stepFleetFrame = (world, frame) => {
+        // every controller reads the same pre-impulse world (pure reads), then all
+        // impulses land in one batched canonical rebuild — the recommended frame
+        // shape for multi-vehicle games
+        let groundedWheels = 0;
+        const frameImpulses = [];
+        for (let index = 0; index < vehicles.length; index += 1) {
+            const input = {
+                throttle: 10,
+                steer: (Math.trunc(frame / 24) + index) % 2 === 0 ? 10 : -10,
+                brake: 0,
+            };
+            const result = stepDeterministicVehicle3D(vehicles[index], input, world, { dtTicks: 1 });
+            groundedWheels += result.wheels.filter((wheel) => wheel.grounded).length;
+            for (const impulse of result.impulses) {
+                frameImpulses.push({ bodyId: impulse.bodyId, impulse: impulse.impulse, worldPoint: impulse.point });
+            }
+        }
+        const next = stepDeterministicPhysicsWorld3D(applyDeterministicImpulses3D(world, frameImpulses), {
+            gravityY: -0.02,
+            computeChecksum: false,
+        }).world;
+        return { world: next, groundedWheels };
+    };
+    const initial = createDeterministicPhysicsWorld3D(bodies);
+    let world = initial;
+    let snapshot = initial;
+    let groundedWheelSamples = 0;
+    const timings = [];
+    const half = Math.floor(frames / 2);
+    for (let frame = 0; frame < frames; frame += 1) {
+        if (frame === half) {
+            snapshot = world;
+        }
+        const stepStartedAt = engineCompleteNowMs();
+        const stepped = stepFleetFrame(world, frame);
+        timings.push(engineCompleteNowMs() - stepStartedAt);
+        world = stepped.world;
+        groundedWheelSamples += stepped.groundedWheels;
+    }
+    const checksum = defaultChecksum(world);
+    let restored = snapshot;
+    for (let frame = half; frame < frames; frame += 1) {
+        restored = stepFleetFrame(restored, frame).world;
+    }
+    return {
+        checksum,
+        rollbackEquivalent: checksum === defaultChecksum(restored),
+        vehicles: vehicles.length,
+        frames,
+        groundedWheelSamples,
+        p95MeasuredStepMs: roundMetric(percentileNumber(timings, 95), 6),
+        p99MeasuredStepMs: roundMetric(percentileNumber(timings, 99), 6),
+        maxMeasuredStepMs: roundMetric(timings.reduce((max, value) => Math.max(max, value), 0), 6),
+    };
+}
 function runKcc3DFullStepMeasurementFixture(players, frames) {
     let bodies = Array.from({ length: players }, (_, slot) => ({
         x: slot % 16,

package/dist/engine-parity-matrix.js

@@ -617,19 +617,34 @@ const engineParityMatrixEntries = [
         currentEvidence: [
             'packages/syncplay/src/physics2d.ts',
             'packages/syncplay/src/physics3d.ts',
+            'packages/syncplay/src/physics3d-solver.ts',
+            'packages/syncplay/src/physics3d-joints.ts',
             'packages/syncplay/tests/physics2d.test.ts',
+            'packages/syncplay/tests/physics3d-solver.test.ts',
+            'packages/syncplay/tests/physics3d-joints.test.ts',
+            'packages/syncplay/tests/physics3d-ccd.test.ts',
             'packages/syncplay/tests/engine-complete.test.ts',
+            'packages/syncplay/src/physics3d-vehicle.ts',
+            'packages/syncplay/tests/physics3d-vehicle.test.ts',
+            'warm-started sequential-impulse solver: stable stacking, tumbling, sleeping, axis locks, joints (ball/hinge/weld/rope/grab), speculative-contact CCD, compound colliders, orientation-aware queries',
+            'builtin-rigid physics-cert lane passes all 4 determinism gates; contact/joint caches are checksummed rollback state',
+            'raycast-wheel vehicle controller (stepDeterministicVehicle3D): spring-damper suspension, friction-circle drive/steer/brake, fixed-point steering trig; certified via the physics-rigid-vehicle fixture, the builtin-rigid arena car, and a rollback-every-frame synctest scene',
+            'per-world static AABB-tree query index: raycast/overlap/shape-cast are O(log n + hits) with bit-identical results (oracle-tested; cert-lane checksums unchanged); batched applyDeterministicImpulses3D applies a frame of controller impulses in one canonical rebuild',
+            'pooled narrow-phase/constraint scratch (scalarized box face-clip over ping-pong clip slots, step-scoped constraint pool) pulled the 128-body pile impact-burst p99 from 2.06 ms to 1.54 ms (p50 0.85 → 0.72 ms, median-of-5); prismatic/breakable/collision-suppressed joints, a soft frequencyHz/dampingRatio spring joint, and per-body gravityScale round out the joint/body surface — joint breaks are sticky checksummed cache state',
         ],
         cliProofs: [
             'npm run lab:physics3d -- --bodies 128 --frames 1000 --no-fast-stress --json artifacts/reports/physics3d-no-fast.json',
             'npm run certify:engine-complete -- --filter physics3d --players 128 --frames 5000 --no-fast-stress',
+            'npm run lab:physics-cert -- --engine builtin-rigid --shape fixed-arena --players 4 --frames 600 --seed 7 --snapshot-every 8',
+            'npm run coverage:package:physics-vehicle',
         ],
         gaps: [
-            'Production-quality stacked rigid-body solving, broad mesh import, full CCD, and long no-fast stress are not proven.',
-            '100k stress can use optimized-tail mode unless no-fast-stress is required.',
+            'Vehicles are raycast-wheel only (static ground, flat/axis-aligned contact normals); moving-ground reaction and rigid-wheel vehicles are tracked follow-ons.',
+            'Dynamic mesh-vs-mesh collision, convex-hull decomposition / visual collider import, and ragdolls-in-checksummed-state remain out of scope.',
+            'Cross-VM certification posture unchanged (V8↔V8 certified; WebKit nightly; Hermes documented gap).',
         ],
         nextCliWork: [
-            'Add adversarial no-fast fixtures for stacks, tunneling, joints, query ordering, 2.5D overload, and rollback equivalence.',
+            'Profile the remaining burst cost before further pooling; no known single lever.',
         ],
         referenceDocs: [
             'external-deterministic-engine-reference:manual/physics/overview',
@@ -793,7 +808,7 @@ const engineParityMatrixEntries = [
             'Integrated samples need stronger per-scene mechanics assertions and replay artifacts.',
         ],
         nextCliWork: [
-            'Add CLI-rendered or artifact-traced Simple FPS, platform shooter, arena brawler, nav agents, animator, KCC playground, vehicle, and waiting-room samples.',
+            'Add CLI-rendered or artifact-traced Simple FPS, platform shooter, arena brawler, nav agents, animator, KCC playground, vehicle (the sample-scenes vehicle is kinematic by design; raycast-wheel physics lives in physics3d-vehicle.ts), and waiting-room samples.',
         ],
         referenceDocs: [
             'external-deterministic-engine-reference:game-samples/engine-simple-fps/overview',