@series-inc/rundot-syncplay 5.26.0-beta.2 → 5.26.0-beta.3

package/dist/browser.d.ts

@@ -27,6 +27,7 @@ export { fbm2D, hash2, hashUint32, valueNoise1D, valueNoise2D } from './noise.js
 export { circleCastDeterministicPhysics2D, createDeterministicPhysicsWorld2D, nearestDeterministicPhysicsHit2D, queryDeterministicPhysicsAabb2D, queryDeterministicPhysicsShapeOverlap2D, raycastAllDeterministicPhysics2D, raycastDeterministicPhysics2D, stepDeterministicPhysicsWorld2D } from './physics2d.js';
 export { applyDeterministicImpulse3D, applyDeterministicImpulses3D, applyDeterministicWorldEdit3D, contactDetailsDeterministicPhysics3D, createDeterministicPhysicsWorld3D, createTrustedDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D } from './physics3d.js';
 export { cookDeterministicVoxelChunkCollider3D } from './physics3d-voxel.js';
+export { cylinderHullVertices } from './physics3d-hull.js';
 export { createDeterministicCosmeticPhysicsWorld3D, setDeterministicCosmeticPhysicsAuthoritativeBodyProxies3D, stepDeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.js';
 export { stepDeterministicVehicle3D } from './physics3d-vehicle.js';
 export { createDeterministicR3fRenderAdapter as createDeterministicR3fAdapter, createDeterministicR3fRenderAdapter, interpolateDeterministicRenderNumber, interpolateDeterministicRenderVec2 } from './r3f-render-adapter.js';

package/dist/browser.js

@@ -28,6 +28,7 @@ export { fbm2D, hash2, hashUint32, valueNoise1D, valueNoise2D } from './noise.js
 export { circleCastDeterministicPhysics2D, createDeterministicPhysicsWorld2D, nearestDeterministicPhysicsHit2D, queryDeterministicPhysicsAabb2D, queryDeterministicPhysicsShapeOverlap2D, raycastAllDeterministicPhysics2D, raycastDeterministicPhysics2D, stepDeterministicPhysicsWorld2D } from './physics2d.js';
 export { applyDeterministicImpulse3D, applyDeterministicImpulses3D, applyDeterministicWorldEdit3D, contactDetailsDeterministicPhysics3D, createDeterministicPhysicsWorld3D, createTrustedDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D } from './physics3d.js';
 export { cookDeterministicVoxelChunkCollider3D } from './physics3d-voxel.js';
+export { cylinderHullVertices } from './physics3d-hull.js';
 export { createDeterministicCosmeticPhysicsWorld3D, setDeterministicCosmeticPhysicsAuthoritativeBodyProxies3D, stepDeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.js';
 export { stepDeterministicVehicle3D } from './physics3d-vehicle.js';
 export { createDeterministicR3fRenderAdapter as createDeterministicR3fAdapter, createDeterministicR3fRenderAdapter, interpolateDeterministicRenderNumber, interpolateDeterministicRenderVec2 } from './r3f-render-adapter.js';

package/dist/creator.d.ts

@@ -14,6 +14,7 @@ export type { SyncplaySession, SyncplaySessionPolicy } from './sdk-session.js';
 export type { InstantReplayInputFrame, InstantReplayResult, InstantReplayRunner, InstantReplayRunnerOptions, InstantReplayRunOptions, RunInstantReplayOptions, } from './instant-replay.js';
 export { applyDeterministicImpulse3D, applyDeterministicImpulses3D, applyDeterministicWorldEdit3D, contactDetailsDeterministicPhysics3D, createDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D, } from './physics3d.js';
 export { cookDeterministicVoxelChunkCollider3D } from './physics3d-voxel.js';
+export { cylinderHullVertices } from './physics3d-hull.js';
 export { stepDeterministicVehicle3D } from './physics3d-vehicle.js';
 export type { DeterministicContactCacheEntry3D, DeterministicJointCacheEntry3D, DeterministicPhysicsActivePair3D, DeterministicPhysicsAxisLock3D, DeterministicPhysicsBody3D, DeterministicPhysicsCallbackMask3D, DeterministicPhysicsCompoundChild3D, DeterministicPhysicsCompoundChildShape3D, DeterministicPhysicsConstraint3D, DeterministicPhysicsContactDetail3D, DeterministicPhysicsContactEvent3D, DeterministicPhysicsDetailedHit3D, DeterministicPhysicsHit3D, DeterministicPhysicsHullShape3D, DeterministicPhysicsImpulseApplication3D, DeterministicPhysicsOverlapQuery3D, DeterministicPhysicsPrimitiveShape3D, DeterministicPhysicsQuaternion3D, DeterministicPhysicsQueryOptions3D, DeterministicPhysicsRaycastQuery3D, DeterministicPhysicsScheduledQuery3D, DeterministicPhysicsShape3D, DeterministicPhysicsShapeCastQuery3D, DeterministicPhysicsStepResult3D, DeterministicPhysicsVec3, DeterministicPhysicsWorld3D, DeterministicPhysicsWorldEdit3D, } from './physics3d.js';
 export type { DeterministicVoxelChunk3D, DeterministicVoxelCompoundShape3D } from './physics3d-voxel.js';

package/dist/creator.js

@@ -11,4 +11,5 @@ export { runSyncplaySynctest } from './synctest.js';
 // stay off it — the first two are not requested, the third reads wall clock.
 export { applyDeterministicImpulse3D, applyDeterministicImpulses3D, applyDeterministicWorldEdit3D, contactDetailsDeterministicPhysics3D, createDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D, } from './physics3d.js';
 export { cookDeterministicVoxelChunkCollider3D } from './physics3d-voxel.js';
+export { cylinderHullVertices } from './physics3d-hull.js';
 export { stepDeterministicVehicle3D } from './physics3d-vehicle.js';

package/dist/index.d.ts

@@ -30,6 +30,7 @@ export { fbm2D, hash2, hashUint32, valueNoise1D, valueNoise2D } from './noise.js
 export { circleCastDeterministicPhysics2D, createDeterministicPhysicsWorld2D, nearestDeterministicPhysicsHit2D, queryDeterministicPhysicsAabb2D, queryDeterministicPhysicsShapeOverlap2D, raycastAllDeterministicPhysics2D, raycastDeterministicPhysics2D, stepDeterministicPhysicsWorld2D } from './physics2d.js';
 export { applyDeterministicImpulse3D, applyDeterministicImpulses3D, applyDeterministicWorldEdit3D, contactDetailsDeterministicPhysics3D, createDeterministicPhysicsWorld3D, createTrustedDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D } from './physics3d.js';
 export { cookDeterministicVoxelChunkCollider3D } from './physics3d-voxel.js';
+export { cylinderHullVertices } from './physics3d-hull.js';
 export { runDeterministicPhysics3DDestructionCert } from './physics3d-destruction-cert.js';
 export { createDeterministicCosmeticPhysicsWorld3D, setDeterministicCosmeticPhysicsAuthoritativeBodyProxies3D, stepDeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.js';
 export { runDeterministicKickRecovery3DScenario, runDeterministicMassRatio3DScenario, runDeterministicPyramid3DScenario, runDeterministicStackingSuite3D, runDeterministicTower3DScenario } from './physics3d-stacking.js';

package/dist/index.js

@@ -31,6 +31,7 @@ export { fbm2D, hash2, hashUint32, valueNoise1D, valueNoise2D } from './noise.js
 export { circleCastDeterministicPhysics2D, createDeterministicPhysicsWorld2D, nearestDeterministicPhysicsHit2D, queryDeterministicPhysicsAabb2D, queryDeterministicPhysicsShapeOverlap2D, raycastAllDeterministicPhysics2D, raycastDeterministicPhysics2D, stepDeterministicPhysicsWorld2D } from './physics2d.js';
 export { applyDeterministicImpulse3D, applyDeterministicImpulses3D, applyDeterministicWorldEdit3D, contactDetailsDeterministicPhysics3D, createDeterministicPhysicsWorld3D, createTrustedDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D } from './physics3d.js';
 export { cookDeterministicVoxelChunkCollider3D } from './physics3d-voxel.js';
+export { cylinderHullVertices } from './physics3d-hull.js';
 export { runDeterministicPhysics3DDestructionCert } from './physics3d-destruction-cert.js';
 export { createDeterministicCosmeticPhysicsWorld3D, setDeterministicCosmeticPhysicsAuthoritativeBodyProxies3D, stepDeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.js';
 export { runDeterministicKickRecovery3DScenario, runDeterministicMassRatio3DScenario, runDeterministicPyramid3DScenario, runDeterministicStackingSuite3D, runDeterministicTower3DScenario } from './physics3d-stacking.js';

package/dist/movement3d.d.ts

@@ -189,6 +189,15 @@ export declare function stepDeterministicKcc3D(body: DeterministicKccBody3D, inp
     readonly maxPushImpulse?: number;
     /** Enable standing on (and inheriting the velocity of) dynamic physics bodies. */
     readonly standOnDynamicBodies?: boolean;
+    /**
+     * Ground the capsule on STATIC physics bodies, including heightfields.
+     * Off by default: without it the physics world only blocks horizontally and
+     * vertical support comes from `world.slopes` / `steps` / platforms / `minY`,
+     * so a streaming-terrain game had to rebuild slope geometry to stand on the
+     * same terrain it already streams as colliders. Opt-in so shipped games keep
+     * bit-identical checksums.
+     */
+    readonly groundOnStaticBodies?: boolean;
 }): DeterministicKccStepResult3D;
 export interface DeterministicKccCarryState3D {
     readonly bodyId: string;

package/dist/movement3d.js

@@ -1,5 +1,6 @@
 import { defaultChecksum } from './canonical.js';
 import { createDeterministicPhysicsWorld3D, overlapDeterministicPhysics3D, } from './physics3d.js';
+import { heightfieldLocalSurfaceY } from './physics3d-heightfield.js';
 import { mulMat3Vec, quaternionFromQuarterTurns, quatMultiply, quatToMat3, rotatePointByQuat } from './physics3d-shared.js';
 export function stepDeterministicKcc3D(body, input, world, options) {
     let next = applyProcessors(body, input, options.frame, options.processors ?? []);
@@ -19,6 +20,7 @@ export function stepDeterministicKcc3D(body, input, world, options) {
     let z = next.z + vz;
     let grounded = false;
     let platformId = next.platformId;
+    let platformClaimedThisFrame = false;
     if (externalImpulse.applied) {
         events.push('external-impulse');
     }
@@ -36,6 +38,7 @@ export function stepDeterministicKcc3D(body, input, world, options) {
             vy = 0;
             grounded = true;
             platformId = platform.id;
+            platformClaimedThisFrame = true;
             events.push('moving-platform');
         }
     }
@@ -75,6 +78,58 @@ export function stepDeterministicKcc3D(body, input, world, options) {
         coyoteFrames = 0;
         events.push(next.grounded ? 'jump' : 'coyote-jump');
     }
+    const previousFeetY = next.y - kccFeetOffset(geometry);
+    let groundedOnStatic = false;
+    let groundedOnDynamic = false;
+    // Resolved before the dynamic path so the higher of the two wins: a crate
+    // standing on a floor must not lose its platform to the floor underneath it.
+    const staticGround = options.physics !== undefined && options.groundOnStaticBodies === true && vy <= 0
+        ? staticGroundUnderKcc(options.physics, x, y, z, previousFeetY, geometry, new Set(options.ignoredPhysicsBodyIds ?? []), world.stepHeight)
+        : undefined;
+    if (options.physics !== undefined && options.standOnDynamicBodies === true && vy <= 0) {
+        const ground = dynamicGroundUnderKcc(options.physics, x, y, z, geometry, new Set(options.ignoredPhysicsBodyIds ?? []));
+        if (ground !== undefined && (staticGround === undefined || ground.topY >= staticGround.topY)) {
+            groundedOnDynamic = true;
+            platformClaimedThisFrame = true;
+            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');
+            }
+        }
+    }
+    // Applied BEFORE the horizontal slide: the slide resolves overlap horizontally
+    // only, so a capsule that fell into terrain would be shoved sideways across
+    // the surface instead of being stood on top of it. Skipped when a dynamic
+    // body already claimed a higher surface this frame.
+    // platformId carries over from the previous frame, so a rider that simply
+    // walked off keeps pointing at a platform it has left. Clear it once nothing
+    // has claimed it this frame.
+    if (options.standOnDynamicBodies === true && !platformClaimedThisFrame) {
+        platformId = undefined;
+    }
+    // `grounded` here means an earlier source (moving platform, slope, step, or a
+    // dynamic body) already claimed a surface this frame; static only wins if it
+    // is higher. platformId cannot be used for this — it carries over from the
+    // previous frame, so stepping off a crate onto terrain would skip grounding.
+    if (staticGround !== undefined && (!grounded || staticGround.topY > y)) {
+        platformId = undefined;
+        y = staticGround.topY;
+        vy = 0;
+        grounded = true;
+        groundedOnStatic = true;
+        events.push('static-ground');
+    }
     // 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 };
@@ -90,32 +145,41 @@ export function stepDeterministicKcc3D(body, input, world, options) {
             vz = resolved.vz;
             correctionCount += resolved.correctionCount;
             events.push(resolved.swept ? 'physics-sweep' : resolved.slid ? 'physics-slide' : 'physics-correction');
+            // The slide moved the footprint, so the height sampled before it belongs
+            // to the old x/z. On sloped ground that stale height reads as penetration
+            // next frame and freezes movement along walls and ledges — re-sample.
+            // Attachment must follow the FINAL footprint. A slide can carry the
+            // capsule off the platform it was standing on (leaving it "grounded" in
+            // mid-air) or onto one it had missed.
+            if (groundedOnDynamic && (x !== pushCandidate.x || z !== pushCandidate.z)) {
+                const reattached = dynamicGroundUnderKcc(options.physics, x, y, z, geometry, new Set(options.ignoredPhysicsBodyIds ?? []));
+                if (reattached === undefined) {
+                    grounded = false;
+                    platformId = undefined;
+                    groundedOnDynamic = false;
+                }
+                else {
+                    y = reattached.topY;
+                    platformId = reattached.bodyId;
+                }
+            }
+            if (groundedOnStatic && (x !== pushCandidate.x || z !== pushCandidate.z)) {
+                const reground = staticGroundUnderKcc(options.physics, x, y, z, 
+                // The capsule has already landed, so this is a local correction from
+                // the landed feet — not the start-of-frame ones. Reusing those would
+                // reopen the fall-crossing window and let a slide under an overhang
+                // yank the capsule onto its roof.
+                y - kccFeetOffset(geometry), geometry, new Set(options.ignoredPhysicsBodyIds ?? []), world.stepHeight);
+                if (reground !== undefined) {
+                    y = reground.topY;
+                }
+            }
         }
     }
     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 ?? []));
@@ -123,7 +187,10 @@ export function stepDeterministicKcc3D(body, input, world, options) {
             events.push('push-dynamic');
         }
     }
