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

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.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);
@@ -23,12 +23,16 @@ __exportStar(require("./session-snapshot.js"), exports);
 __exportStar(require("./networked-client.js"), exports);
 var offline_session_js_1 = require("./offline-session.js");
 Object.defineProperty(exports, "createOfflineSession", { enumerable: true, get: function () { return offline_session_js_1.createOfflineSession; } });
+var sdk_session_js_1 = require("./sdk-session.js");
+Object.defineProperty(exports, "createSyncplaySession", { enumerable: true, get: function () { return sdk_session_js_1.createSyncplaySession; } });
 __exportStar(require("./instant-replay.js"), exports);
 __exportStar(require("./pause-resume.js"), exports);
 __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/noise.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashUint32 = hashUint32;
+exports.hash2 = hash2;
+exports.valueNoise1D = valueNoise1D;
+exports.valueNoise2D = valueNoise2D;
+exports.fbm2D = fbm2D;
+/** Integer avalanche hash (Murmur-style finalizer) → uint32. */
+function hashUint32(x) {
+    let h = x | 0;
+    h = Math.imul(h ^ (h >>> 16), 0x45d9f3b);
+    h = Math.imul(h ^ (h >>> 16), 0x45d9f3b);
+    h = (h ^ (h >>> 16)) >>> 0;
+    return h;
+}
+function hash2(x, y) {
+    return hashUint32((Math.imul(x | 0, 0x1f1f1f1f) ^ Math.imul(y | 0, 0x8da6b343)) >>> 0);
+}
+/** Hash → fixed value in [-scale, scale]. */
+function hashToFixed(h, fixedScale) {
+    return Math.trunc((h / 4294967296) * (2 * fixedScale)) - fixedScale;
+}
+function valueNoise1D(math, xFixed, seed) {
+    const scale = math.fixedScale;
+    const i0 = Math.floor(xFixed / scale);
+    const frac = xFixed - i0 * scale;
+    const g0 = hashToFixed(hash2(i0, seed), scale);
+    const g1 = hashToFixed(hash2(i0 + 1, seed), scale);
+    const t = math.smoothstep(0, scale, frac);
+    return math.lerp(g0, g1, t);
+}
+function valueNoise2D(math, xFixed, yFixed, seed) {
+    const scale = math.fixedScale;
+    const ix = Math.floor(xFixed / scale);
+    const iy = Math.floor(yFixed / scale);
+    const fx = xFixed - ix * scale;
+    const fy = yFixed - iy * scale;
+    const c = (gx, gy) => hashToFixed(hashUint32((hash2(ix + gx, iy + gy) ^ hashUint32(seed)) >>> 0), scale);
+    const tx = math.smoothstep(0, scale, fx);
+    const ty = math.smoothstep(0, scale, fy);
+    const top = math.lerp(c(0, 0), c(1, 0), tx);
+    const bot = math.lerp(c(0, 1), c(1, 1), tx);
+    return math.lerp(top, bot, ty);
+}
+function fbm2D(math, xFixed, yFixed, seed, octaves) {
+    const scale = math.fixedScale;
+    let sum = 0;
+    let amp = scale;
+    let freq = scale;
+    let norm = 0;
+    for (let o = 0; o < octaves; o += 1) {
+        sum += math.mul(valueNoise2D(math, math.mul(xFixed, freq), math.mul(yFixed, freq), seed + o), amp);
+        norm += amp;
+        amp = Math.trunc(amp / 2);
+        freq = freq * 2;
+    }
+    return norm === 0 ? 0 : Math.trunc((sum * scale) / norm);
+}

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) {