@series-inc/rundot-syncplay 5.28.0-beta.1 → 5.28.0-beta.3

package/dist/browser.d.ts

@@ -25,7 +25,7 @@ export { createSyncplayRunner } from './runner.js';
 export { fbm2D, hash2, hashUint32, valueNoise1D, valueNoise2D } from './noise.js';
 export { circleCastDeterministicPhysics2D, createDeterministicPhysicsWorld2D, nearestDeterministicPhysicsHit2D, queryDeterministicPhysicsAabb2D, queryDeterministicPhysicsShapeOverlap2D, raycastAllDeterministicPhysics2D, raycastDeterministicPhysics2D, stepDeterministicPhysicsWorld2D } from './physics2d.js';
 export { applyDeterministicForces3D, applyDeterministicImpulse3D, applyDeterministicImpulses3D, applyDeterministicWorldEdit3D, contactDetailsDeterministicPhysics3D, createBoxShapeFromExtents, createBoxShapeFromMinMax, createCapsuleShapeFromBase, createDeterministicPhysicsWorld3D, createTrustedDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, setDeterministicKinematicPoses3D, setDeterministicKinematicTransforms3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D } from './physics3d.js';
-export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D } from './physics3d-voxel.js';
+export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D } from './physics3d-voxel.js';
 export { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { createDeterministicCosmeticPhysicsWorld3D, setDeterministicCosmeticPhysicsAuthoritativeBodyProxies3D, stepDeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.js';
@@ -66,7 +66,7 @@ export type { CookedDeterministicNavmesh, DeterministicNavmeshAgent, Determinist
 export type { ConfirmedSyncplayPresentationFrame, KinetixRuntimeFactory, NetworkedClientTransport, NetworkedSyncplayClient, NetworkedSyncplayClientInputDelayOptions, NetworkedSyncplayClientNetStats, NetworkedSyncplayClientOptions, NetworkedSyncplayClientPacingOptions, NetworkedSyncplayPreparationOptions, NetworkedSyncplaySessionDescriptor, NetworkedSyncplaySlotPresence, PreparedNetworkedSyncplayTransport, SyncplayPredictionMode, SyncplayRemoteInputPrediction } from './networked-client.js';
 export type { SyncplayRunner, SyncplayRunnerConfig, SyncplayRunnerConnectionEvent, SyncplayRunnerOccupancy, SyncplayRunnerOfflineOptions, SyncplayRunnerPresentation, SyncplayRunnerSnapshot, SyncplayRunnerStatus, SyncplayRunnerTransport } from './runner.js';
 export type { DeterministicBodyKind, DeterministicContactEvent2D, DeterministicContactEventType, DeterministicPhysicsAabbQuery2D, DeterministicPhysicsActivePair2D, DeterministicPhysicsBody2D, DeterministicPhysicsCircleCastQuery2D, DeterministicPhysicsConstraint2D, DeterministicPhysicsHit2D, DeterministicPhysicsQueryOptions2D, DeterministicPhysicsRaycastQuery2D, DeterministicPhysicsShape2D, DeterministicPhysicsShapeOverlapQuery2D, DeterministicPhysicsStepOptions2D, DeterministicPhysicsStepResult2D, DeterministicPhysicsWorld2D } from './physics2d.js';
-export type { DeterministicContactCacheEntry3D, DeterministicJointCacheEntry3D, DeterministicKinematicPose3D, DeterministicKinematicTransformBuffer3D, DeterministicPhysicsActivePair3D, DeterministicPhysicsAxisLock3D, DeterministicPhysicsBody3D, DeterministicPhysicsCallbackMask3D, DeterministicPhysicsCompoundChild3D, DeterministicPhysicsCompoundChildShape3D, DeterministicPhysicsConstraint3D, DeterministicPhysicsContactDetail3D, DeterministicPhysicsContactEvent3D, DeterministicPhysicsDetailedHit3D, DeterministicPhysicsForceApplication3D, DeterministicPhysicsHit3D, DeterministicPhysicsHullShape3D, DeterministicPhysicsImpulseApplication3D, DeterministicPhysicsOverlapQuery3D, DeterministicPhysicsPrimitiveShape3D, DeterministicPhysicsQuaternion3D, DeterministicPhysicsQueryOptions3D, DeterministicPhysicsRaycastQuery3D, DeterministicPhysicsScheduledQuery3D, DeterministicPhysicsShape3D, DeterministicPhysicsShapeCastQuery3D, DeterministicPhysicsStepResult3D, DeterministicPhysicsVec3, DeterministicPhysicsWorld3D, DeterministicPhysicsWorldEdit3D } from './physics3d.js';
+export type { DeterministicContactCacheEntry3D, DeterministicJointCacheEntry3D, DeterministicKinematicPose3D, DeterministicKinematicTransformBuffer3D, DeterministicPhysicsActivePair3D, DeterministicPhysicsAxisLock3D, DeterministicPhysicsBody3D, DeterministicPhysicsCallbackMask3D, DeterministicPhysicsCompoundChild3D, DeterministicPhysicsCompoundChildShape3D, DeterministicPhysicsConstraint3D, DeterministicPhysicsContactDetail3D, DeterministicPhysicsContactEvent3D, DeterministicPhysicsDetailedHit3D, DeterministicPhysicsForceApplication3D, DeterministicPhysicsHit3D, DeterministicPhysicsHullShape3D, DeterministicPhysicsImpulseApplication3D, DeterministicPhysicsOverlapQuery3D, DeterministicPhysicsPrimitiveShape3D, DeterministicPhysicsQuaternion3D, DeterministicPhysicsQueryOptions3D, DeterministicPhysicsRaycastQuery3D, DeterministicPhysicsScheduledQuery3D, DeterministicPhysicsShape3D, DeterministicPhysicsShapeCastQuery3D, DeterministicPhysicsStepOptions3D, DeterministicPhysicsStepResult3D, DeterministicPhysicsVec3, DeterministicPhysicsWorld3D, DeterministicPhysicsWorldEdit3D } from './physics3d.js';
 export type { DeterministicVoxelChunk3D, DeterministicVoxelCompoundShape3D, DeterministicVoxelRayHit3D, SplitDeterministicVoxelChunkOptions3D, VoxelAnchorFace, VoxelBoxCarveRegion3D, VoxelCapsuleCarveRegion3D, VoxelCarveRegion3D, VoxelOccupancy3D, VoxelSphereCarveRegion3D, VoxelSubChunk3D } from './physics3d-voxel.js';
 export type { PhysicsWorldDebugMesh, PhysicsWorldDebugMeshOptions } from './debug-wireframe.js';
 export type { DeterministicAuthoritativeBodyProxy3D, DeterministicCosmeticPhysicsBody3D, DeterministicCosmeticPhysicsStepOptions3D, DeterministicCosmeticPhysicsStepResult3D, DeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.js';

package/dist/browser.js

@@ -26,7 +26,7 @@ export { createSyncplayRunner } from './runner.js';
 export { fbm2D, hash2, hashUint32, valueNoise1D, valueNoise2D } from './noise.js';
 export { circleCastDeterministicPhysics2D, createDeterministicPhysicsWorld2D, nearestDeterministicPhysicsHit2D, queryDeterministicPhysicsAabb2D, queryDeterministicPhysicsShapeOverlap2D, raycastAllDeterministicPhysics2D, raycastDeterministicPhysics2D, stepDeterministicPhysicsWorld2D } from './physics2d.js';
 export { applyDeterministicForces3D, applyDeterministicImpulse3D, applyDeterministicImpulses3D, applyDeterministicWorldEdit3D, contactDetailsDeterministicPhysics3D, createBoxShapeFromExtents, createBoxShapeFromMinMax, createCapsuleShapeFromBase, createDeterministicPhysicsWorld3D, createTrustedDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, setDeterministicKinematicPoses3D, setDeterministicKinematicTransforms3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D } from './physics3d.js';
-export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D } from './physics3d-voxel.js';
+export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D } from './physics3d-voxel.js';
 export { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { createDeterministicCosmeticPhysicsWorld3D, setDeterministicCosmeticPhysicsAuthoritativeBodyProxies3D, stepDeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.js';

package/dist/creator.d.ts

@@ -13,13 +13,15 @@ export type { ReplayRuntimeFactory, ReplayVerificationConfig, ReplayVerification
 export type { SyncplaySession, SyncplaySessionPolicy } from './sdk-session.js';
 export type { InstantReplayInputFrame, InstantReplayResult, InstantReplayRunner, InstantReplayRunnerOptions, InstantReplayRunOptions, RunInstantReplayOptions, } from './instant-replay.js';
 export { applyDeterministicForces3D, applyDeterministicImpulse3D, applyDeterministicImpulses3D, applyDeterministicWorldEdit3D, contactDetailsDeterministicPhysics3D, createBoxShapeFromExtents, createBoxShapeFromMinMax, createCapsuleShapeFromBase, createDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, setDeterministicKinematicPoses3D, setDeterministicKinematicTransforms3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D, } from './physics3d.js';
-export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D, } from './physics3d-voxel.js';
+export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D, } from './physics3d-voxel.js';
 export { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { stepDeterministicVehicle3D } from './physics3d-vehicle.js';
-export type { DeterministicContactCacheEntry3D, DeterministicJointCacheEntry3D, DeterministicKinematicPose3D, DeterministicKinematicTransformBuffer3D, DeterministicPhysicsActivePair3D, DeterministicPhysicsAxisLock3D, DeterministicPhysicsBody3D, DeterministicPhysicsCallbackMask3D, DeterministicPhysicsCompoundChild3D, DeterministicPhysicsCompoundChildShape3D, DeterministicPhysicsConstraint3D, DeterministicPhysicsContactDetail3D, DeterministicPhysicsContactEvent3D, DeterministicPhysicsDetailedHit3D, DeterministicPhysicsForceApplication3D, DeterministicPhysicsHit3D, DeterministicPhysicsHullShape3D, DeterministicPhysicsImpulseApplication3D, DeterministicPhysicsOverlapQuery3D, DeterministicPhysicsPrimitiveShape3D, DeterministicPhysicsQuaternion3D, DeterministicPhysicsQueryOptions3D, DeterministicPhysicsRaycastQuery3D, DeterministicPhysicsScheduledQuery3D, DeterministicPhysicsShape3D, DeterministicPhysicsShapeCastQuery3D, DeterministicPhysicsStepResult3D, DeterministicPhysicsVec3, DeterministicPhysicsWorld3D, DeterministicPhysicsWorldEdit3D, } from './physics3d.js';
+export { createDeterministicBinarySerializer, deterministicDslMaxPlayers, parseDeterministicSchemaDsl, stableDeterministicDslSchemaJson, } from './schema-dsl-binary.js';
+export type { DeterministicContactCacheEntry3D, DeterministicJointCacheEntry3D, DeterministicKinematicPose3D, DeterministicKinematicTransformBuffer3D, DeterministicPhysicsActivePair3D, DeterministicPhysicsAxisLock3D, DeterministicPhysicsBody3D, DeterministicPhysicsCallbackMask3D, DeterministicPhysicsCompoundChild3D, DeterministicPhysicsCompoundChildShape3D, DeterministicPhysicsConstraint3D, DeterministicPhysicsContactDetail3D, DeterministicPhysicsContactEvent3D, DeterministicPhysicsDetailedHit3D, DeterministicPhysicsForceApplication3D, DeterministicPhysicsHit3D, DeterministicPhysicsHullShape3D, DeterministicPhysicsImpulseApplication3D, DeterministicPhysicsOverlapQuery3D, DeterministicPhysicsPrimitiveShape3D, DeterministicPhysicsQuaternion3D, DeterministicPhysicsQueryOptions3D, DeterministicPhysicsRaycastQuery3D, DeterministicPhysicsScheduledQuery3D, DeterministicPhysicsShape3D, DeterministicPhysicsShapeCastQuery3D, DeterministicPhysicsStepOptions3D, DeterministicPhysicsStepResult3D, DeterministicPhysicsVec3, DeterministicPhysicsWorld3D, DeterministicPhysicsWorldEdit3D, } from './physics3d.js';
 export type { DeterministicVoxelChunk3D, DeterministicVoxelCompoundShape3D, DeterministicVoxelRayHit3D, SplitDeterministicVoxelChunkOptions3D, VoxelAnchorFace, VoxelBoxCarveRegion3D, VoxelCapsuleCarveRegion3D, VoxelCarveRegion3D, VoxelOccupancy3D, VoxelSphereCarveRegion3D, VoxelSubChunk3D, } from './physics3d-voxel.js';
 export type { PhysicsWorldDebugMesh, PhysicsWorldDebugMeshOptions } from './debug-wireframe.js';
 export type { DeterministicPhysicsJoint3D } from './physics3d-joints.js';
 export type { DeterministicVehicle3D, DeterministicVehicleImpulse3D, DeterministicVehicleInput3D, DeterministicVehicleStepOptions3D, DeterministicVehicleStepResult3D, DeterministicVehicleWheel3D, DeterministicVehicleWheelTelemetry3D, } from './physics3d-vehicle.js';
 export type { DeterministicPhysicsMaterial } from './deterministic-primitives.js';
+export type { DeterministicBinarySerializer, DeterministicDslDeclaration, DeterministicDslDeclarationKind, DeterministicDslDictionaryEntry, DeterministicDslDictionaryFieldKind, DeterministicDslField, DeterministicDslFieldKind, DeterministicDslFixedArrayFieldKind, DeterministicDslListFieldKind, DeterministicDslScalarFieldKind, DeterministicDslScalarValue, DeterministicDslSchema, DeterministicDslSetFieldKind, DeterministicDslValue, } from './schema-dsl-binary.js';

package/dist/creator.js

@@ -10,7 +10,8 @@ export { runSyncplaySynctest } from './synctest.js';
 // cooking. Cosmetic physics, KCC (movement3d), and the destruction-cert runner
 // stay off it — the first two are not requested, the third reads wall clock.
 export { applyDeterministicForces3D, applyDeterministicImpulse3D, applyDeterministicImpulses3D, applyDeterministicWorldEdit3D, contactDetailsDeterministicPhysics3D, createBoxShapeFromExtents, createBoxShapeFromMinMax, createCapsuleShapeFromBase, createDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, setDeterministicKinematicPoses3D, setDeterministicKinematicTransforms3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D, } from './physics3d.js';
-export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D, } from './physics3d-voxel.js';
+export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D, } from './physics3d-voxel.js';
 export { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { stepDeterministicVehicle3D } from './physics3d-vehicle.js';
+export { createDeterministicBinarySerializer, deterministicDslMaxPlayers, parseDeterministicSchemaDsl, stableDeterministicDslSchemaJson, } from './schema-dsl-binary.js';

package/dist/index.d.ts

@@ -28,7 +28,7 @@ export { createSyncplayRunner } from './runner.js';
 export { fbm2D, hash2, hashUint32, valueNoise1D, valueNoise2D } from './noise.js';
 export { circleCastDeterministicPhysics2D, createDeterministicPhysicsWorld2D, nearestDeterministicPhysicsHit2D, queryDeterministicPhysicsAabb2D, queryDeterministicPhysicsShapeOverlap2D, raycastAllDeterministicPhysics2D, raycastDeterministicPhysics2D, stepDeterministicPhysicsWorld2D } from './physics2d.js';
 export { applyDeterministicForces3D, applyDeterministicImpulse3D, applyDeterministicImpulses3D, applyDeterministicWorldEdit3D, contactDetailsDeterministicPhysics3D, createBoxShapeFromExtents, createBoxShapeFromMinMax, createCapsuleShapeFromBase, createDeterministicPhysicsWorld3D, createTrustedDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, setDeterministicKinematicPoses3D, setDeterministicKinematicTransforms3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D } from './physics3d.js';
-export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D } from './physics3d-voxel.js';
+export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D } from './physics3d-voxel.js';
 export { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { runDeterministicPhysics3DDestructionCert } from './physics3d-destruction-cert.js';
@@ -78,7 +78,7 @@ export type { CookedDeterministicNavmesh, DeterministicNavmeshAgent, Determinist
 export type { ConfirmedSyncplayPresentationFrame, KinetixRuntimeFactory, NetworkedClientTransport, NetworkedSyncplayClient, NetworkedSyncplayClientInputDelayOptions, NetworkedSyncplayClientNetStats, NetworkedSyncplayClientOptions, NetworkedSyncplayClientPacingOptions, NetworkedSyncplayPreparationOptions, NetworkedSyncplaySessionDescriptor, PreparedNetworkedSyncplayTransport, SyncplayPredictionMode, SyncplayRemoteInputPrediction } from './networked-client.js';
 export type { SyncplayRunner, SyncplayRunnerConfig, SyncplayRunnerConnectionEvent, SyncplayRunnerOccupancy, SyncplayRunnerOfflineOptions, SyncplayRunnerPresentation, SyncplayRunnerSnapshot, SyncplayRunnerStatus, SyncplayRunnerTransport } from './runner.js';
 export type { DeterministicBodyKind, DeterministicContactEvent2D, DeterministicContactEventType, DeterministicPhysicsAabbQuery2D, DeterministicPhysicsBody2D, DeterministicPhysicsCircleCastQuery2D, DeterministicPhysicsConstraint2D, DeterministicPhysicsHit2D, DeterministicPhysicsQueryOptions2D, DeterministicPhysicsRaycastQuery2D, DeterministicPhysicsShape2D, DeterministicPhysicsShapeOverlapQuery2D, DeterministicPhysicsStepOptions2D, DeterministicPhysicsStepResult2D, DeterministicPhysicsWorld2D } from './physics2d.js';
-export type { DeterministicContactCacheEntry3D, DeterministicJointCacheEntry3D, DeterministicKinematicPose3D, DeterministicKinematicTransformBuffer3D, DeterministicPhysicsActivePair3D, DeterministicPhysicsAxisLock3D, DeterministicPhysicsBody3D, DeterministicPhysicsCallbackMask3D, DeterministicPhysicsCompoundChild3D, DeterministicPhysicsCompoundChildShape3D, DeterministicPhysicsConstraint3D, DeterministicPhysicsContactDetail3D, DeterministicPhysicsContactEvent3D, DeterministicPhysicsDetailedHit3D, DeterministicPhysicsForceApplication3D, DeterministicPhysicsHit3D, DeterministicPhysicsHullShape3D, DeterministicPhysicsImpulseApplication3D, DeterministicPhysicsOverlapQuery3D, DeterministicPhysicsPrimitiveShape3D, DeterministicPhysicsQuaternion3D, DeterministicPhysicsQueryOptions3D, DeterministicPhysicsRaycastQuery3D, DeterministicPhysicsScheduledQuery3D, DeterministicPhysicsShape3D, DeterministicPhysicsShapeCastQuery3D, DeterministicPhysicsStepResult3D, DeterministicPhysicsVec3, DeterministicPhysicsWorld3D, DeterministicPhysicsWorldEdit3D } from './physics3d.js';
+export type { DeterministicContactCacheEntry3D, DeterministicJointCacheEntry3D, DeterministicKinematicPose3D, DeterministicKinematicTransformBuffer3D, DeterministicPhysicsActivePair3D, DeterministicPhysicsAxisLock3D, DeterministicPhysicsBody3D, DeterministicPhysicsCallbackMask3D, DeterministicPhysicsCompoundChild3D, DeterministicPhysicsCompoundChildShape3D, DeterministicPhysicsConstraint3D, DeterministicPhysicsContactDetail3D, DeterministicPhysicsContactEvent3D, DeterministicPhysicsDetailedHit3D, DeterministicPhysicsForceApplication3D, DeterministicPhysicsHit3D, DeterministicPhysicsHullShape3D, DeterministicPhysicsImpulseApplication3D, DeterministicPhysicsOverlapQuery3D, DeterministicPhysicsPrimitiveShape3D, DeterministicPhysicsQuaternion3D, DeterministicPhysicsQueryOptions3D, DeterministicPhysicsRaycastQuery3D, DeterministicPhysicsScheduledQuery3D, DeterministicPhysicsShape3D, DeterministicPhysicsShapeCastQuery3D, DeterministicPhysicsStepOptions3D, DeterministicPhysicsStepResult3D, DeterministicPhysicsVec3, DeterministicPhysicsWorld3D, DeterministicPhysicsWorldEdit3D } from './physics3d.js';
 export type { DeterministicVoxelChunk3D, DeterministicVoxelCompoundShape3D, DeterministicVoxelRayHit3D, SplitDeterministicVoxelChunkOptions3D, VoxelAnchorFace, VoxelBoxCarveRegion3D, VoxelCapsuleCarveRegion3D, VoxelCarveRegion3D, VoxelOccupancy3D, VoxelSphereCarveRegion3D, VoxelSubChunk3D } from './physics3d-voxel.js';
 export type { PhysicsWorldDebugMesh, PhysicsWorldDebugMeshOptions } from './debug-wireframe.js';
 export type { DeterministicDestructionCertOptions, DeterministicDestructionCertResult } from './physics3d-destruction-cert.js';

package/dist/index.js

@@ -29,7 +29,7 @@ export { createSyncplayRunner } from './runner.js';
 export { fbm2D, hash2, hashUint32, valueNoise1D, valueNoise2D } from './noise.js';
 export { circleCastDeterministicPhysics2D, createDeterministicPhysicsWorld2D, nearestDeterministicPhysicsHit2D, queryDeterministicPhysicsAabb2D, queryDeterministicPhysicsShapeOverlap2D, raycastAllDeterministicPhysics2D, raycastDeterministicPhysics2D, stepDeterministicPhysicsWorld2D } from './physics2d.js';
 export { applyDeterministicForces3D, applyDeterministicImpulse3D, applyDeterministicImpulses3D, applyDeterministicWorldEdit3D, contactDetailsDeterministicPhysics3D, createBoxShapeFromExtents, createBoxShapeFromMinMax, createCapsuleShapeFromBase, createDeterministicPhysicsWorld3D, createTrustedDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, setDeterministicKinematicPoses3D, setDeterministicKinematicTransforms3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D } from './physics3d.js';
-export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D } from './physics3d-voxel.js';
+export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D } from './physics3d-voxel.js';
 export { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { runDeterministicPhysics3DDestructionCert } from './physics3d-destruction-cert.js';

package/dist/physics3d-joints.d.ts

@@ -101,6 +101,11 @@ export type DeterministicPhysicsJoint3D = {
     readonly targetZ: number;
     readonly maxForce: number;
     readonly damping?: number;
+    readonly targetRotation?: Quat3D;
+    readonly maxTorque?: number;
+    readonly angularDamping?: number;
+    readonly breakDistance?: number;
+    readonly breakImpulse?: number;
 };
 /** Build solver joint objects from joint definitions, seeded from the joint cache. */
 export declare function createSolverJoints(joints: readonly DeterministicPhysicsJoint3D[], indexById: Map<string, number>, jointCache: readonly SolverJointCacheEntry[]): SolverJointSolve[];

package/dist/physics3d-joints.js

@@ -639,12 +639,33 @@ function grabJoint(joint, bodyIndex, warm) {
     let desiredVel = { x: 0, y: 0, z: 0 };
     const target = { x: joint.targetX, y: joint.targetY, z: joint.targetZ };
     const maxImpulse = joint.maxForce * 1;
+    const targetRotation = joint.targetRotation !== undefined ? normalizeQuat(joint.targetRotation) : undefined;
+    const maxTorque = joint.maxTorque ?? 0;
+    const angularDamping = joint.angularDamping ?? joint.damping ?? 1;
+    let desiredAngVel = { x: 0, y: 0, z: 0 };
+    let angMassMat;
+    let angMassDiag;
+    let broken = false;
+    let torqueImpulse = { x: 0, y: 0, z: 0 };
     return {
         bodyIndices: [bodyIndex],
         prepare(ctx) {
+            if (broken) {
+                return;
+            }
+            torqueImpulse = { x: 0, y: 0, z: 0 };
             const body = ctx.bodies[bodyIndex];
             r = jointLever(body, joint.anchor);
             const worldAnchor = addVec3(body.c, r);
+            if (joint.breakDistance !== undefined) {
+                const delta = subVec3(target, worldAnchor);
+                const d = solverSqrt(dotVec3(delta, delta));
+                if (d > joint.breakDistance) {
+                    broken = true;
+                    state.impulse = { x: 0, y: 0, z: 0 };
+                    return;
+                }
+            }
             const imB = ctx.invMass[bodyIndex];
             const linear = mat3FromDiag(imB);
             const skewR = skewMat3(r);
@@ -653,8 +674,36 @@ function grabJoint(joint, bodyIndex, warm) {
             const damping = joint.damping ?? 1;
             desiredVel = scaleVec3(subVec3(target, worldAnchor), damping / ctx.dt);
             ctx.applyToBody(bodyIndex, r, state.impulse);
+            if (targetRotation !== undefined) {
+                const errorRotation = quatMultiply(quatConjugate(targetRotation), body.q);
+                const sign = errorRotation.w < 0 ? -1 : 1;
+                const error = {
+                    x: 2 * sign * errorRotation.x,
+                    y: 2 * sign * errorRotation.y,
+                    z: 2 * sign * errorRotation.z,
+                };
+                desiredAngVel = scaleVec3(error, -angularDamping / ctx.dt);
+                const invI = ctx.invInertia[bodyIndex];
+                const fullInv = invertMat3(invI);
+                const isSingular = fullInv[0] === 0 && fullInv[4] === 0 && fullInv[8] === 0;
+                if (!isSingular) {
+                    angMassMat = fullInv;
+                    angMassDiag = undefined;
+                }
+                else {
+                    angMassMat = undefined;
+                    angMassDiag = {
+                        x: invI[0] > 1e-9 ? 1 / invI[0] : 0,
+                        y: invI[4] > 1e-9 ? 1 / invI[4] : 0,
+                        z: invI[8] > 1e-9 ? 1 / invI[8] : 0,
+                    };
+                }
+            }
         },
         iterate(ctx) {
+            if (broken) {
+                return;
+            }
             const body = ctx.bodies[bodyIndex];
             const currentVel = addVec3(body.v, crossVec3(body.w, r));
             const dImpulse = mulMat3Vec(kInv, subVec3(desiredVel, currentVel));
@@ -663,9 +712,36 @@ function grabJoint(joint, bodyIndex, warm) {
             const applied = subVec3(clamped, state.impulse);
             state.impulse = clamped;
             ctx.applyToBody(bodyIndex, r, applied);
+            if (targetRotation !== undefined && maxTorque > 0) {
+                const deltaW = subVec3(desiredAngVel, body.w);
+                const dTorque = angMassMat !== undefined
+                    ? mulMat3Vec(angMassMat, deltaW)
+                    : { x: deltaW.x * angMassDiag.x, y: deltaW.y * angMassDiag.y, z: deltaW.z * angMassDiag.z };
+                const targetTorque = addVec3(torqueImpulse, dTorque);
+                const clampedTorque = clampMagnitude(targetTorque, maxTorque * ctx.dt);
+                const appliedTorque = subVec3(clampedTorque, torqueImpulse);
+                torqueImpulse = clampedTorque;
+                ctx.applyAngularToBody(bodyIndex, appliedTorque);
+            }
+        },
+        postSubstep(_ctx) {
+            if (!broken) {
+                state.stepImpulse = addVec3(state.stepImpulse, state.impulse);
+            }
+            torqueImpulse = { x: 0, y: 0, z: 0 };
         },
         emitCache() {
-            return { jointId: joint.id, impulseX: state.impulse.x, impulseY: state.impulse.y, impulseZ: state.impulse.z, axialImpulse: 0, hingeAngle: 0 };
+            const reaction2 = dotVec3(state.stepImpulse, state.stepImpulse);
+            const isBroken = broken || (joint.breakImpulse !== undefined && reaction2 > joint.breakImpulse * joint.breakImpulse);
+            return {
+                jointId: joint.id,
+                impulseX: isBroken ? 0 : state.impulse.x,
+                impulseY: isBroken ? 0 : state.impulse.y,
+                impulseZ: isBroken ? 0 : state.impulse.z,
+                axialImpulse: 0,
+                hingeAngle: 0,
+                ...(isBroken ? { broken: true } : {}),
+            };
         },
     };
 }
@@ -687,6 +763,33 @@ function validateJoint(joint) {
         if (!Number.isFinite(joint.targetX) || !Number.isFinite(joint.targetY) || !Number.isFinite(joint.targetZ)) {
             throw new Error(`physics3d joint ${joint.id}: target must be finite`);
         }
+        if (joint.damping !== undefined && (!Number.isFinite(joint.damping) || joint.damping < 0)) {
+            throw new Error(`physics3d joint ${joint.id}: damping must be non-negative`);
+        }
+        if (joint.targetRotation !== undefined) {
+            const target = joint.targetRotation;
+            if (!Number.isFinite(target.x) || !Number.isFinite(target.y) || !Number.isFinite(target.z) || !Number.isFinite(target.w)
+                || target.x * target.x + target.y * target.y + target.z * target.z + target.w * target.w === 0) {
+                throw new Error(`physics3d joint ${joint.id}: targetRotation must be a finite non-zero quaternion`);
+            }
+            if (joint.maxTorque === undefined || !Number.isFinite(joint.maxTorque) || joint.maxTorque <= 0) {
+                throw new Error(`physics3d joint ${joint.id}: maxTorque must be a positive finite number`);
+            }
+        }
+        else if (joint.maxTorque !== undefined) {
+            if (!Number.isFinite(joint.maxTorque) || joint.maxTorque <= 0) {
+                throw new Error(`physics3d joint ${joint.id}: maxTorque must be a positive finite number`);
+            }
+        }
+        if (joint.angularDamping !== undefined && (!Number.isFinite(joint.angularDamping) || joint.angularDamping < 0)) {
+            throw new Error(`physics3d joint ${joint.id}: angularDamping must be non-negative`);
+        }
+        if (joint.breakDistance !== undefined && (!Number.isFinite(joint.breakDistance) || joint.breakDistance <= 0)) {
+            throw new Error(`physics3d joint ${joint.id}: breakDistance must be positive`);
+        }
+        if (joint.breakImpulse !== undefined && (!Number.isFinite(joint.breakImpulse) || joint.breakImpulse <= 0)) {
+            throw new Error(`physics3d joint ${joint.id}: breakImpulse must be positive`);
+        }
         return;
     }
     assertFiniteVec(joint.anchorA, 'anchorA', joint.id);

package/dist/physics3d-solver.d.ts

@@ -222,6 +222,8 @@ export interface SolverJointContext {
     apply(a: number, b: number, rA: Point3D, rB: Point3D, impulse: Point3D): void;
     /** Angular-only impulse (no linear component), e.g. hinge motor/limit rows. */
     applyAngular(a: number, b: number, angularImpulse: Point3D): void;
+    /** Apply an angular impulse to a single body (grab joint orientation drive). */
+    applyAngularToBody(index: number, angularImpulse: Point3D): void;
     /** Apply an impulse to a single body at anchor `r` (grab / world-target joints). */
     applyToBody(index: number, r: Point3D, impulse: Point3D): void;
     /** Split-impulse position correction on pseudo-velocities (no real momentum). */

package/dist/physics3d-solver.js

@@ -1685,6 +1685,13 @@ export function solveRigidStep(bodies, options) {
                 B.w = addVec3(B.w, mulMat3Vec(invInertia[b], angularImpulse));
             }
         },
+        applyAngularToBody: (index, angularImpulse) => {
+            const body = bodies[index];
+            if (!solid(body)) {
+                return;
+            }
+            body.w = addVec3(body.w, mulMat3Vec(invInertia[index], angularImpulse));
+        },
         applyToBody: (index, r, impulse) => {
             const body = bodies[index];
             if (!solid(body)) {

package/dist/physics3d-voxel.d.ts

@@ -91,6 +91,11 @@ export declare function cookDeterministicVoxelSubregion3D(chunk: DeterministicVo
     readonly maxY: number;
     readonly maxZ: number;
 }): DeterministicVoxelCompoundShape3D | undefined;
+/**
+ * Alias for {@link cookDeterministicVoxelSubregion3D}.
+ * Re-cooks dirty subregions of a voxel chunk collider after carving or modifying voxels.
+ */
+export declare const recookDeterministicVoxelSubregion3D: typeof cookDeterministicVoxelSubregion3D;
 export type VoxelAnchorFace = '+x' | '-x' | '+y' | '-y' | '+z' | '-z';
 export interface VoxelSubChunk3D {
     readonly chunk: DeterministicVoxelChunk3D;

package/dist/physics3d-voxel.js

@@ -501,6 +501,11 @@ export function cookDeterministicVoxelSubregion3D(chunk, existingShape, dirtyReg
         children: finalChildren,
     };
 }
+/**
+ * Alias for {@link cookDeterministicVoxelSubregion3D}.
+ * Re-cooks dirty subregions of a voxel chunk collider after carving or modifying voxels.
+ */
+export const recookDeterministicVoxelSubregion3D = cookDeterministicVoxelSubregion3D;
 /**
  * Partitions the non-zero voxels of a chunk into 6-connected components.
  * Each component is tightly cropped into a sub-chunk with its origin offset in parent cells,

package/dist/physics3d.d.ts

@@ -108,18 +108,28 @@ export interface DeterministicPhysicsBody3D {
     readonly x: number;
     readonly y: number;
     readonly z: number;
+    /**
+     * Linear velocity along the X axis in units per tick (NOT per second).
+     * The solver integrates per tick (`dtTicks`), so positions advance as `x += vx * dtTicks`.
+     */
     readonly vx: number;
+    /** Linear velocity along the Y axis in units per tick (NOT per second). */
     readonly vy: number;
+    /** Linear velocity along the Z axis in units per tick (NOT per second). */
     readonly vz: number;
     readonly rx?: number;
     readonly ry?: number;
     readonly rz?: number;
+    /** Angular velocity around the X axis in radians per tick (NOT per second). */
     readonly avx?: number;
+    /** Angular velocity around the Y axis in radians per tick (NOT per second). */
     readonly avy?: number;
+    /** Angular velocity around the Z axis in radians per tick (NOT per second). */
     readonly avz?: number;
     readonly inertia?: number;
     /** Full 6-DOF orientation (opt-in); bodies without it are rotation-locked through the rigid solver. */
     readonly orientation?: DeterministicPhysicsQuaternion3D;
+    /** Angular velocity vector in radians per tick (NOT per second). */
     readonly angularVel?: DeterministicPhysicsVec3;
     readonly mass?: number;
     readonly linearDamping?: number;
@@ -443,18 +453,35 @@ export declare function setDeterministicKinematicTransforms3D(world: Determinist
 export declare function applyDeterministicImpulse3D(world: DeterministicPhysicsWorld3D, bodyId: string, impulse: Point3D, worldPoint?: Point3D): DeterministicPhysicsWorld3D;
 /** Set a body's linear (and optional angular) velocity deterministically, waking its island. */
 export declare function setDeterministicBodyVelocity3D(world: DeterministicPhysicsWorld3D, bodyId: string, velocity: Point3D, angularVelocity?: Point3D): DeterministicPhysicsWorld3D;
-export declare function stepDeterministicPhysicsWorld3D(world: DeterministicPhysicsWorld3D, options?: {
+/**
+ * Options for advancing the deterministic 3D physics world snapshot-to-snapshot.
+ */
+export interface DeterministicPhysicsStepOptions3D {
+    /**
+     * Acceleration due to gravity along the Y axis, in units per tick squared (or dtTicks).
+     *
+     * NOTE ON TIME UNITS:
+     * `stepDeterministicPhysicsWorld3D` integrates per tick (with `dtTicks`, default 1 tick).
+     * Therefore, `gravityY` and rigid body velocities (`vx`, `vy`, `vz`, `angularVel`)
+     * are expressed per tick (units/tick, rad/tick), NOT per second.
+     * For example, at a 30 Hz tick rate with standard -9.8 m/s^2 gravity,
+     * `gravityY = -9.8 / (30 * 30)` ≈ `-0.0108889` units/tick^2.
+     */
     readonly gravityY?: number;
     readonly scheduledQueries?: readonly DeterministicPhysicsScheduledQuery3D[];
     readonly constraints?: readonly DeterministicPhysicsConstraint3D[];
     readonly joints?: readonly DeterministicPhysicsJoint3D[];
+    /**
+     * Step duration measured in ticks (default: 1).
+     */
     readonly dtTicks?: number;
     readonly velocityIterations?: number;
     readonly substeps?: number;
     readonly computeChecksum?: boolean;
     readonly computeBroadphasePairs?: boolean;
     readonly pairs?: readonly (readonly [number, number])[];
-}): DeterministicPhysicsStepResult3D;
+}
+export declare function stepDeterministicPhysicsWorld3D(world: DeterministicPhysicsWorld3D, options?: DeterministicPhysicsStepOptions3D): DeterministicPhysicsStepResult3D;
 /** O(1) body lookup backed by the per-world query-index cache. */
 export declare function deterministicPhysicsBodyById3D(world: DeterministicPhysicsWorld3D, bodyId: string): DeterministicPhysicsBody3D | undefined;
 export declare function __staticTreeBuildCount(): number;

package/dist/runner.d.ts

@@ -85,7 +85,17 @@ export interface SyncplayRunnerOfflineOptions<Input> {
 }
 export interface SyncplayRunnerSnapshot<RenderState> {
     readonly status: SyncplayRunnerStatus;
+    /**
+     * Discrete tick render state. Note: to prevent 30Hz display judder on
+     * high-refresh displays, prefer interpolatedRenderState or runner.getRenderState().
+     */
     readonly renderState?: Readonly<RenderState>;
+    /**
+     * Smooth presentation state interpolated between previous and current
+     * render states at the current `renderAlpha`. If no interpolator is
+     * configured or interpolation throws, falls back to `renderState`.
+     */
+    readonly interpolatedRenderState?: Readonly<RenderState>;
     readonly renderAlpha: number;
     readonly localSlot: number;
     readonly rollbackCount: number;

package/dist/runner.js

@@ -68,9 +68,28 @@ export function createSyncplayRunner(config) {
         return localSession !== undefined ? localSession.currentFrame : 0;
     }
     function snapshot() {
+        let interpolatedRender;
+        if (currentRender !== undefined) {
+            if (previousRender !== undefined && config.presentation.interpolate !== undefined) {
+                try {
+                    interpolatedRender = config.presentation.interpolate(previousRender, currentRender, renderAlpha);
+                }
+                catch {
+                    interpolatedRender = currentRender;
+                }
+            }
+            else {
+                interpolatedRender = currentRender;
+            }
+        }
         return Object.freeze({
             status,
-            ...(currentRender === undefined ? {} : { renderState: currentRender }),
+            ...(currentRender === undefined
+                ? {}
+                : {
+                    renderState: currentRender,
+                    interpolatedRenderState: interpolatedRender,
+                }),
             renderAlpha,
             localSlot,
             rollbackCount: networkClient?.rollbacks ?? 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@series-inc/rundot-syncplay",
-  "version": "5.28.0-beta.1",
+  "version": "5.28.0-beta.3",
   "description": "Kinetix orchestration, rollback, replay, late-join, and deterministic networking for RUN.game",
   "repository": {
     "type": "git",