-    const boundsCorrection = clampBodyToBounds({ x, y, z, vx, vy, vz, grounded, coyoteFrames, jumpBufferFrames, platformId }, world);
+    // Spread `next` first: the capsule's radius/halfHeight/skinWidth live on the
+    // body, and rebuilding it from a bare literal dropped them, so a caller's
+    // capsule silently reverted to the 1x2 default after a single step.
+    const boundsCorrection = clampBodyToBounds({ ...next, x, y, z, vx, vy, vz, grounded, coyoteFrames, jumpBufferFrames, platformId }, world);
     if (boundsCorrection.corrected) {
         correctionCount += boundsCorrection.corrections;
         events.push(...boundsCorrection.events);
@@ -247,7 +314,101 @@ function groundContactTopAt(body, x, z) {
         }
         return top;
     }
-    return undefined; // mesh: static-only, not a stand-on platform
+    if (shape.type === 'hull') {
+        // Not primitiveHalfExtent: that returns symmetric max(|y|) half-extents, so
+        // an asymmetric hull would snap the capsule above its real top and treat
+        // the mirrored side of the AABB as walkable. The stand-on height is max(y)
+        // of the rotated vertices, and the footprint is their true XZ range.
+        const m = quatToMat3(q);
+        let minX = Infinity;
+        let maxX = -Infinity;
+        let minZ = Infinity;
+        let maxZ = -Infinity;
+        let maxY = -Infinity;
+        for (const vertex of shape.vertices) {
+            const rotated = mulMat3Vec(m, vertex);
+            minX = Math.min(minX, rotated.x);
+            maxX = Math.max(maxX, rotated.x);
+            minZ = Math.min(minZ, rotated.z);
+            maxZ = Math.max(maxZ, rotated.z);
+            maxY = Math.max(maxY, rotated.y);
+        }
+        const localX = x - body.x;
+        const localZ = z - body.z;
+        if (localX < minX || localX > maxX || localZ < minZ || localZ > maxZ) {
+            return undefined;
+        }
+        return body.y + maxY;
+    }
+    if (shape.type === 'heightfield') {
+        // Heightfields are static and never rotate (the solver maps them to a mesh
+        // in body-local space), so local == world minus the body position.
+        const localY = heightfieldLocalSurfaceY(shape, x - body.x, z - body.z);
+        return localY === undefined ? undefined : body.y + localY;
+    }
+    return undefined; // mesh: arbitrary triangle soup, not a stand-on platform
+}
+/**
+ * Highest static surface under the capsule within `snapDistance` of its feet.
+ *
+ * The overlap probe only narrows candidates (it rides the world's static query
+ * tree); the surface height itself comes from groundContactTopAt, so a capsule
+ * lands on the same triangle a projectile would hit.
+ */
+/**
+ * Separation held between a grounded capsule and the surface under it, so
+ * resting contact never reads as penetration. Fixed rather than derived because
+ * skinWidth defaults to 0; a plain double is bit-identical on every peer.
+ */
+const KCC_GROUND_CLEARANCE = 1e-4;
+/**
+ * Distance from the capsule's centre to the bottom of its collision shape.
+ * A capsule's vertical extent is halfHeight + radius (see primitiveHalfExtent),
+ * so grounding on `halfHeight` alone buries it by a radius and the horizontal
+ * slide then fights the penetration every frame — the capsule cannot walk.
+ * skinWidth keeps a gap so resting contact is not treated as overlap.
+ */
+function kccFeetOffset(geometry) {
+    // physicsOverlapsKcc probes with radius+skinWidth AND halfHeight+skinWidth,
+    // and counts exact touching as an overlap — at which point the slide reverts
+    // the whole horizontal move, so a capsule resting flush on terrain cannot
+    // walk. Rest one clearance above that probe instead of on the surface.
+    return geometry.halfHeight + geometry.radius + 2 * geometry.skinWidth + KCC_GROUND_CLEARANCE;
+}
+function staticGroundUnderKcc(physics, x, y, z, previousFeetY, geometry, ignoredBodyIds, snapDistance) {
+    const feetY = y - kccFeetOffset(geometry);
+    // Gravity is unbounded (vy -= 1 per frame), so a fast fall can clear the whole
+    // snap band in one step. Accept a surface the feet CROSSED this frame, not
+    // just one they ended near — otherwise terrain tunnels at terminal velocity.
+    // Requiring the frame to START at or above the surface is what keeps a capsule
+    // walking beneath a floating static box from being yanked onto its roof.
+    const fallDistance = Math.max(0, previousFeetY - feetY);
+    const reach = snapDistance + fallDistance;
+    const probe = {
+        shape: { type: 'sphere', radius: geometry.radius + reach },
+        x,
+        y: feetY,
+        z,
+        hitStatics: true,
+        hitDynamics: false,
+        hitKinematics: false,
+    };
+    const hitIds = new Set(overlapDeterministicPhysics3D(physics, probe));
+    const grounds = physics.bodies
+        .filter((body) => body.kind === 'static' && hitIds.has(body.id) && !ignoredBodyIds.has(body.id))
+        .map((body) => ({ body, top: groundContactTopAt(body, x, z) }))
+        .filter((candidate) => candidate.top !== undefined
+        && feetY <= candidate.top + snapDistance
+        && previousFeetY >= candidate.top - snapDistance)
+        .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 + kccFeetOffset(geometry),
+    };
 }
 /** World half-extents (x,y,z) of a primitive shape under rotation matrix `m`. */
 function primitiveHalfExtent(shape, m) {
@@ -283,7 +444,7 @@ function primitiveHalfExtent(shape, m) {
 }
 /** 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 feetY = y - kccFeetOffset(geometry);
     const probe = {
         shape: { type: 'sphere', radius: geometry.radius },
         x,
@@ -308,7 +469,7 @@ function dynamicGroundUnderKcc(physics, x, y, z, geometry, ignoredBodyIds) {
     }
     return {
         bodyId: ground.body.id,
-        topY: ground.top + geometry.halfHeight + geometry.skinWidth,
+        topY: ground.top + kccFeetOffset(geometry),
         deltaX: ground.body.vx,
         deltaZ: ground.body.vz,
     };

package/dist/physics3d-heightfield.d.ts

@@ -14,4 +14,14 @@ export interface HeightfieldBounds3D {
     readonly maxZ: number;
 }
 export declare function heightfieldLocalBounds(shape: HeightfieldShapeData3D): HeightfieldBounds3D;
+/**
+ * Local surface height at a local (x, z), or undefined outside the field.
+ *
+ * MUST stay consistent with heightfieldLocalTriangles' cell split: a cell emits
+ * [a,b,c] and [d,c,b] with a=(col,row) b=(col,row+1) c=(col+1,row)
+ * d=(col+1,row+1), so the diagonal runs b–c and the first triangle is the
+ * u+v<=1 half. Sampling a different diagonal would let a character stand where
+ * a projectile passes through.
+ */
+export declare function heightfieldLocalSurfaceY(shape: HeightfieldShapeData3D, localX: number, localZ: number): number | undefined;
 export declare function heightfieldLocalTriangles(shape: HeightfieldShapeData3D, bounds?: HeightfieldBounds3D): readonly (readonly [Point3D, Point3D, Point3D])[];

package/dist/physics3d-heightfield.js

@@ -21,6 +21,39 @@ function vertex(shape, column, row) {
         z: row * shape.scale.z,
     };
 }
