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

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';
@@ -60,7 +61,7 @@ export type { DeterministicAuthoritativeLagCompensation3DShotContext, Determinis
 export type { DeterministicLocalAuthoritySnapshotIdentity, DeterministicLocalAuthoritySnapshotTransfer, DeterministicLocalAuthorityWireEnvelope, DeterministicLocalAuthorityWireKind } from './local-authority-wire.js';
 export type { DeterministicFixedQuaternion, DeterministicFixedVec2, DeterministicFixedVec3, DeterministicMath } from './math.js';
 export type { DeterministicFpsAimState, DeterministicFpsInput, DeterministicKccBody, DeterministicKccInput, DeterministicKccStepResult, DeterministicLagCompensatedHitValidation, DeterministicLagCompensatedShot, DeterministicMovementCrowdMetrics, DeterministicMovementSimulationMetrics, DeterministicMovementStep, DeterministicMovementWorld, DeterministicMovingPlatform, DeterministicOneWayPlatform, DeterministicSlope, DeterministicTargetSnapshot, DeterministicTopDownBody, DeterministicTopDownBounds, DeterministicTopDownInput } from './movement.js';
-export type { DeterministicKccBody3D, DeterministicKccCarrierPose3D, DeterministicKccCarryResult3D, DeterministicKccCarryState3D, DeterministicKccCollisionCandidate3D, DeterministicKccCollisionFilter3D, DeterministicKccExternalImpulse3D, DeterministicKccGeometry3D, DeterministicKccInput3D, DeterministicKccPhysicsImpulse3D, DeterministicKccProcessor3D, DeterministicKccStepResult3D, DeterministicKccWorld3D, DeterministicMovingPlatform3D, DeterministicSlope3D, DeterministicStep3D } from './movement3d.js';
+export type { DeterministicKccBody3D, DeterministicKccCarrierPose3D, DeterministicKccCarryResult3D, DeterministicKccCarryState3D, DeterministicKccCollisionCandidate3D, DeterministicKccCollisionFilter3D, DeterministicKccExternalImpulse3D, DeterministicKccGeometry3D, DeterministicKccInput3D, DeterministicKccJumpTuning3D, DeterministicKccPhysicsImpulse3D, DeterministicKccProcessor3D, DeterministicKccStepResult3D, DeterministicKccWorld3D, DeterministicMovingPlatform3D, DeterministicSlope3D, DeterministicStep3D } from './movement3d.js';
 export type { CookedDeterministicNavigationGraph, DeterministicFlowField, DeterministicNavEdge, DeterministicNavigationAgent, DeterministicNavigationGraphSource, DeterministicNavigationStepOptions, DeterministicNavigationStepResult, DeterministicNavNode, DeterministicNavRegion, DeterministicPathQuery, DeterministicPathResult, DeterministicTilemapSource } from './navigation.js';
 export type { CookedDeterministicNavmesh, DeterministicNavmeshAgent, DeterministicNavmeshAgentStepResult, DeterministicNavmeshImportSource, DeterministicNavmeshLink, DeterministicNavmeshMovingAvoidanceObstacle, DeterministicNavmeshOffMeshTraversalState, DeterministicNavmeshOffMeshTraversalStep, DeterministicNavmeshPath, DeterministicNavmeshPoint, DeterministicNavmeshPolygon, DeterministicNavmeshSource } from './navmesh.js';
 export type { ConfirmedSyncplayPresentationFrame, KinetixRuntimeFactory, NetworkedClientTransport, NetworkedSyncplayClient, NetworkedSyncplayClientInputDelayOptions, NetworkedSyncplayClientNetStats, NetworkedSyncplayClientOptions, NetworkedSyncplayClientPacingOptions, NetworkedSyncplayPreparationOptions, NetworkedSyncplaySessionDescriptor, NetworkedSyncplaySlotPresence, PreparedNetworkedSyncplayTransport, SyncplayPredictionMode } from './networked-client.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';
@@ -72,7 +73,7 @@ export type { DeterministicAuthoritativeLagCompensation3DShotContext, Determinis
 export type { DeterministicLocalAuthoritySnapshotIdentity, DeterministicLocalAuthoritySnapshotTransfer, DeterministicLocalAuthorityWireEnvelope, DeterministicLocalAuthorityWireKind } from './local-authority-wire.js';
 export type { DeterministicFixedQuaternion, DeterministicFixedVec2, DeterministicFixedVec3, DeterministicMath } from './math.js';
 export type { DeterministicFpsAimState, DeterministicFpsInput, DeterministicKccBody, DeterministicKccInput, DeterministicKccStepResult, DeterministicMovementCrowdMetrics, DeterministicMovementSimulationMetrics, DeterministicMovementStep, DeterministicMovementWorld, DeterministicMovingPlatform, DeterministicOneWayPlatform, DeterministicSlope, DeterministicTargetSnapshot, DeterministicTopDownBody, DeterministicTopDownBounds, DeterministicTopDownInput } from './movement.js';
-export type { DeterministicKccBody3D, DeterministicKccCarrierPose3D, DeterministicKccCarryResult3D, DeterministicKccCarryState3D, DeterministicKccCollisionCandidate3D, DeterministicKccCollisionFilter3D, DeterministicKccExternalImpulse3D, DeterministicKccGeometry3D, DeterministicKccInput3D, DeterministicKccPhysicsImpulse3D, DeterministicKccProcessor3D, DeterministicKccStepResult3D, DeterministicKccWorld3D, DeterministicMovingPlatform3D, DeterministicSlope3D, DeterministicStep3D } from './movement3d.js';
+export type { DeterministicKccBody3D, DeterministicKccCarrierPose3D, DeterministicKccCarryResult3D, DeterministicKccCarryState3D, DeterministicKccCollisionCandidate3D, DeterministicKccCollisionFilter3D, DeterministicKccExternalImpulse3D, DeterministicKccGeometry3D, DeterministicKccInput3D, DeterministicKccJumpTuning3D, DeterministicKccPhysicsImpulse3D, DeterministicKccProcessor3D, DeterministicKccStepResult3D, DeterministicKccWorld3D, DeterministicMovingPlatform3D, DeterministicSlope3D, DeterministicStep3D } from './movement3d.js';
 export type { CookedDeterministicNavigationGraph, DeterministicFlowField, DeterministicNavEdge, DeterministicNavigationAgent, DeterministicNavigationGraphSource, DeterministicNavigationStepOptions, DeterministicNavigationStepResult, DeterministicNavNode, DeterministicNavRegion, DeterministicPathQuery, DeterministicPathResult, DeterministicTilemapSource } from './navigation.js';
 export type { CookedDeterministicNavmesh, DeterministicNavmeshAgent, DeterministicNavmeshAgentStepResult, DeterministicNavmeshImportSource, DeterministicNavmeshLink, DeterministicNavmeshMovingAvoidanceObstacle, DeterministicNavmeshOffMeshTraversalState, DeterministicNavmeshOffMeshTraversalStep, DeterministicNavmeshPath, DeterministicNavmeshPoint, DeterministicNavmeshPolygon, DeterministicNavmeshSource } from './navmesh.js';
 export type { ConfirmedSyncplayPresentationFrame, KinetixRuntimeFactory, NetworkedClientTransport, NetworkedSyncplayClient, NetworkedSyncplayClientInputDelayOptions, NetworkedSyncplayClientNetStats, NetworkedSyncplayClientOptions, NetworkedSyncplayClientPacingOptions, NetworkedSyncplayPreparationOptions, NetworkedSyncplaySessionDescriptor, PreparedNetworkedSyncplayTransport, SyncplayPredictionMode } from './networked-client.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

@@ -24,6 +24,20 @@ export interface DeterministicKccInput3D {
     readonly moveZ: number;
     readonly jumpPressed?: boolean;
 }
+export interface DeterministicKccJumpTuning3D {
+    /** Upward velocity the jump sets, in units per frame. Default 10. */
+    readonly impulse?: number;
+    /**
+     * Immediate lift applied on the jump frame to unstick the capsule from the
+     * ground it is resting on. Defaults to `impulse / 10`, which keeps the
+     * historical 1-unit lift at the default impulse and scales with a retune.
+     */
+    readonly liftOff?: number;
+    /** Frames a jump stays available after leaving the ground. Default 4. */
+    readonly coyoteFrames?: number;
+    /** Frames an early jump press is held for. Minimum 1, default 4. */
+    readonly bufferFrames?: number;
+}
 export interface DeterministicKccExternalImpulse3D {
     readonly id: string;
     readonly vx: number;
@@ -189,6 +203,23 @@ 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;
+    /**
+     * Jump tuning, in the KCC's frame units. Gravity retunes through a processor
+     * because processors run before `vy -= 1`, but the jump impulse is applied
+     * AFTER them, so it cannot be scaled the same way — without these a game that
+     * retunes gravity must own jump, coyote and buffer itself. Every default
+     * reproduces the previous hardcoded behaviour bit-for-bit.
+     */
+    readonly jump?: DeterministicKccJumpTuning3D;
 }): DeterministicKccStepResult3D;
 export interface DeterministicKccCarryState3D {
     readonly bodyId: string;

package/dist/movement3d.js

@@ -1,7 +1,39 @@
 import { defaultChecksum } from './canonical.js';
 import { createDeterministicPhysicsWorld3D, overlapDeterministicPhysics3D, } from './physics3d.js';
-import { mulMat3Vec, quaternionFromQuarterTurns, quatMultiply, quatToMat3, rotatePointByQuat } from './physics3d-shared.js';
+import { heightfieldLocalSurfaceY } from './physics3d-heightfield.js';
+import { mulMat3Vec, quaternionFromQuarterTurns, quatMultiply, quatToMat3, rotatePointByQuat, solverSqrt } from './physics3d-shared.js';
+function normalizeKccJumpTuning3D(tuning) {
+    const impulse = finiteKccJumpNumber(tuning?.impulse, 10, 'impulse');
+    return {
+        impulse,
+        liftOff: finiteKccJumpNumber(tuning?.liftOff, impulse / 10, 'liftOff'),
+        coyoteFrames: kccJumpFrameCount(tuning?.coyoteFrames, 'coyoteFrames', 0),
+        // A press arms the jump by writing this into jumpBufferFrames and the gate
+        // needs it > 0, so 0 would not mean "no buffering" — it would mean "never
+        // jump". 1 is the real floor: the press lives for the frame it happened on.
+        bufferFrames: kccJumpFrameCount(tuning?.bufferFrames, 'bufferFrames', 1),
+    };
+}
+function finiteKccJumpNumber(value, fallback, field) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (!Number.isFinite(value)) {
+        throw new Error(`KCC jump.${field} must be a finite number`);
+    }
+    return value;
+}
+function kccJumpFrameCount(value, field, minimum) {
+    if (value === undefined) {
+        return 4;
+    }
+    if (!Number.isInteger(value) || value < minimum) {
+        throw new Error(`KCC jump.${field} must be an integer >= ${minimum}, got ${value}`);
+    }
+    return value;
+}
 export function stepDeterministicKcc3D(body, input, world, options) {
+    const jump = normalizeKccJumpTuning3D(options.jump);
     let next = applyProcessors(body, input, options.frame, options.processors ?? []);
     const events = [];
     let correctionCount = 0;
@@ -9,8 +41,8 @@ export function stepDeterministicKcc3D(body, input, world, options) {
     let collisionFilterCalls = 0;
     let collisionFilterRejectedHits = 0;
     const externalImpulse = combineExternalKccImpulses(options.externalImpulses ?? []);
-    let coyoteFrames = next.grounded ? 4 : Math.max(0, next.coyoteFrames - 1);
-    let jumpBufferFrames = input.jumpPressed === true ? 4 : Math.max(0, next.jumpBufferFrames - 1);
+    let coyoteFrames = next.grounded ? jump.coyoteFrames : Math.max(0, next.coyoteFrames - 1);
+    let jumpBufferFrames = input.jumpPressed === true ? jump.bufferFrames : Math.max(0, next.jumpBufferFrames - 1);
     let vx = input.moveX + externalImpulse.vx;
     let vz = input.moveZ + externalImpulse.vz;
     let vy = next.vy - 1 + externalImpulse.vy;
@@ -19,6 +51,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 +69,7 @@ export function stepDeterministicKcc3D(body, input, world, options) {
             vy = 0;
             grounded = true;
             platformId = platform.id;
+            platformClaimedThisFrame = true;
             events.push('moving-platform');
         }
     }
@@ -67,14 +101,66 @@ export function stepDeterministicKcc3D(body, input, world, options) {
         }
     }
     if (jumpBufferFrames > 0 && (next.grounded || next.coyoteFrames > 0 || grounded)) {
-        vy = 10;
-        y += 1;
+        vy = jump.impulse;
+        y += jump.liftOff;
         grounded = false;
         platformId = undefined;
         jumpBufferFrames = 0;
         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 +176,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 +218,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);
@@ -131,7 +229,7 @@ export function stepDeterministicKcc3D(body, input, world, options) {
     next = boundsCorrection.body;
     const finalBody = {
         ...next,
-        coyoteFrames: next.grounded ? 4 : coyoteFrames,
+        coyoteFrames: next.grounded ? jump.coyoteFrames : coyoteFrames,
         jumpBufferFrames,
     };
     return {
@@ -247,7 +345,144 @@ 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;
+/**
+ * Extra vertical lift a round capsule bottom needs to rest ON a sloped surface
+ * instead of IN it.
+ *
+ * groundContactTopAt reports the height under the capsule CENTRE, but the
+ * bottom is a sphere, so on gradient `g` the contact sits uphill and a bare
+ * radius of lift buries the uphill flank by `radius * (sec θ - 1)`. Past ~1.7°
+ * that exceeds KCC_GROUND_CLEARANCE, every overlap probe (full, x-only AND
+ * z-only) hits, and resolvePhysicsSlide3D reverts the whole horizontal move.
+ *
+ * Sampled a bottom-sphere radius out: that is the footprint the sphere can
+ * touch, it reads a plane exactly at any angle, and it self-bounds the
+ * discontinuities groundContactTopAt has on some shapes (a compound's children
+ * can butt together at a height jump) — a jump of D reads as D/radius here
+ * instead of the skyward fling an epsilon probe would give. Per axis it takes
+ * the steeper of forward/backward so a sample straddling an edge cannot
+ * average its way to an under-lift and back into the freeze.
+ */
+function kccSlopeClearance(body, x, z, top, geometry) {
+    const step = geometry.radius + geometry.skinWidth;
+    const axisGradient = (deltaX, deltaZ) => {
+        const ahead = groundContactTopAt(body, x + deltaX, z + deltaZ);
+        const behind = groundContactTopAt(body, x - deltaX, z - deltaZ);
+        const forward = ahead === undefined ? 0 : Math.abs(ahead - top) / step;
+        const backward = behind === undefined ? 0 : Math.abs(top - behind) / step;
+        return Math.max(forward, backward);
+    };
+    const gradientX = axisGradient(step, 0);
+    const gradientZ = axisGradient(0, step);
+    const gradientSq = gradientX * gradientX + gradientZ * gradientZ;
+    if (gradientSq <= 0) {
+        return 0;
+    }
+    // radius + skinWidth is the bottom-sphere radius physicsOverlapsKcc probes with.
+    return (geometry.radius + geometry.skinWidth) * (solverSqrt(1 + gradientSq) - 1);
+}
+/**
+ * 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)
+        .map((candidate) => ({
+        ...candidate,
+        lift: kccSlopeClearance(candidate.body, x, z, candidate.top, geometry),
+    }))
+        // The band is measured from where the capsule actually STANDS, so a slope
+        // lift bigger than snapDistance cannot drop it out of its own ground the
+        // next frame and leave it cycling between grounded and falling.
+        .filter((candidate) => feetY <= candidate.top + candidate.lift + 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) + ground.lift,
+    };
 }
 /** World half-extents (x,y,z) of a primitive shape under rotation matrix `m`. */
 function primitiveHalfExtent(shape, m) {
@@ -283,7 +518,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 +543,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;
+}