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

package/core/physics.d.ts

@@ -276,6 +276,7 @@ export interface KinetixPhysicsStepResult {
   readonly world: KinetixPhysicsWorld;
   readonly contacts: readonly KinetixPhysicsContactEvent[];
   readonly brokenJointIds: readonly string[];
+  readonly brokenJoints: readonly string[];
   readonly scheduledQueryResults: readonly { readonly id: string; readonly hits: readonly KinetixPhysicsHit[] }[];
   readonly prePhysicsScheduledQueryResults: readonly { readonly id: string; readonly hits: readonly KinetixPhysicsHit[] }[];
   readonly postPhysicsScheduledQueryResults: readonly { readonly id: string; readonly hits: readonly KinetixPhysicsHit[] }[];

package/core/src/physics/index.mjs

@@ -2953,6 +2953,7 @@ export function stepPhysicsWorld(world, options) {
     world: nextWorld,
     contacts: visibleEvents,
     brokenJointIds,
+    brokenJoints: brokenJointIds,
     scheduledQueryResults,
     prePhysicsScheduledQueryResults,
     postPhysicsScheduledQueryResults,

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, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D } from './physics3d-voxel.js';
+export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D, splitDeterministicVoxelCompoundCollider3D } 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,8 +66,8 @@ 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, 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 { DeterministicContactCacheEntry3D, DeterministicFluidVolume3D, DeterministicJointCacheEntry3D, DeterministicKinematicPose3D, DeterministicKinematicTransformBuffer3D, DeterministicPhysicsAabb3D, 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, DeterministicVoxelCompoundSplitResult3D, 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';
 export type { DeterministicPhysicsJoint3D } from './physics3d-joints.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, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D } from './physics3d-voxel.js';
+export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D, splitDeterministicVoxelCompoundCollider3D } 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,13 @@ 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, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D, } from './physics3d-voxel.js';
+export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D, splitDeterministicVoxelCompoundCollider3D, } 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';
-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 { DeterministicContactCacheEntry3D, DeterministicFluidVolume3D, DeterministicJointCacheEntry3D, DeterministicKinematicPose3D, DeterministicKinematicTransformBuffer3D, DeterministicPhysicsAabb3D, 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, DeterministicVoxelCompoundSplitResult3D, 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';

package/dist/creator.js

@@ -10,7 +10,7 @@ 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, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D, } from './physics3d-voxel.js';
+export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D, splitDeterministicVoxelCompoundCollider3D, } from './physics3d-voxel.js';
 export { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { stepDeterministicVehicle3D } from './physics3d-vehicle.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, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D } from './physics3d-voxel.js';
+export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D, splitDeterministicVoxelCompoundCollider3D } from './physics3d-voxel.js';
 export { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { runDeterministicPhysics3DDestructionCert } from './physics3d-destruction-cert.js';
@@ -78,8 +78,8 @@ 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, 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 { DeterministicContactCacheEntry3D, DeterministicFluidVolume3D, DeterministicJointCacheEntry3D, DeterministicKinematicPose3D, DeterministicKinematicTransformBuffer3D, DeterministicPhysicsAabb3D, 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, DeterministicVoxelCompoundSplitResult3D, 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';
 export type { DeterministicAuthoritativeBodyProxy3D, DeterministicCosmeticPhysicsBody3D, DeterministicCosmeticPhysicsStepOptions3D, DeterministicCosmeticPhysicsStepResult3D, DeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.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, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D } from './physics3d-voxel.js';
+export { carveDeterministicVoxelChunk3D, cookDeterministicVoxelChunkCollider3D, cookDeterministicVoxelSubregion3D, recookDeterministicVoxelSubregion3D, raycastDeterministicVoxelChunk3D, splitDeterministicVoxelChunk3D, splitDeterministicVoxelCompoundCollider3D } 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,15 @@ export type DeterministicPhysicsJoint3D = {
     readonly targetZ: number;
     readonly maxForce: number;
     readonly damping?: number;
+    readonly linearHertz?: number;
+    readonly linearDampingRatio?: number;
+    readonly targetRotation?: Quat3D;
+    readonly maxTorque?: number;
+    readonly angularDamping?: number;
+    readonly angularHertz?: number;
+    readonly angularDampingRatio?: 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

@@ -626,6 +626,29 @@ function springJoint(joint, aIndex, bIndex, warm) {
         },
     };
 }
+/**
+ * Box3D / Box2D v3 b3MakeSoft coefficient scheme:
+ * Translates (frequencyHz, dampingRatio, dt) into mass-independent constraint softness coefficients:
+ * biasRate = omega / a1, massScale = a2 / (1 + a2), impulseScale = 1 / (1 + a2).
+ * Unconditionally stable: biasRate * dt = (dt * omega) / (2 * damping + dt * omega) <= 1.0 always.
+ */
+function makeSoft(hertz, dampingRatio, dt) {
+    if (hertz <= 0) {
+        return { biasRate: 0, massScale: 0, impulseScale: 0 };
+    }
+    const omega = TWO_PI * hertz;
+    const a1 = 2 * Math.max(0, dampingRatio) + dt * omega;
+    if (a1 <= 1e-18) {
+        return { biasRate: 0, massScale: 0, impulseScale: 0 };
+    }
+    const a2 = dt * omega * a1;
+    const a3 = 1 / (1 + a2);
+    return {
+        biasRate: omega / a1,
+        massScale: a2 * a3,
+        impulseScale: a3,
+    };
+}
 function grabJoint(joint, bodyIndex, warm) {
     const state = {
         impulse: warm ? { x: warm.impulseX, y: warm.impulseY, z: warm.impulseZ } : { x: 0, y: 0, z: 0 },
@@ -636,36 +659,139 @@ function grabJoint(joint, bodyIndex, warm) {
     };
     let r = { x: 0, y: 0, z: 0 };
     let kInv = [0, 0, 0, 0, 0, 0, 0, 0, 0];
-    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 linearHertz = joint.linearHertz ?? 5.0;
+    const linearDampingRatio = joint.linearDampingRatio ?? joint.damping ?? 1.0;
+    const angularHertz = joint.angularHertz ?? 5.0;
+    const angularDampingRatio = joint.angularDampingRatio ?? joint.angularDamping ?? joint.damping ?? 1.0;
+    let linBiasRate = 0;
+    let linMassScale = 1;
+    let linImpulseScale = 0;
+    let angBiasVel = { x: 0, y: 0, z: 0 };
+    let angMassScale = 1;
+    let angImpulseScale = 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);
             const ang = mat3Multiply(mat3Multiply(skewR, ctx.invInertia[bodyIndex]), skewR);
             kInv = invertMat3(mat3Sub(linear, ang));
-            const damping = joint.damping ?? 1;
-            desiredVel = scaleVec3(subVec3(target, worldAnchor), damping / ctx.dt);
+            const linSoft = (joint.linearHertz !== undefined || joint.linearDampingRatio !== undefined)
+                ? makeSoft(linearHertz, linearDampingRatio, ctx.dt)
+                : undefined;
+            linBiasRate = linSoft ? linSoft.biasRate : (joint.damping ?? 1) / ctx.dt;
+            linMassScale = linSoft ? linSoft.massScale : 1.0;
+            linImpulseScale = linSoft ? linSoft.impulseScale : 0;
             ctx.applyToBody(bodyIndex, r, state.impulse);
+            if (targetRotation !== undefined) {
+                const angSoft = makeSoft(angularHertz, angularDampingRatio, ctx.dt);
+                angMassScale = angSoft.massScale;
+                angImpulseScale = angSoft.impulseScale;
+                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,
+                };
+                // Box3D soft constraint bias rate: biasRate * dt <= 1.0 always, preventing single-step overshoot
+                angBiasVel = clampMagnitude(scaleVec3(error, -angSoft.biasRate), 10.0);
+                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 worldAnchor = addVec3(body.c, r);
+            const posError = subVec3(target, worldAnchor);
+            const desiredVel = scaleVec3(posError, linBiasRate);
             const currentVel = addVec3(body.v, crossVec3(body.w, r));
-            const dImpulse = mulMat3Vec(kInv, subVec3(desiredVel, currentVel));
+            const deltaV = subVec3(desiredVel, currentVel);
+            const rawImpulse = mulMat3Vec(kInv, deltaV);
+            const dImpulse = subVec3(scaleVec3(rawImpulse, linMassScale), scaleVec3(state.impulse, linImpulseScale));
             const target2 = addVec3(state.impulse, dImpulse);
             const clamped = clampMagnitude(target2, maxImpulse * ctx.dt);
             const applied = subVec3(clamped, state.impulse);
             state.impulse = clamped;
             ctx.applyToBody(bodyIndex, r, applied);
+            if (targetRotation !== undefined && maxTorque > 0) {
+                const deltaW = subVec3(angBiasVel, body.w);
+                const rawTorque = angMassMat !== undefined
+                    ? mulMat3Vec(angMassMat, deltaW)
+                    : { x: deltaW.x * angMassDiag.x, y: deltaW.y * angMassDiag.y, z: deltaW.z * angMassDiag.z };
+                const dTorque = subVec3(scaleVec3(rawTorque, angMassScale), scaleVec3(torqueImpulse, angImpulseScale));
+                const targetTorque = addVec3(torqueImpulse, dTorque);
+                const clampedTorque = clampMagnitude(targetTorque, maxTorque * ctx.dt);
+                let appliedTorque = subVec3(clampedTorque, torqueImpulse);
+                // Safeguard angular acceleration: clamp appliedTorque so Delta omega <= 0.5 rad/substep
+                const dw = mulMat3Vec(ctx.invInertia[bodyIndex], appliedTorque);
+                const dwLen = solverSqrt(dotVec3(dw, dw));
+                if (dwLen > 0.5) {
+                    appliedTorque = scaleVec3(appliedTorque, 0.5 / dwLen);
+                }
+                torqueImpulse = addVec3(torqueImpulse, appliedTorque);
+                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 +813,45 @@ 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.linearHertz !== undefined && (!Number.isFinite(joint.linearHertz) || joint.linearHertz <= 0)) {
+            throw new Error(`physics3d joint ${joint.id}: linearHertz must be positive`);
+        }
+        if (joint.linearDampingRatio !== undefined && (!Number.isFinite(joint.linearDampingRatio) || joint.linearDampingRatio < 0)) {
+            throw new Error(`physics3d joint ${joint.id}: linearDampingRatio 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.angularHertz !== undefined && (!Number.isFinite(joint.angularHertz) || joint.angularHertz <= 0)) {
+            throw new Error(`physics3d joint ${joint.id}: angularHertz must be positive`);
+        }
+        if (joint.angularDampingRatio !== undefined && (!Number.isFinite(joint.angularDampingRatio) || joint.angularDampingRatio < 0)) {
+            throw new Error(`physics3d joint ${joint.id}: angularDampingRatio 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-shared.js

@@ -141,6 +141,9 @@ export function worldInvInertia(rot, invI) {
  * identity so no NaN reaches state.
  */
 export function integrateQuat(q, w, dt) {
+    if (!Number.isFinite(dt) || dt <= 0 || !Number.isFinite(w.x) || !Number.isFinite(w.y) || !Number.isFinite(w.z)) {
+        return normalizeQuat(q);
+    }
     const hx = w.x * 0.5 * dt;
     const hy = w.y * 0.5 * dt;
     const hz = w.z * 0.5 * dt;
@@ -148,18 +151,34 @@ export function integrateQuat(q, w, dt) {
     const ny = q.y + (hy * q.w + hz * q.x - hx * q.z);
     const nz = q.z + (hz * q.w + hx * q.y - hy * q.x);
     const nw = q.w + (-hx * q.x - hy * q.y - hz * q.z);
-    const length = solverSqrt(nx * nx + ny * ny + nz * nz + nw * nw);
-    if (length === 0) {
-        return { x: 0, y: 0, z: 0, w: 1 };
+    const maxComp = Math.max(Math.abs(nx), Math.abs(ny), Math.abs(nz), Math.abs(nw));
+    if (!Number.isFinite(maxComp) || maxComp === 0) {
+        return normalizeQuat(q);
+    }
+    const sx = nx / maxComp;
+    const sy = ny / maxComp;
+    const sz = nz / maxComp;
+    const sw = nw / maxComp;
+    const length = solverSqrt(sx * sx + sy * sy + sz * sz + sw * sw);
+    if (!Number.isFinite(length) || length === 0) {
+        return normalizeQuat(q);
     }
-    return { x: nx / length, y: ny / length, z: nz / length, w: nw / length };
+    return { x: sx / length, y: sy / length, z: sz / length, w: sw / length };
 }
 export function normalizeQuat(q) {
-    const length = solverSqrt(q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w);
-    if (length === 0) {
+    const maxComp = Math.max(Math.abs(q.x), Math.abs(q.y), Math.abs(q.z), Math.abs(q.w));
+    if (!Number.isFinite(maxComp) || maxComp === 0) {
+        return { x: 0, y: 0, z: 0, w: 1 };
+    }
+    const sx = q.x / maxComp;
+    const sy = q.y / maxComp;
+    const sz = q.z / maxComp;
+    const sw = q.w / maxComp;
+    const length = solverSqrt(sx * sx + sy * sy + sz * sz + sw * sw);
+    if (!Number.isFinite(length) || length === 0) {
         return { x: 0, y: 0, z: 0, w: 1 };
     }
-    return { x: q.x / length, y: q.y / length, z: q.z / length, w: q.w / length };
+    return { x: sx / length, y: sy / length, z: sz / length, w: sw / length };
 }
 export function quatConjugate(q) {
     return { x: -q.x, y: -q.y, z: -q.z, w: q.w };

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). */
@@ -247,6 +249,24 @@ export interface SolverWarmPoint {
     readonly tangentImpulse1: number;
     readonly tangentImpulse2: number;
 }
+export interface DeterministicPhysicsAabb3D {
+    readonly minX: number;
+    readonly minY: number;
+    readonly minZ: number;
+    readonly maxX: number;
+    readonly maxY: number;
+    readonly maxZ: number;
+}
+export interface DeterministicFluidVolume3D {
+    readonly id: string;
+    readonly bounds: DeterministicPhysicsAabb3D;
+    readonly density?: number;
+    readonly linearDrag?: number;
+    readonly angularDrag?: number;
+    readonly flowVelocity?: Point3D;
+    readonly layer?: number;
+    readonly mask?: number;
+}
 export interface SolverStepOptions {
     readonly dt: number;
     readonly gravityY: number;
@@ -260,6 +280,7 @@ export interface SolverStepOptions {
     readonly joints?: readonly SolverJointSolve[];
     /** Packed index pairs (min * WARM_KEY_BASE + max) whose contacts are suppressed (jointed pairs). */
     readonly noCollidePairs?: ReadonlySet<number>;
+    readonly fluids?: readonly DeterministicFluidVolume3D[];
 }
 export declare function combinedContactFriction(frictionA10: number, frictionB10: number): number;
 export interface SolverContactImpulse {

package/dist/physics3d-solver.js

@@ -1435,6 +1435,286 @@ function takeConstraint() {
     constraintPool.high += 1;
     return slot;
 }
+function computeSubmergence(b, bounds) {
+    let points = [];
+    let volume = 0;
+    let yMin = b.p.y;
+    let yMax = b.p.y;
+    let xMin = b.p.x;
+    let xMax = b.p.x;
+    let zMin = b.p.z;
+    let zMax = b.p.z;
+    const shape = b.shape;
+    if (shape.kind === 'box') {
+        const h = shape.half;
+        volume = 8 * h.x * h.y * h.z;
+        const corners = [
+            { x: -h.x, y: -h.y, z: -h.z },
+            { x: h.x, y: -h.y, z: -h.z },
+            { x: -h.x, y: h.y, z: -h.z },
+            { x: h.x, y: h.y, z: -h.z },
+            { x: -h.x, y: -h.y, z: h.z },
+            { x: h.x, y: -h.y, z: h.z },
+            { x: -h.x, y: h.y, z: h.z },
+            { x: h.x, y: h.y, z: h.z },
+        ];
+        points = corners.map((c) => addVec3(b.p, rotatePointByQuat(b.q, c)));
+        xMin = points[0].x;
+        xMax = points[0].x;
+        yMin = points[0].y;
+        yMax = points[0].y;
+        zMin = points[0].z;
+        zMax = points[0].z;
+        for (let i = 1; i < points.length; i += 1) {
+            const p = points[i];
+            if (p.x < xMin)
+                xMin = p.x;
+            if (p.x > xMax)
+                xMax = p.x;
+            if (p.y < yMin)
+                yMin = p.y;
+            if (p.y > yMax)
+                yMax = p.y;
+            if (p.z < zMin)
+                zMin = p.z;
+            if (p.z > zMax)
+                zMax = p.z;
+        }
+    }
+    else if (shape.kind === 'sphere') {
+        const r = shape.radius;
+        volume = (4 / 3) * Math.PI * r * r * r;
+        xMin = b.p.x - r;
+        xMax = b.p.x + r;
+        yMin = b.p.y - r;
+        yMax = b.p.y + r;
+        zMin = b.p.z - r;
+        zMax = b.p.z + r;
+        points = [b.p];
+    }
+    else if (shape.kind === 'capsule') {
+        const r = shape.radius;
+        const hh = shape.halfHeight;
+        volume = (4 / 3) * Math.PI * r * r * r + 2 * Math.PI * r * r * hh;
+        const pTop = addVec3(b.p, rotatePointByQuat(b.q, { x: 0, y: hh, z: 0 }));
+        const pBot = addVec3(b.p, rotatePointByQuat(b.q, { x: 0, y: -hh, z: 0 }));
+        xMin = Math.min(pTop.x, pBot.x) - r;
+        xMax = Math.max(pTop.x, pBot.x) + r;
+        yMin = Math.min(pTop.y, pBot.y) - r;
+        yMax = Math.max(pTop.y, pBot.y) + r;
+        zMin = Math.min(pTop.z, pBot.z) - r;
+        zMax = Math.max(pTop.z, pBot.z) + r;
+        points = [pBot, pTop];
+    }
+    else if (shape.kind === 'hull') {
+        const verts = shape.data.vertices;
+        volume = 1.0;
+        points = verts.map((v) => addVec3(b.p, rotatePointByQuat(b.q, v)));
+        if (points.length > 0) {
+            xMin = points[0].x;
+            xMax = points[0].x;
+            yMin = points[0].y;
+            yMax = points[0].y;
+            zMin = points[0].z;
+            zMax = points[0].z;
+            for (let i = 1; i < points.length; i += 1) {
+                const p = points[i];
+                if (p.x < xMin)
+                    xMin = p.x;
+                if (p.x > xMax)
+                    xMax = p.x;
+                if (p.y < yMin)
+                    yMin = p.y;
+                if (p.y > yMax)
+                    yMax = p.y;
+                if (p.z < zMin)
+                    zMin = p.z;
+                if (p.z > zMax)
+                    zMax = p.z;
+            }
+            volume = Math.max(0.001, (xMax - xMin) * (yMax - yMin) * (zMax - zMin) * 0.5);
+        }
+    }
+    else if (shape.kind === 'compound') {
+        volume = 0;
+        for (const child of shape.children) {
+            const childCenter = addVec3(b.p, rotatePointByQuat(b.q, child.offset));
+            const childQ = quatMultiply(b.q, child.q);
+            if (child.shape.kind === 'box') {
+                const h = child.shape.half;
+                volume += 8 * h.x * h.y * h.z;
+                const corners = [
+                    { x: -h.x, y: -h.y, z: -h.z },
+                    { x: h.x, y: -h.y, z: -h.z },
+                    { x: -h.x, y: h.y, z: -h.z },
+                    { x: h.x, y: h.y, z: -h.z },
+                    { x: -h.x, y: -h.y, z: h.z },
+                    { x: h.x, y: -h.y, z: h.z },
+                    { x: -h.x, y: h.y, z: h.z },
+                    { x: h.x, y: h.y, z: h.z },
+                ];
+                points.push(...corners.map((c) => addVec3(childCenter, rotatePointByQuat(childQ, c))));
+            }
+            else if (child.shape.kind === 'sphere') {
+                const r = child.shape.radius;
+                volume += (4 / 3) * Math.PI * r * r * r;
+                points.push(childCenter, { x: childCenter.x - r, y: childCenter.y, z: childCenter.z }, { x: childCenter.x + r, y: childCenter.y, z: childCenter.z }, { x: childCenter.x, y: childCenter.y - r, z: childCenter.z }, { x: childCenter.x, y: childCenter.y + r, z: childCenter.z }, { x: childCenter.x, y: childCenter.y, z: childCenter.z - r }, { x: childCenter.x, y: childCenter.y, z: childCenter.z + r });
+            }
+            else if (child.shape.kind === 'capsule') {
+                const r = child.shape.radius;
+                const hh = child.shape.halfHeight;
+                volume += (4 / 3) * Math.PI * r * r * r + 2 * Math.PI * r * r * hh;
+                const capTop = addVec3(childCenter, rotatePointByQuat(childQ, { x: 0, y: hh, z: 0 }));
+                const capBot = addVec3(childCenter, rotatePointByQuat(childQ, { x: 0, y: -hh, z: 0 }));
+                points.push(capTop, capBot, { x: capTop.x - r, y: capTop.y, z: capTop.z }, { x: capTop.x + r, y: capTop.y, z: capTop.z }, { x: capTop.x, y: capTop.y - r, z: capTop.z }, { x: capTop.x, y: capTop.y + r, z: capTop.z }, { x: capTop.x, y: capTop.y, z: capTop.z - r }, { x: capTop.x, y: capTop.y, z: capTop.z + r }, { x: capBot.x - r, y: capBot.y, z: capBot.z }, { x: capBot.x + r, y: capBot.y, z: capBot.z }, { x: capBot.x, y: capBot.y - r, z: capBot.z }, { x: capBot.x, y: capBot.y + r, z: capBot.z }, { x: capBot.x, y: capBot.y, z: capBot.z - r }, { x: capBot.x, y: capBot.y, z: capBot.z + r });
+            }
+            else if (child.shape.kind === 'hull') {
+                const verts = child.shape.data.vertices;
+                const hullPoints = verts.map((v) => addVec3(childCenter, rotatePointByQuat(childQ, v)));
+                points.push(...hullPoints);
+                if (hullPoints.length > 0) {
+                    let hxMin = hullPoints[0].x;
+                    let hxMax = hullPoints[0].x;
+                    let hyMin = hullPoints[0].y;
+                    let hyMax = hullPoints[0].y;
+                    let hzMin = hullPoints[0].z;
+                    let hzMax = hullPoints[0].z;
+                    for (let i = 1; i < hullPoints.length; i += 1) {
+                        const p = hullPoints[i];
+                        if (p.x < hxMin)
+                            hxMin = p.x;
+                        if (p.x > hxMax)
+                            hxMax = p.x;
+                        if (p.y < hyMin)
+                            hyMin = p.y;
+                        if (p.y > hyMax)
+                            hyMax = p.y;
+                        if (p.z < hzMin)
+                            hzMin = p.z;
+                        if (p.z > hzMax)
+                            hzMax = p.z;
+                    }
+                    volume += Math.max(0.001, (hxMax - hxMin) * (hyMax - hyMin) * (hzMax - hzMin) * 0.5);
+                }
+            }
+        }
+        if (points.length > 0) {
+            xMin = points[0].x;
+            xMax = points[0].x;
+            yMin = points[0].y;
+            yMax = points[0].y;
+            zMin = points[0].z;
+            zMax = points[0].z;
+            for (let i = 1; i < points.length; i += 1) {
+                const p = points[i];
+                if (p.x < xMin)
+                    xMin = p.x;
+                if (p.x > xMax)
+                    xMax = p.x;
+                if (p.y < yMin)
+                    yMin = p.y;
+                if (p.y > yMax)
+                    yMax = p.y;
+                if (p.z < zMin)
+                    zMin = p.z;
+                if (p.z > zMax)
+                    zMax = p.z;
+            }
+        }
+    }
+    if (xMax < bounds.minX || xMin > bounds.maxX || zMax < bounds.minZ || zMin > bounds.maxZ) {
+        return undefined;
+    }
+    if (yMax <= bounds.minY || yMin >= bounds.maxY) {
+        return undefined;
+    }
+    const yBottom = Math.max(bounds.minY, yMin);
+    const yTop = Math.min(bounds.maxY, yMax);
+    const span = Math.max(1e-6, yMax - yMin);
+    const fraction = Math.min(1.0, Math.max(0.0, (yTop - yBottom) / span));
+    let cbX = b.c.x;
+    let cbY = (yBottom + yTop) / 2;
+    let cbZ = b.c.z;
+    if (fraction >= 1.0) {
+        // Fully submerged: center of buoyancy coincides with body centroid (no phantom righting torque)
+        cbX = b.c.x;
+        cbY = b.c.y;
+        cbZ = b.c.z;
+    }
+    else {
+        // Partially submerged: depth-weighted average of submerged sample points relative to fluid surface
+        let sumWeight = 0;
+        let sumX = 0;
+        let sumZ = 0;
+        const surfaceY = bounds.maxY;
+        for (const p of points) {
+            if (p.y < surfaceY) {
+                const depth = surfaceY - p.y;
+                sumWeight += depth;
+                sumX += p.x * depth;
+                sumZ += p.z * depth;
+            }
+        }
+        if (sumWeight > 1e-9) {
+            cbX = sumX / sumWeight;
+            cbZ = sumZ / sumWeight;
+        }
+    }
+    return {
+        fraction,
+        centerOfBuoyancy: { x: cbX, y: cbY, z: cbZ },
+        displacedVolume: volume,
+    };
+}
+function applyFluidForces(bodies, invInertia, fluids, gravityY, dt) {
+    for (let index = 0; index < bodies.length; index += 1) {
+        const b = bodies[index];
+        if (!solid(b) || !b.isDynamic) {
+            continue;
+        }
+        for (const fluid of fluids) {
+            if (fluid.layer !== undefined && fluid.mask !== undefined) {
+                if ((fluid.mask & b.layer) === 0 || (b.mask & fluid.layer) === 0) {
+                    continue;
+                }
+            }
+            const submergence = computeSubmergence(b, fluid.bounds);
+            if (submergence === undefined || submergence.fraction <= 0) {
+                continue;
+            }
+            const { fraction, centerOfBuoyancy, displacedVolume } = submergence;
+            const fluidDensity = fluid.density ?? 1.0;
+            const linearDragCoeff = fluid.linearDrag ?? 1.0;
+            const angularDragCoeff = fluid.angularDrag ?? 0.5;
+            const flowVel = fluid.flowVelocity ?? ZERO;
+            const effG = gravityY * b.gravityScale;
+            if (Math.abs(effG) > 0 && b.invMassVec.y > 0) {
+                // Buoyant force opposes effective gravity
+                const buoyantForceY = -effG * fluidDensity * displacedVolume * fraction;
+                const buoyantAccelY = buoyantForceY * b.invMassVec.y;
+                b.v.y += buoyantAccelY * dt;
+                const rB = subVec3(centerOfBuoyancy, b.c);
+                const torque = {
+                    x: -rB.z * buoyantForceY,
+                    y: 0,
+                    z: rB.x * buoyantForceY,
+                };
+                const angImpulse = scaleVec3(torque, dt);
+                let dw = mulMat3Vec(invInertia[index], angImpulse);
+                const dwLen = solverSqrt(dotVec3(dw, dw));
+                if (dwLen > 0.5) {
+                    dw = scaleVec3(dw, 0.5 / dwLen);
+                }
+                b.w = addVec3(b.w, dw);
+            }
+            const vRel = subVec3(b.v, flowVel);
+            const linDragFactor = 1 / (1 + linearDragCoeff * fraction * dt);
+            b.v = addVec3(scaleVec3(vRel, linDragFactor), flowVel);
+            const angDragFactor = 1 / (1 + angularDragCoeff * fraction * dt);
+            b.w = scaleVec3(b.w, angDragFactor);
+        }
+    }
+}
 /** Runs one deterministic rigid-body step in place over `bodies`. */
 export function solveRigidStep(bodies, options) {
     /* istanbul ignore next -- worlds are validated far below this bound; guards the packed warm-cache key from silent index collisions. */
@@ -1589,6 +1869,25 @@ export function solveRigidStep(bodies, options) {
             b.lowVelFrames = 0;
         }
     }
+    if (options.fluids && options.fluids.length > 0) {
+        for (const b of bodies) {
+            if (b.isDynamic && b.sleeping) {
+                for (const f of options.fluids) {
+                    if (f.layer !== undefined && f.mask !== undefined) {
+                        if ((f.mask & b.layer) === 0 || (b.mask & f.layer) === 0) {
+                            continue;
+                        }
+                    }
+                    const sub = computeSubmergence(b, f.bounds);
+                    if (sub && sub.fraction > 0) {
+                        b.sleeping = false;
+                        b.lowVelFrames = 0;
+                        break;
+                    }
+                }
+            }
+        }
+    }
     for (const m of manifolds) {
         wakeIfContacted(bodies[m.a], bodies[m.b]);
         wakeIfContacted(bodies[m.b], bodies[m.a]);
@@ -1685,6 +1984,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)) {
@@ -1706,6 +2012,9 @@ export function solveRigidStep(bodies, options) {
                 b.v.y = b.v.y + options.gravityY * b.gravityScale * h;
             }
         }
+        if (options.fluids && options.fluids.length > 0) {
+            applyFluidForces(bodies, invInertia, options.fluids, options.gravityY, h);
+        }
         for (const joint of joints) {
             joint.prepare(jointCtx);
         }

package/dist/physics3d-voxel.d.ts

@@ -116,3 +116,16 @@ export interface SplitDeterministicVoxelChunkOptions3D {
  * occupied count, and whether any of its voxels touch the specified anchor faces.
  */
 export declare function splitDeterministicVoxelChunk3D(chunk: DeterministicVoxelChunk3D, options?: SplitDeterministicVoxelChunkOptions3D): readonly VoxelSubChunk3D[];
+export interface DeterministicVoxelCompoundSplitResult3D {
+    readonly compounds: readonly (DeterministicVoxelCompoundShape3D | undefined)[];
+    readonly preservedBoxesCount: number;
+    readonly recookedBoxesCount: number;
+}
+/**
+ * Incrementally slices a parent compound collider across partitioned sub-chunks
+ * from {@link splitDeterministicVoxelChunk3D}.
+ * Preserves intact child box colliders that fall entirely within a sub-chunk's volume
+ * without re-cooking, rebasing their offset coordinates to sub-chunk local space.
+ * Only re-cooks severed/split boundary voxels that were not covered by preserved boxes.
+ */
+export declare function splitDeterministicVoxelCompoundCollider3D(parentCompound: DeterministicVoxelCompoundShape3D, subChunks: readonly VoxelSubChunk3D[]): DeterministicVoxelCompoundSplitResult3D;

package/dist/physics3d-voxel.js

@@ -693,3 +693,127 @@ export function splitDeterministicVoxelChunk3D(chunk, options) {
     });
     return subChunks;
 }
+/**
+ * Incrementally slices a parent compound collider across partitioned sub-chunks
+ * from {@link splitDeterministicVoxelChunk3D}.
+ * Preserves intact child box colliders that fall entirely within a sub-chunk's volume
+ * without re-cooking, rebasing their offset coordinates to sub-chunk local space.
+ * Only re-cooks severed/split boundary voxels that were not covered by preserved boxes.
+ */
+export function splitDeterministicVoxelCompoundCollider3D(parentCompound, subChunks) {
+    if (subChunks.length === 0) {
+        return {
+            compounds: [],
+            preservedBoxesCount: 0,
+            recookedBoxesCount: 0,
+        };
+    }
+    let totalPreservedBoxes = 0;
+    let totalRecookedBoxes = 0;
+    const compounds = [];
+    for (const subChunk of subChunks) {
+        const chunk = subChunk.chunk;
+        const cellSize = chunk.cellSize;
+        const scX = subChunk.offsetCells.x;
+        const scY = subChunk.offsetCells.y;
+        const scZ = subChunk.offsetCells.z;
+        const maxBoundX = scX + chunk.dimX - 1;
+        const maxBoundY = scY + chunk.dimY - 1;
+        const maxBoundZ = scZ + chunk.dimZ - 1;
+        const totalCells = chunk.dimX * chunk.dimY * chunk.dimZ;
+        const coveredInSubChunk = new Uint8Array(totalCells);
+        const preservedChildren = [];
+        for (const child of parentCompound.children) {
+            if (child.shape.type !== 'box') {
+                continue;
+            }
+            const boxMinX = Math.round((child.offset.x - child.shape.halfX) / cellSize + 0.5);
+            const boxMaxX = Math.round((child.offset.x + child.shape.halfX) / cellSize - 0.5);
+            const boxMinY = Math.round((child.offset.y - child.shape.halfY) / cellSize + 0.5);
+            const boxMaxY = Math.round((child.offset.y + child.shape.halfY) / cellSize - 0.5);
+            const boxMinZ = Math.round((child.offset.z - child.shape.halfZ) / cellSize + 0.5);
+            const boxMaxZ = Math.round((child.offset.z + child.shape.halfZ) / cellSize - 0.5);
+            if (boxMinX >= scX && boxMaxX <= maxBoundX &&
+                boxMinY >= scY && boxMaxY <= maxBoundY &&
+                boxMinZ >= scZ && boxMaxZ <= maxBoundZ) {
+                let isIntact = true;
+                for (let bz = boxMinZ; bz <= boxMaxZ && isIntact; bz++) {
+                    for (let by = boxMinY; by <= boxMaxY && isIntact; by++) {
+                        for (let bx = boxMinX; bx <= boxMaxX; bx++) {
+                            const lx = bx - scX;
+                            const ly = by - scY;
+                            const lz = bz - scZ;
+                            const idx = lx + chunk.dimX * (ly + chunk.dimY * lz);
+                            if (chunk.occupancy[idx] === 0) {
+                                isIntact = false;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (isIntact) {
+                    for (let bz = boxMinZ; bz <= boxMaxZ; bz++) {
+                        for (let by = boxMinY; by <= boxMaxY; by++) {
+                            for (let bx = boxMinX; bx <= boxMaxX; bx++) {
+                                const lx = bx - scX;
+                                const ly = by - scY;
+                                const lz = bz - scZ;
+                                const idx = lx + chunk.dimX * (ly + chunk.dimY * lz);
+                                coveredInSubChunk[idx] = 1;
+                            }
+                        }
+                    }
+                    preservedChildren.push({
+                        shape: child.shape,
+                        offset: {
+                            x: child.offset.x - scX * cellSize,
+                            y: child.offset.y - scY * cellSize,
+                            z: child.offset.z - scZ * cellSize,
+                        },
+                        ...(child.quarterTurns !== undefined ? { quarterTurns: child.quarterTurns } : {}),
+                    });
+                    totalPreservedBoxes += 1;
+                }
+            }
+        }
+        let uncoveredCount = 0;
+        for (let i = 0; i < totalCells; i++) {
+            if (chunk.occupancy[i] !== 0 && coveredInSubChunk[i] === 0) {
+                uncoveredCount += 1;
+            }
+        }
+        let recookedChildren = [];
+        if (uncoveredCount > 0) {
+            const uncoveredOccupancy = new Uint8Array(totalCells);
+            for (let i = 0; i < totalCells; i++) {
+                if (chunk.occupancy[i] !== 0 && coveredInSubChunk[i] === 0) {
+                    uncoveredOccupancy[i] = 1;
+                }
+            }
+            const uncoveredChunk = {
+                dimX: chunk.dimX,
+                dimY: chunk.dimY,
+                dimZ: chunk.dimZ,
+                cellSize: chunk.cellSize,
+                occupancy: uncoveredOccupancy,
+            };
+            recookedChildren = cookSubregionBoxes(uncoveredChunk, 0, 0, 0, chunk.dimX - 1, chunk.dimY - 1, chunk.dimZ - 1);
+            totalRecookedBoxes += recookedChildren.length;
+        }
+        const finalChildren = [...preservedChildren, ...recookedChildren];
+        if (finalChildren.length === 0) {
+            compounds.push(undefined);
+        }
+        else {
+            compounds.push({
+                type: 'compound',
+                children: finalChildren,
+            });
+        }
+    }
+    return {
+        compounds,
+        preservedBoxesCount: totalPreservedBoxes,
+        recookedBoxesCount: totalRecookedBoxes,
+    };
+}

package/dist/physics3d.d.ts

@@ -1,5 +1,7 @@
 import { type DeterministicPhysicsMaterial } from './deterministic-primitives.js';
 import { type Point3D } from './physics3d-shared.js';
+import { type DeterministicPhysicsAabb3D, type DeterministicFluidVolume3D } from './physics3d-solver.js';
+export type { DeterministicPhysicsAabb3D, DeterministicFluidVolume3D };
 import { type DeterministicPhysicsJoint3D } from './physics3d-joints.js';
 export type DeterministicPhysicsPrimitiveShape3D = {
     readonly type: 'box';
@@ -364,6 +366,8 @@ export interface DeterministicPhysicsStepResult3D {
     readonly contacts: readonly DeterministicPhysicsContactEvent3D[];
     /** Joint ids that broke this step (newly, sorted); sticky once broken. */
     readonly brokenJointIds: readonly string[];
+    /** Alias for brokenJointIds requested for ergonomics parity. */
+    readonly brokenJoints: readonly string[];
     readonly scheduledQueryResults: readonly {
         readonly id: string;
         readonly hits: readonly DeterministicPhysicsHit3D[];
@@ -480,6 +484,7 @@ export interface DeterministicPhysicsStepOptions3D {
     readonly computeChecksum?: boolean;
     readonly computeBroadphasePairs?: boolean;
     readonly pairs?: readonly (readonly [number, number])[];
+    readonly fluids?: readonly DeterministicFluidVolume3D[];
 }
 export declare function stepDeterministicPhysicsWorld3D(world: DeterministicPhysicsWorld3D, options?: DeterministicPhysicsStepOptions3D): DeterministicPhysicsStepResult3D;
 /** O(1) body lookup backed by the per-world query-index cache. */

package/dist/physics3d.js

@@ -693,7 +693,52 @@ export function setDeterministicBodyVelocity3D(world, bodyId, velocity, angularV
     });
     return { ...world, bodies: normalizeBodies(bodies, 'trusted') };
 }
+function validateFluidVolume(fluid) {
+    if (typeof fluid.id !== 'string' || fluid.id.length === 0) {
+        throw new Error('physics3d fluid: id must be a non-empty string');
+    }
+    const bounds = fluid.bounds;
+    if (!bounds || typeof bounds !== 'object') {
+        throw new Error(`physics3d fluid ${fluid.id}: bounds must be an object`);
+    }
+    const { minX, minY, minZ, maxX, maxY, maxZ } = bounds;
+    if (!Number.isFinite(minX) ||
+        !Number.isFinite(minY) ||
+        !Number.isFinite(minZ) ||
+        !Number.isFinite(maxX) ||
+        !Number.isFinite(maxY) ||
+        !Number.isFinite(maxZ)) {
+        throw new Error(`physics3d fluid ${fluid.id}: bounds must contain finite numbers`);
+    }
+    if (minX > maxX) {
+        throw new Error(`physics3d fluid ${fluid.id}: minX must not exceed maxX`);
+    }
+    if (minY > maxY) {
+        throw new Error(`physics3d fluid ${fluid.id}: minY must not exceed maxY`);
+    }
+    if (minZ > maxZ) {
+        throw new Error(`physics3d fluid ${fluid.id}: minZ must not exceed maxZ`);
+    }
+    if (fluid.density !== undefined && (!Number.isFinite(fluid.density) || fluid.density <= 0)) {
+        throw new Error(`physics3d fluid ${fluid.id}: density must be positive`);
+    }
+    if (fluid.linearDrag !== undefined && (!Number.isFinite(fluid.linearDrag) || fluid.linearDrag < 0)) {
+        throw new Error(`physics3d fluid ${fluid.id}: linearDrag must be non-negative`);
+    }
+    if (fluid.angularDrag !== undefined && (!Number.isFinite(fluid.angularDrag) || fluid.angularDrag < 0)) {
+        throw new Error(`physics3d fluid ${fluid.id}: angularDrag must be non-negative`);
+    }
+    if (fluid.flowVelocity !== undefined) {
+        const { x, y, z } = fluid.flowVelocity;
+        if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) {
+            throw new Error(`physics3d fluid ${fluid.id}: flowVelocity must be finite`);
+        }
+    }
+}
 export function stepDeterministicPhysicsWorld3D(world, options = {}) {
+    for (const fluid of options.fluids ?? []) {
+        validateFluidVolume(fluid);
+    }
     const scheduledQueries = sortScheduledQueries(options.scheduledQueries ?? []);
     const prePhysicsScheduledQueryResults = scheduledQueries
         .filter((query) => query.phase === 'pre-physics')
@@ -711,7 +756,7 @@ export function stepDeterministicPhysicsWorld3D(world, options = {}) {
     }
     const dt = options.dtTicks ?? 1;
     const gravityY = options.gravityY ?? 0;
-    const rigid = runRigidSolver(world, dt, gravityY, velocityIterations, substeps, options.joints ?? [], options.pairs);
+    const rigid = runRigidSolver(world, dt, gravityY, velocityIterations, substeps, options.joints ?? [], options.pairs, options.fluids);
     const constrained = solveConstraints3D(rigid.bodies, options.constraints ?? []);
     const solvedBodies = constrained.bodies;
     // Dynamic-involved solid-collision events come from the solver's manifolds (so
@@ -783,6 +828,7 @@ export function stepDeterministicPhysicsWorld3D(world, options = {}) {
         world: nextWorld,
         contacts: events,
         brokenJointIds: rigid.brokenJointIds,
+        brokenJoints: rigid.brokenJointIds,
         scheduledQueryResults,
         prePhysicsScheduledQueryResults,
         postPhysicsScheduledQueryResults,
@@ -2236,7 +2282,7 @@ function sleepingRebuildIsNoop(body, sb) {
         && eq(q(sb.w.x), body.angularVel.x) && eq(q(sb.w.y), body.angularVel.y) && eq(q(sb.w.z), body.angularVel.z)
         && eq(sb.lowVelFrames, body.lowVelFrames);
 }
-function runRigidSolver(world, dt, gravityY, velocityIterations, substeps, joints, pairs) {
+function runRigidSolver(world, dt, gravityY, velocityIterations, substeps, joints, pairs, fluids) {
     const source = world.bodies;
     const indexById = new Map(source.map((body, index) => [body.id, index]));
     const solverBodies = source.map((body, index) => buildSolverBody(body, index));
@@ -2281,6 +2327,7 @@ function runRigidSolver(world, dt, gravityY, velocityIterations, substeps, joint
         warm,
         pairs,
         joints: solverJoints,
+        fluids,
     });
     // Post-solve safety clamp: no fast body may end past its TOI along its motion.
     for (const [index, clamp] of fastClamps) {

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.2",
+  "version": "5.28.0-beta.4",
   "description": "Kinetix orchestration, rollback, replay, late-join, and deterministic networking for RUN.game",
   "repository": {
     "type": "git",
@@ -168,7 +168,7 @@
     "test:core": "node --expose-gc --import tsx --test --test-concurrency=1 tests/canonical.test.ts tests/canonical-portability.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/runtime-room-metadata.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/production-input-budget.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/module-seam.test.ts tests/module-contract-portability.test.ts tests/module-identity.test.ts tests/module-corpus.test.ts tests/component-model.test.ts tests/component-model-rollback.test.ts tests/component-model-integration.test.ts tests/actors-ai.test.ts tests/character-3d.test.ts tests/character-3d-certification.test.ts tests/combat-modules.test.ts tests/combat-modules-integration.test.ts tests/firearm.test.ts tests/gameplay-effects.test.ts tests/spatial-interaction.test.ts tests/stats-abilities.test.ts tests/inventory-equipment.test.ts tests/inventory-equipment-certification.test.ts tests/platformer-2d.test.ts tests/platformer-2d-certification.test.ts tests/module-promotion.test.ts tests/module-docs.test.ts tests/module-bundle-budget.test.ts tests/published-side-effects.test.ts tests/host-timing.test.ts tests/test-manifest.test.ts tests/coarse-region.test.ts tests/input-codec.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/math-profile.test.ts tests/movement3d-kcc-unit-contract.test.ts tests/movement3d-static-ground.test.ts",
     "test:sdk-contract": "node --import tsx --test tests/sdk-runtime-contract.test.ts",
     "test:soak": "tsx --test tests/runtime-soak.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-debug-wireframe.test.ts tests/physics3d-destruction-cert.test.ts tests/physics3d-forces-and-contacts.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-kinematic-poses.test.ts tests/physics3d-kinematic-transforms.test.ts tests/physics3d-mass.test.ts tests/physics3d-materials.test.ts tests/physics3d-mesh-onesided.test.ts tests/physics3d-queries-capsule-childindex.test.ts tests/physics3d-query-index.test.ts tests/physics3d-recipes.test.ts tests/physics3d-rotation-convention.test.ts tests/physics3d-shape-builders.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-carving.test.ts tests/physics3d-voxel-dda.test.ts tests/physics3d-voxel-split.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-buoyancy.test.ts tests/physics3d-ccd.test.ts tests/physics3d-coverage.test.ts tests/physics3d-debug-wireframe.test.ts tests/physics3d-destruction-cert.test.ts tests/physics3d-forces-and-contacts.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-kinematic-poses.test.ts tests/physics3d-kinematic-transforms.test.ts tests/physics3d-mass.test.ts tests/physics3d-materials.test.ts tests/physics3d-mesh-onesided.test.ts tests/physics3d-queries-capsule-childindex.test.ts tests/physics3d-query-index.test.ts tests/physics3d-recipes.test.ts tests/physics3d-rotation-convention.test.ts tests/physics3d-shape-builders.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-carving.test.ts tests/physics3d-voxel-dda.test.ts tests/physics3d-voxel-split.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",
     "build:native": "node core/scripts/build-native.mjs",
     "build:mobile-native": "node core/scripts/build-mobile-native.mjs",