+function heightAt(shape, column, row) {
+    return shape.heights[row * shape.columns + column] * shape.scale.y;
+}
+/**
+ * Local surface height at a local (x, z), or undefined outside the field.
+ *
+ * MUST stay consistent with heightfieldLocalTriangles' cell split: a cell emits
+ * [a,b,c] and [d,c,b] with a=(col,row) b=(col,row+1) c=(col+1,row)
+ * d=(col+1,row+1), so the diagonal runs b–c and the first triangle is the
+ * u+v<=1 half. Sampling a different diagonal would let a character stand where
+ * a projectile passes through.
+ */
+export function heightfieldLocalSurfaceY(shape, localX, localZ) {
+    const maxX = (shape.columns - 1) * shape.scale.x;
+    const maxZ = (shape.rows - 1) * shape.scale.z;
+    if (localX < 0 || localX > maxX || localZ < 0 || localZ > maxZ) {
+        return undefined;
+    }
+    const columnFloat = localX / shape.scale.x;
+    const rowFloat = localZ / shape.scale.z;
+    const column = Math.min(shape.columns - 2, Math.floor(columnFloat));
+    const row = Math.min(shape.rows - 2, Math.floor(rowFloat));
+    const u = columnFloat - column;
+    const v = rowFloat - row;
+    const a = heightAt(shape, column, row);
+    const b = heightAt(shape, column, row + 1);
+    const c = heightAt(shape, column + 1, row);
+    if (u + v <= 1) {
+        return a + (b - a) * v + (c - a) * u;
+    }
+    const d = heightAt(shape, column + 1, row + 1);
+    return d + (c - d) * (1 - v) + (b - d) * (1 - u);
+}
 export function heightfieldLocalTriangles(shape, bounds) {
     const minColumn = bounds === undefined ? 0 : Math.max(0, Math.floor(bounds.minX / shape.scale.x));
     const maxColumn = bounds === undefined

package/dist/physics3d-hull.d.ts

@@ -51,3 +51,17 @@ export declare function closestPointOnHullLocal(point: Point3D, hull: SolverHull
     readonly normal: Point3D;
     readonly distance: number;
 };
+/**
+ * Vertices for a cylinder approximated as a regular prism, for trunks, stumps,
+ * logs, pillars and barrels.
+ *
+ * There is no cylinder primitive in Kinetix, the TypeScript solver, or the
+ * Box3D parity set — a cylinder is a convex hull, and hulls are at parity. The
+ * TypeScript hull builder accepts 4-16 vertices, so `sides` tops out at 8 (an
+ * octagonal prism, exactly 16). A capsule is cheaper but its rounded caps let a
+ * character slide off a flat top and change how a body rolls off an edge.
+ *
+ * Call this when building the world, not inside the step: the vertices are
+ * constant for a given (radius, halfHeight, sides).
+ */
+export declare function cylinderHullVertices(radius: number, halfHeight: number, sides?: number): readonly Point3D[];

package/dist/physics3d-hull.js

@@ -10,6 +10,7 @@
  * Numeric regime: add/mul/cmp plus `solverSqrt` for the final unit normals only.
  * No transcendentals (banned in src/ by the static determinism checker).
  */
+import { createDeterministicMath } from './math.js';
 import { addVec3, crossVec3, dotVec3, scaleVec3, solverSqrt, subVec3, } from './physics3d-shared.js';
 const PLANE_TOL = 1e-9;
 const COPLANAR_TOL = 1e-6;
@@ -374,3 +375,47 @@ function closestPointOnSegmentLocal(point, a, b) {
     t = t < 0 ? 0 : t > 1 ? 1 : t;
     return addVec3(a, scaleVec3(ab, t));
 }
+/**
+ * Native Math.cos/Math.sin are not bit-identical across JS engines, and these
+ * vertices become checksummed collision geometry — two peers building the same
+ * trunk must agree exactly. sinTurns/cosTurns are pure integer arithmetic.
+ * 840 is divisible by every allowed side count, so each vertex lands on an
+ * exact turn boundary.
+ */
+const PRISM_TURN_SCALE = 840_000;
+const prismMath = createDeterministicMath(PRISM_TURN_SCALE);
+/**
+ * Vertices for a cylinder approximated as a regular prism, for trunks, stumps,
+ * logs, pillars and barrels.
+ *
+ * There is no cylinder primitive in Kinetix, the TypeScript solver, or the
+ * Box3D parity set — a cylinder is a convex hull, and hulls are at parity. The
+ * TypeScript hull builder accepts 4-16 vertices, so `sides` tops out at 8 (an
+ * octagonal prism, exactly 16). A capsule is cheaper but its rounded caps let a
+ * character slide off a flat top and change how a body rolls off an edge.
+ *
+ * Call this when building the world, not inside the step: the vertices are
+ * constant for a given (radius, halfHeight, sides).
+ */
+export function cylinderHullVertices(radius, halfHeight, sides = 8) {
+    if (!Number.isFinite(radius) || radius <= 0) {
+        throw new Error(`cylinder hull radius must be a finite positive number, received ${radius}`);
+    }
+    if (!Number.isFinite(halfHeight) || halfHeight <= 0) {
+        throw new Error(`cylinder hull halfHeight must be a finite positive number, received ${halfHeight}`);
+    }
+    if (!Number.isInteger(sides) || sides < 3 || sides > 8) {
+        throw new Error(`cylinder hull sides must be an integer in 3..8 (2 x sides must fit the 4-16 vertex hull limit), received ${sides}`);
+    }
+    const vertices = [];
+    for (let index = 0; index < sides; index += 1) {
+        // Turns, not radians: PRISM_TURN_SCALE is divisible by every allowed side
+        // count, so this is an exact integer and never rounds.
+        const turns = (PRISM_TURN_SCALE * index) / sides;
+        const x = (radius * prismMath.cosTurns(turns)) / PRISM_TURN_SCALE;
+        const z = (radius * prismMath.sinTurns(turns)) / PRISM_TURN_SCALE;
+        vertices.push({ x, y: halfHeight, z });
+        vertices.push({ x, y: -halfHeight, z });
+    }
+    return vertices;
+}

package/dist/physics3d.js

@@ -2080,6 +2080,33 @@ function warmMapToCache(warm, bodies) {
         || left.anchorY - right.anchorY
         || left.anchorZ - right.anchorZ);
 }
+/**
+ * Exact-overlap memo for static/static pairs. Neither body can move, so the
+ * result is invariant for the lifetime of both objects, and static bodies keep
+ * their identity across steps (see the `kind === 'static'` passthrough in the
+ * solver's body rebuild). Without this, every prop resting on a heightfield
+ * regenerates the terrain's triangles on every step to re-derive an answer that
+ * cannot change.
+ */
+// rdm-ignore-next-line determinism/no-mutable-collection-state: pure derived overlap memo keyed by immutable body identity
+const staticOverlapCache = new WeakMap();
+function shapesOverlapForPair(left, right) {
+    if (left.kind !== 'static' || right.kind !== 'static') {
+        return shapesOverlap3D(bodyPose(left), bodyPose(right));
+    }
+    let memo = staticOverlapCache.get(left);
+    if (memo === undefined) {
+        memo = new WeakMap();
+        staticOverlapCache.set(left, memo);
+    }
+    const cached = memo.get(right);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const overlap = shapesOverlap3D(bodyPose(left), bodyPose(right));
+    memo.set(right, overlap);
+    return overlap;
+}
 function detectContacts(bodies, keepPair) {
     const contacts = [];
     for (const pair of broadphaseCandidatePairs(bodies)) {
@@ -2091,7 +2118,7 @@ function detectContacts(bodies, keepPair) {
         if ((left.mask & right.layer) === 0 ||
             (right.mask & left.layer) === 0 ||
             !boundsOverlap(pair.leftBounds, pair.rightBounds) ||
-            !shapesOverlap3D(bodyPose(left), bodyPose(right))) {
+            !shapesOverlapForPair(left, right)) {
             continue;
         }
         const pairId = [left.id, right.id].sort(compareStrings).join('|');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@series-inc/rundot-syncplay",
-  "version": "5.26.0-beta.2",
+  "version": "5.26.0-beta.3",
   "description": "Kinetix orchestration, rollback, replay, late-join, and deterministic networking for RUN.game",
   "repository": {
     "type": "git",
@@ -70,7 +70,9 @@
       "types": "./core/physics.d.ts",
       "default": "./core/src/physics/index.mjs"
     },
+    "./core/box3d-probe": "./core/src/physics/box3d-probe.mjs",
     "./core/build-native": "./core/scripts/build-native.mjs",
+    "./core/build-mobile-native": "./core/scripts/build-mobile-native.mjs",
     "./core/build-wasm-physics": "./core/scripts/build-wasm-physics.mjs",
     "./core/preflight": "./core/scripts/preflight.mjs"
   },
@@ -88,17 +90,19 @@
   "scripts": {
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
     "test": "npm run test:core",
-    "test:core": "tsx --test tests/canonical.test.ts tests/runtime-session.test.ts tests/kinetix-runtime-session.test.ts tests/runtime-support.test.ts tests/runtime-guards.test.ts tests/r3f-render-adapter.test.ts tests/snapshot-cost.test.ts tests/sdkSession.test.ts tests/input-authority.test.ts tests/session-wire.test.ts tests/session-snapshot.test.ts tests/authority-room.test.ts tests/networked-client-snapshot.test.ts tests/runner.test.ts tests/testing.test.ts tests/browser-session.test.ts tests/secret-config.test.ts tests/secret-protocol.test.ts tests/secret-authority.test.ts tests/secret-client.test.ts tests/late-join-checksum.test.ts tests/late-join-input-backfill.test.ts tests/replay-scoring.test.ts tests/bot-backfill.test.ts tests/latency-simulation.test.ts tests/time-sync.test.ts tests/match-log.test.ts tests/spectator.test.ts tests/synctest.test.ts tests/instant-replay.test.ts tests/session-promotion.test.ts tests/physics3d-broadphase-stats.test.ts tests/entrypoints.test.ts tests/export-surface.test.ts tests/test-manifest.test.ts tests/coarse-region.test.ts tests/input-codec.test.ts tests/platformer-content.test.ts tests/command-ingress.test.ts tests/session-reconfigure.test.ts tests/prediction-mode.test.ts tests/ephemeral-channel.test.ts tests/runner-surface.test.ts tests/runner-harness.test.ts tests/effects-adapter-bounds.test.ts tests/simulated-match-secrets.test.ts tests/run-glue-surface.test.mjs core/tests/core-boundary.test.mjs tests/math-core-parity.test.ts",
+    "test:core": "tsx --test tests/canonical.test.ts tests/runtime-session.test.ts tests/kinetix-runtime-session.test.ts tests/runtime-support.test.ts tests/runtime-guards.test.ts tests/r3f-render-adapter.test.ts tests/snapshot-cost.test.ts tests/sdkSession.test.ts tests/input-authority.test.ts tests/session-wire.test.ts tests/session-snapshot.test.ts tests/authority-room.test.ts tests/networked-client-snapshot.test.ts tests/runner.test.ts tests/testing.test.ts tests/browser-session.test.ts tests/secret-config.test.ts tests/secret-protocol.test.ts tests/secret-authority.test.ts tests/secret-client.test.ts tests/late-join-checksum.test.ts tests/late-join-input-backfill.test.ts tests/replay-scoring.test.ts tests/bot-backfill.test.ts tests/latency-simulation.test.ts tests/time-sync.test.ts tests/match-log.test.ts tests/spectator.test.ts tests/synctest.test.ts tests/instant-replay.test.ts tests/session-promotion.test.ts tests/physics3d-broadphase-stats.test.ts tests/entrypoints.test.ts tests/export-surface.test.ts tests/test-manifest.test.ts tests/coarse-region.test.ts tests/input-codec.test.ts tests/platformer-content.test.ts tests/command-ingress.test.ts tests/session-reconfigure.test.ts tests/prediction-mode.test.ts tests/ephemeral-channel.test.ts tests/runner-surface.test.ts tests/runner-harness.test.ts tests/effects-adapter-bounds.test.ts tests/simulated-match-secrets.test.ts tests/run-glue-surface.test.mjs core/tests/core-boundary.test.mjs tests/math-core-parity.test.ts tests/movement3d-kcc-unit-contract.test.ts tests/movement3d-static-ground.test.ts",
     "test:soak": "tsx --test tests/runtime-soak.test.ts",
-    "test:extended": "tsx --test tests/animation.test.ts tests/asset-cooking.test.ts tests/backend-proof-checksum-vectors.test.ts tests/bot-documents.test.ts tests/bot-primitives.test.ts tests/collider-cooking.test.ts tests/collision.test.ts tests/command-timeline.test.ts tests/config-bundle.test.ts tests/cosmetic-physics3d.test.ts tests/deterministic-primitives.test.ts tests/ecs-lite.test.ts tests/effects-adapter.test.ts tests/engine-runtime.test.ts tests/errors.test.ts tests/events.test.ts tests/input-button.test.ts tests/load-128-players.test.ts tests/math.test.ts tests/movement.test.ts tests/movement3d.test.ts tests/multiclient-authority.test.ts tests/navigation.test.ts tests/noise.test.ts tests/physics-cert.test.ts tests/physics2d.test.ts tests/physics3d-ccd.test.ts tests/physics3d-coverage.test.ts tests/physics3d-destruction-cert.test.ts tests/physics3d-heightfield.test.ts tests/physics3d-hull.test.ts tests/physics3d-joints.test.ts tests/physics3d-kinematic-mesh.test.ts tests/physics3d-mass.test.ts tests/physics3d-materials.test.ts tests/physics3d-mesh-onesided.test.ts tests/physics3d-query-index.test.ts tests/physics3d-recipes.test.ts tests/physics3d-rotation-convention.test.ts tests/physics3d-shared.test.ts tests/physics3d-sleeping-manifold-reuse.test.ts tests/physics3d-solver.test.ts tests/physics3d-stacking.test.ts tests/physics3d-toi.test.ts tests/physics3d-vehicle.test.ts tests/physics3d-voxel.test.ts tests/physics3d-world-edit.test.ts tests/physics3d.test.ts tests/physics-vector-generator.test.ts tests/random.test.ts tests/rollback-history.test.ts tests/schema-artifacts.test.ts tests/schema-codegen.test.ts tests/schema-dsl-binary.test.ts tests/schema.test.ts tests/signals.test.ts tests/sparse-set.test.ts tests/static-checker.test.ts tests/system-lifecycle.test.ts tests/wire-canonical-sentinels.test.ts tests/ws-frame.test.ts",
+    "test:extended": "tsx --test tests/kcc-vehicle-characterization.test.ts tests/animation.test.ts tests/asset-cooking.test.ts tests/backend-proof-checksum-vectors.test.ts tests/bot-documents.test.ts tests/bot-primitives.test.ts tests/collider-cooking.test.ts tests/collision.test.ts tests/command-timeline.test.ts tests/config-bundle.test.ts tests/cosmetic-physics3d.test.ts tests/deterministic-primitives.test.ts tests/ecs-lite.test.ts tests/effects-adapter.test.ts tests/engine-runtime.test.ts tests/errors.test.ts tests/events.test.ts tests/input-button.test.ts tests/load-128-players.test.ts tests/math.test.ts tests/movement.test.ts tests/movement3d.test.ts tests/multiclient-authority.test.ts tests/navigation.test.ts tests/noise.test.ts tests/physics-cert.test.ts tests/physics2d.test.ts tests/physics3d-ccd.test.ts tests/physics3d-coverage.test.ts tests/physics3d-destruction-cert.test.ts tests/physics3d-geometry-limits.test.ts tests/physics3d-heightfield.test.ts tests/physics3d-hull.test.ts tests/physics3d-joints.test.ts tests/physics3d-kinematic-mesh.test.ts tests/physics3d-mass.test.ts tests/physics3d-materials.test.ts tests/physics3d-mesh-onesided.test.ts tests/physics3d-query-index.test.ts tests/physics3d-recipes.test.ts tests/physics3d-rotation-convention.test.ts tests/physics3d-shared.test.ts tests/physics3d-sleeping-manifold-reuse.test.ts tests/physics3d-solver.test.ts tests/physics3d-static-memoization.test.ts tests/physics3d-static-overlap-memo.test.ts tests/physics3d-cylinder-hull.test.ts tests/physics3d-stacking.test.ts tests/physics3d-toi.test.ts tests/physics3d-vehicle.test.ts tests/physics3d-voxel.test.ts tests/physics3d-world-edit.test.ts tests/physics3d.test.ts tests/physics-vector-generator.test.ts tests/random.test.ts tests/rollback-history.test.ts tests/schema-artifacts.test.ts tests/schema-codegen.test.ts tests/schema-dsl-binary.test.ts tests/schema.test.ts tests/signals.test.ts tests/sparse-set.test.ts tests/static-checker.test.ts tests/system-lifecycle.test.ts tests/wire-canonical-sentinels.test.ts tests/ws-frame.test.ts",
     "test:ci": "npm run build && npm run test:core",
     "build:native": "node core/scripts/build-native.mjs",
+    "build:mobile-native": "node core/scripts/build-mobile-native.mjs",
     "build:wasm-physics": "node core/scripts/build-wasm-physics.mjs",
     "test:determinism": "node --test core/tests/*.test.mjs",
     "generate:platformer-manifest": "node core/scripts/generate-platformer2d-manifest.mjs",
     "generate:physics-vectors": "node scripts/gen-physics-vectors.mjs",
     "test:physics-vectors": "node --import tsx/esm --test tests/physics-vector-generator.test.ts",
-    "pack:dry-run": "npm pack --dry-run"
+    "pack:dry-run": "npm pack --dry-run",
+    "bench:cross-lane": "node core/bench/cross-lane.mjs"
   },
   "license": "SEE LICENSE IN LICENSE.md",
   "keywords": [

package/dist/prediction-culling.d.ts

@@ -1,34 +0,0 @@
-export type PredictionCullingMode = 'off' | 'local-area';
-export interface PredictionCullingOptions {
-    readonly mode: PredictionCullingMode;
-    readonly players: number;
-    readonly objectsPerPlayer: number;
-    readonly frames: number;
-    readonly seed: number;
-    readonly radius: number;
-    readonly includeHiddenThreat?: boolean;
-}
-export interface PredictionCullingResult {
-    readonly mode: PredictionCullingMode;
-    readonly players: number;
-    readonly objects: number;
-    readonly frames: number;
-    readonly seed: number;
-    readonly radius: number;
-    readonly averagePredictedObjects: string;
-    readonly minPredictedObjects: number;
-    readonly maxPredictedObjects: number;
-    readonly visibleCorrections: number;
-    readonly hiddenAuthoritativeInteractions: number;
-    readonly predictedObjectSteps: number;
-    readonly verifiedObjectSteps: number;
-    readonly culledObjectSteps: number;
-    readonly restoreFrame: number;
-    readonly predictedChecksum: string;
-    readonly verifiedChecksum: string;
-    readonly resimulatedChecksum: string;
-    readonly predictionFilterChecksum: string;
-    readonly completeChecksum: string;
-    readonly result: 'pass' | 'fail';
-}
-export declare function runPredictionCullingLab(options: PredictionCullingOptions): PredictionCullingResult;