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

package/dist/browser.d.ts

@@ -24,8 +24,8 @@ export { createNetworkedSyncplayClient, prepareNetworkedSyncplayTransport } from
 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 { 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 } from './physics3d-voxel.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 { 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, DeterministicPhysicsHit3D, DeterministicPhysicsHullShape3D, DeterministicPhysicsImpulseApplication3D, DeterministicPhysicsOverlapQuery3D, DeterministicPhysicsPrimitiveShape3D, DeterministicPhysicsQuaternion3D, DeterministicPhysicsQueryOptions3D, DeterministicPhysicsRaycastQuery3D, DeterministicPhysicsScheduledQuery3D, DeterministicPhysicsShape3D, DeterministicPhysicsShapeCastQuery3D, DeterministicPhysicsStepResult3D, DeterministicPhysicsVec3, DeterministicPhysicsWorld3D, DeterministicPhysicsWorldEdit3D } from './physics3d.js';
-export type { DeterministicVoxelChunk3D, DeterministicVoxelCompoundShape3D, DeterministicVoxelRayHit3D, VoxelCarveRegion3D } from './physics3d-voxel.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';
 export type { DeterministicPhysicsJoint3D } from './physics3d-joints.js';

package/dist/browser.js

@@ -25,8 +25,8 @@ export { createNetworkedSyncplayClient, prepareNetworkedSyncplayTransport } from
 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 { 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 } from './physics3d-voxel.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 { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { createDeterministicCosmeticPhysicsWorld3D, setDeterministicCosmeticPhysicsAuthoritativeBodyProxies3D, stepDeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.js';

package/dist/creator.d.ts

@@ -12,14 +12,16 @@ export type { RecordedChecksum, RecordedCommandFrame, RecordedDebugEvent, Record
 export type { ReplayRuntimeFactory, ReplayVerificationConfig, ReplayVerificationExecution } from './replay.js';
 export type { SyncplaySession, SyncplaySessionPolicy } from './sdk-session.js';
 export type { InstantReplayInputFrame, InstantReplayResult, InstantReplayRunner, InstantReplayRunnerOptions, InstantReplayRunOptions, RunInstantReplayOptions, } from './instant-replay.js';
-export { applyDeterministicImpulse3D, applyDeterministicImpulses3D, applyDeterministicWorldEdit3D, contactDetailsDeterministicPhysics3D, 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, } from './physics3d-voxel.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 { 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, DeterministicPhysicsHit3D, DeterministicPhysicsHullShape3D, DeterministicPhysicsImpulseApplication3D, DeterministicPhysicsOverlapQuery3D, DeterministicPhysicsPrimitiveShape3D, DeterministicPhysicsQuaternion3D, DeterministicPhysicsQueryOptions3D, DeterministicPhysicsRaycastQuery3D, DeterministicPhysicsScheduledQuery3D, DeterministicPhysicsShape3D, DeterministicPhysicsShapeCastQuery3D, DeterministicPhysicsStepResult3D, DeterministicPhysicsVec3, DeterministicPhysicsWorld3D, DeterministicPhysicsWorldEdit3D, } from './physics3d.js';
-export type { DeterministicVoxelChunk3D, DeterministicVoxelCompoundShape3D, DeterministicVoxelRayHit3D, VoxelCarveRegion3D, } from './physics3d-voxel.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

@@ -9,8 +9,9 @@ export { runSyncplaySynctest } from './synctest.js';
 // create/step/edit, impulses, queries, vehicles, and voxel-chunk collider
 // 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 { 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, } from './physics3d-voxel.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 { 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

@@ -27,8 +27,8 @@ export { createNetworkedSyncplayClient, prepareNetworkedSyncplayTransport } from
 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 { 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 } from './physics3d-voxel.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 { 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, DeterministicPhysicsHit3D, DeterministicPhysicsHullShape3D, DeterministicPhysicsImpulseApplication3D, DeterministicPhysicsOverlapQuery3D, DeterministicPhysicsPrimitiveShape3D, DeterministicPhysicsQuaternion3D, DeterministicPhysicsQueryOptions3D, DeterministicPhysicsRaycastQuery3D, DeterministicPhysicsScheduledQuery3D, DeterministicPhysicsShape3D, DeterministicPhysicsShapeCastQuery3D, DeterministicPhysicsStepResult3D, DeterministicPhysicsVec3, DeterministicPhysicsWorld3D, DeterministicPhysicsWorldEdit3D } from './physics3d.js';
-export type { DeterministicVoxelChunk3D, DeterministicVoxelCompoundShape3D, DeterministicVoxelRayHit3D, VoxelCarveRegion3D } from './physics3d-voxel.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';
 export type { DeterministicAuthoritativeBodyProxy3D, DeterministicCosmeticPhysicsBody3D, DeterministicCosmeticPhysicsStepOptions3D, DeterministicCosmeticPhysicsStepResult3D, DeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.js';

package/dist/index.js

@@ -28,8 +28,8 @@ export { createNetworkedSyncplayClient, prepareNetworkedSyncplayTransport } from
 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 { 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 } from './physics3d-voxel.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 { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { runDeterministicPhysics3DDestructionCert } from './physics3d-destruction-cert.js';

package/dist/physics3d-destruction-cert.js

@@ -87,7 +87,8 @@ function splitChunk(chunk) {
                     const sx = axis === 'x' ? x + from : x;
                     const sy = axis === 'y' ? y + from : y;
                     const sz = axis === 'z' ? z + from : z;
-                    occupancy[x + dimX * (y + dimY * z)] = chunk.occupancy[sx + chunk.dimX * (sy + chunk.dimY * sz)];
+                    const val = chunk.occupancy[sx + chunk.dimX * (sy + chunk.dimY * sz)];
+                    occupancy[x + dimX * (y + dimY * z)] = (val !== undefined && val !== 0) ? 1 : 0;
                 }
             }
         }
@@ -96,7 +97,13 @@ function splitChunk(chunk) {
     return { lower: slice(0, cut), upper: slice(cut, dims[axis]), axis, offset: cut * chunk.cellSize };
 }
 function occupiedCount(chunk) {
-    return chunk.occupancy.reduce((sum, cell) => sum + (cell !== 0 ? 1 : 0), 0);
+    let count = 0;
+    for (let i = 0; i < chunk.occupancy.length; i += 1) {
+        if (chunk.occupancy[i] !== 0) {
+            count += 1;
+        }
+    }
+    return count;
 }
 export function runDeterministicPhysics3DDestructionCert(options = {}) {
     const chunks = options.chunks ?? 64;

package/dist/physics3d-voxel.d.ts

@@ -1,4 +1,5 @@
 import type { DeterministicPhysicsRaycastQuery3D, DeterministicPhysicsShape3D } from './physics3d.js';
+export type VoxelOccupancy3D = readonly (0 | 1)[] | Uint8Array;
 export interface DeterministicVoxelChunk3D {
     readonly dimX: number;
     readonly dimY: number;
@@ -6,7 +7,7 @@ export interface DeterministicVoxelChunk3D {
     /** Edge length of one voxel in world units. Voxel (x,y,z) centers at (x·cellSize, y·cellSize, z·cellSize) in body-local space. */
     readonly cellSize: number;
     /** Row-major occupancy: occupancy[x + dimX * (y + dimY * z)]; non-zero = solid. */
-    readonly occupancy: readonly (0 | 1)[];
+    readonly occupancy: VoxelOccupancy3D;
 }
 export interface DeterministicVoxelRayHit3D {
     readonly hit: boolean;
@@ -40,7 +41,8 @@ export declare function raycastDeterministicVoxelChunk3D(chunk: DeterministicVox
  * of the occupancy grid.
  */
 export declare function cookDeterministicVoxelChunkCollider3D(chunk: DeterministicVoxelChunk3D): DeterministicVoxelCompoundShape3D;
-export interface VoxelCarveRegion3D {
+export interface VoxelBoxCarveRegion3D {
+    readonly type?: 'box';
     readonly minX: number;
     readonly minY: number;
     readonly minZ: number;
@@ -49,9 +51,29 @@ export interface VoxelCarveRegion3D {
     readonly maxZ: number;
     readonly operation: 'carve' | 'fill';
 }
+export interface VoxelSphereCarveRegion3D {
+    readonly type: 'sphere';
+    readonly centerX: number;
+    readonly centerY: number;
+    readonly centerZ: number;
+    readonly radius: number;
+    readonly operation: 'carve' | 'fill';
+}
+export interface VoxelCapsuleCarveRegion3D {
+    readonly type: 'capsule';
+    readonly x0: number;
+    readonly y0: number;
+    readonly z0: number;
+    readonly x1: number;
+    readonly y1: number;
+    readonly z1: number;
+    readonly radius: number;
+    readonly operation: 'carve' | 'fill';
+}
+export type VoxelCarveRegion3D = VoxelBoxCarveRegion3D | VoxelSphereCarveRegion3D | VoxelCapsuleCarveRegion3D;
 /**
- * Carves or fills a 3D axis-aligned cell region in a voxel chunk occupancy grid.
- * Computes interval intersection with chunk dimensions, returning chunk unchanged
+ * Carves or fills a 3D region (box, sphere, or capsule) in a voxel chunk occupancy grid.
+ * Computes bounding box intersection with chunk dimensions, returning chunk unchanged
  * if disjoint or no-op.
  */
 export declare function carveDeterministicVoxelChunk3D(chunk: DeterministicVoxelChunk3D, region: VoxelCarveRegion3D): DeterministicVoxelChunk3D;
@@ -69,3 +91,28 @@ 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;
+    readonly offsetCells: {
+        readonly x: number;
+        readonly y: number;
+        readonly z: number;
+    };
+    readonly occupiedCount: number;
+    readonly anchored: boolean;
+}
+export interface SplitDeterministicVoxelChunkOptions3D {
+    readonly anchorFaces?: readonly VoxelAnchorFace[];
+}
+/**
+ * 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,
+ * occupied count, and whether any of its voxels touch the specified anchor faces.
+ */
+export declare function splitDeterministicVoxelChunk3D(chunk: DeterministicVoxelChunk3D, options?: SplitDeterministicVoxelChunkOptions3D): readonly VoxelSubChunk3D[];

package/dist/physics3d-voxel.js

@@ -82,7 +82,7 @@ export function raycastDeterministicVoxelChunk3D(chunk, query) {
     let hitDistanceGrid = tMin;
     while (currentX >= 0 && currentX < dimX && currentY >= 0 && currentY < dimY && currentZ >= 0 && currentZ < dimZ) {
         const cellIndex = currentX + dimX * (currentY + dimY * currentZ);
-        if (occupancy[cellIndex] === 1) {
+        if (occupancy[cellIndex] !== 0) {
             const worldDistance = hitDistanceGrid * cellSize;
             if (worldDistance > maxDistance) {
                 return undefined;
@@ -155,10 +155,12 @@ export function cookDeterministicVoxelChunkCollider3D(chunk) {
     if (chunk.occupancy.length !== dimX * dimY * dimZ) {
         throw new Error(`cookDeterministicVoxelChunkCollider3D: occupancy length ${chunk.occupancy.length} must equal dimX*dimY*dimZ (${dimX * dimY * dimZ})`);
     }
-    for (let index = 0; index < chunk.occupancy.length; index += 1) {
-        const cell = chunk.occupancy[index];
-        if (cell !== 0 && cell !== 1) {
-            throw new Error(`cookDeterministicVoxelChunkCollider3D: occupancy[${index}] must be 0 or 1, received ${cell}`);
+    if (Array.isArray(chunk.occupancy)) {
+        for (let index = 0; index < chunk.occupancy.length; index += 1) {
+            const cell = chunk.occupancy[index];
+            if (cell !== 0 && cell !== 1) {
+                throw new Error(`cookDeterministicVoxelChunkCollider3D: occupancy[${index}] must be 0 or 1, received ${cell}`);
+            }
         }
     }
     const solid = (x, y, z) => chunk.occupancy[x + dimX * (y + dimY * z)] !== 0;
@@ -228,27 +230,100 @@ export function cookDeterministicVoxelChunkCollider3D(chunk) {
     return { type: 'compound', children };
 }
 /**
- * Carves or fills a 3D axis-aligned cell region in a voxel chunk occupancy grid.
- * Computes interval intersection with chunk dimensions, returning chunk unchanged
+ * Carves or fills a 3D region (box, sphere, or capsule) in a voxel chunk occupancy grid.
+ * Computes bounding box intersection with chunk dimensions, returning chunk unchanged
  * if disjoint or no-op.
  */
 export function carveDeterministicVoxelChunk3D(chunk, region) {
-    const { dimX, dimY, dimZ, cellSize, occupancy } = chunk;
-    const startX = Math.max(0, Math.min(region.minX, region.maxX));
-    const endX = Math.min(dimX - 1, Math.max(region.minX, region.maxX));
-    const startY = Math.max(0, Math.min(region.minY, region.maxY));
-    const endY = Math.min(dimY - 1, Math.max(region.minY, region.maxY));
-    const startZ = Math.max(0, Math.min(region.minZ, region.maxZ));
-    const endZ = Math.min(dimZ - 1, Math.max(region.minZ, region.maxZ));
+    const { dimX, dimY, dimZ, cellSize } = chunk;
+    let startX = 0;
+    let endX = dimX - 1;
+    let startY = 0;
+    let endY = dimY - 1;
+    let startZ = 0;
+    let endZ = dimZ - 1;
+    let isInside;
+    if (region.type === 'sphere') {
+        const { centerX, centerY, centerZ, radius } = region;
+        if (radius <= 0) {
+            return chunk;
+        }
+        const rSq = radius * radius;
+        startX = Math.max(0, Math.floor(centerX - radius));
+        endX = Math.min(dimX - 1, Math.ceil(centerX + radius));
+        startY = Math.max(0, Math.floor(centerY - radius));
+        endY = Math.min(dimY - 1, Math.ceil(centerY + radius));
+        startZ = Math.max(0, Math.floor(centerZ - radius));
+        endZ = Math.min(dimZ - 1, Math.ceil(centerZ + radius));
+        isInside = (x, y, z) => {
+            const dx = x - centerX;
+            const dy = y - centerY;
+            const dz = z - centerZ;
+            return dx * dx + dy * dy + dz * dz <= rSq;
+        };
+    }
+    else if (region.type === 'capsule') {
+        const { x0, y0, z0, x1, y1, z1, radius } = region;
+        if (radius <= 0) {
+            return chunk;
+        }
+        const rSq = radius * radius;
+        startX = Math.max(0, Math.floor(Math.min(x0, x1) - radius));
+        endX = Math.min(dimX - 1, Math.ceil(Math.max(x0, x1) + radius));
+        startY = Math.max(0, Math.floor(Math.min(y0, y1) - radius));
+        endY = Math.min(dimY - 1, Math.ceil(Math.max(y0, y1) + radius));
+        startZ = Math.max(0, Math.floor(Math.min(z0, z1) - radius));
+        endZ = Math.min(dimZ - 1, Math.ceil(Math.max(z0, z1) + radius));
+        const segX = x1 - x0;
+        const segY = y1 - y0;
+        const segZ = z1 - z0;
+        const segLenSq = segX * segX + segY * segY + segZ * segZ;
+        if (segLenSq < 1e-9) {
+            isInside = (x, y, z) => {
+                const dx = x - x0;
+                const dy = y - y0;
+                const dz = z - z0;
+                return dx * dx + dy * dy + dz * dz <= rSq;
+            };
+        }
+        else {
+            isInside = (x, y, z) => {
+                const px = x - x0;
+                const py = y - y0;
+                const pz = z - z0;
+                const dot = px * segX + py * segY + pz * segZ;
+                const t = Math.max(0, Math.min(1, dot / segLenSq));
+                const projX = x0 + t * segX;
+                const projY = y0 + t * segY;
+                const projZ = z0 + t * segZ;
+                const dx = x - projX;
+                const dy = y - projY;
+                const dz = z - projZ;
+                return dx * dx + dy * dy + dz * dz <= rSq;
+            };
+        }
+    }
+    else {
+        startX = Math.max(0, Math.min(region.minX, region.maxX));
+        endX = Math.min(dimX - 1, Math.max(region.minX, region.maxX));
+        startY = Math.max(0, Math.min(region.minY, region.maxY));
+        endY = Math.min(dimY - 1, Math.max(region.minY, region.maxY));
+        startZ = Math.max(0, Math.min(region.minZ, region.maxZ));
+        endZ = Math.min(dimZ - 1, Math.max(region.minZ, region.maxZ));
+        isInside = () => true;
+    }
     if (startX > endX || startY > endY || startZ > endZ) {
         return chunk;
     }
     const targetVal = region.operation === 'carve' ? 0 : 1;
     let changed = false;
-    const nextOccupancy = [...occupancy];
+    const nextOccupancy = chunk.occupancy instanceof Uint8Array ? new Uint8Array(chunk.occupancy) : [...chunk.occupancy];
     for (let z = startZ; z <= endZ; z += 1) {
         for (let y = startY; y <= endY; y += 1) {
             for (let x = startX; x <= endX; x += 1) {
+                if (!isInside(x, y, z)) {
+                    continue;
+                }
                 const index = x + dimX * (y + dimY * z);
                 if (nextOccupancy[index] !== targetVal) {
                     nextOccupancy[index] = targetVal;
@@ -426,3 +501,195 @@ 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,
+ * occupied count, and whether any of its voxels touch the specified anchor faces.
+ */
+export function splitDeterministicVoxelChunk3D(chunk, options) {
+    const { dimX, dimY, dimZ, cellSize, occupancy } = chunk;
+    const totalCells = dimX * dimY * dimZ;
+    if (totalCells === 0) {
+        return [];
+    }
+    const anchorFaces = new Set(options?.anchorFaces ?? []);
+    const checkAnchored = (x, y, z) => {
+        if (anchorFaces.has('-x') && x === 0)
+            return true;
+        if (anchorFaces.has('+x') && x === dimX - 1)
+            return true;
+        if (anchorFaces.has('-y') && y === 0)
+            return true;
+        if (anchorFaces.has('+y') && y === dimY - 1)
+            return true;
+        if (anchorFaces.has('-z') && z === 0)
+            return true;
+        if (anchorFaces.has('+z') && z === dimZ - 1)
+            return true;
+        return false;
+    };
+    const visited = new Uint8Array(totalCells);
+    const queueIdx = new Int32Array(totalCells);
+    const subChunks = [];
+    const sliceSize = dimX * dimY;
+    for (let z = 0; z < dimZ; z += 1) {
+        for (let y = 0; y < dimY; y += 1) {
+            for (let x = 0; x < dimX; x += 1) {
+                const seedIdx = x + dimX * y + sliceSize * z;
+                if (visited[seedIdx] !== 0 || occupancy[seedIdx] === 0) {
+                    continue;
+                }
+                let head = 0;
+                let tail = 0;
+                queueIdx[tail++] = seedIdx;
+                visited[seedIdx] = 1;
+                let minX = x;
+                let maxX = x;
+                let minY = y;
+                let maxY = y;
+                let minZ = z;
+                let maxZ = z;
+                let isAnchored = checkAnchored(x, y, z);
+                while (head < tail) {
+                    const currIdx = queueIdx[head++];
+                    const cz = Math.floor(currIdx / sliceSize);
+                    const rem = currIdx % sliceSize;
+                    const cy = Math.floor(rem / dimX);
+                    const cx = rem % dimX;
+                    if (cx < minX)
+                        minX = cx;
+                    if (cx > maxX)
+                        maxX = cx;
+                    if (cy < minY)
+                        minY = cy;
+                    if (cy > maxY)
+                        maxY = cy;
+                    if (cz < minZ)
+                        minZ = cz;
+                    if (cz > maxZ)
+                        maxZ = cz;
+                    if (!isAnchored && checkAnchored(cx, cy, cz)) {
+                        isAnchored = true;
+                    }
+                    if (cx > 0) {
+                        const nIdx = currIdx - 1;
+                        if (visited[nIdx] === 0 && occupancy[nIdx] !== 0) {
+                            visited[nIdx] = 1;
+                            queueIdx[tail++] = nIdx;
+                        }
+                    }
+                    if (cx + 1 < dimX) {
+                        const nIdx = currIdx + 1;
+                        if (visited[nIdx] === 0 && occupancy[nIdx] !== 0) {
+                            visited[nIdx] = 1;
+                            queueIdx[tail++] = nIdx;
+                        }
+                    }
+                    if (cy > 0) {
+                        const nIdx = currIdx - dimX;
+                        if (visited[nIdx] === 0 && occupancy[nIdx] !== 0) {
+                            visited[nIdx] = 1;
+                            queueIdx[tail++] = nIdx;
+                        }
+                    }
+                    if (cy + 1 < dimY) {
+                        const nIdx = currIdx + dimX;
+                        if (visited[nIdx] === 0 && occupancy[nIdx] !== 0) {
+                            visited[nIdx] = 1;
+                            queueIdx[tail++] = nIdx;
+                        }
+                    }
+                    if (cz > 0) {
+                        const nIdx = currIdx - sliceSize;
+                        if (visited[nIdx] === 0 && occupancy[nIdx] !== 0) {
+                            visited[nIdx] = 1;
+                            queueIdx[tail++] = nIdx;
+                        }
+                    }
+                    if (cz + 1 < dimZ) {
+                        const nIdx = currIdx + sliceSize;
+                        if (visited[nIdx] === 0 && occupancy[nIdx] !== 0) {
+                            visited[nIdx] = 1;
+                            queueIdx[tail++] = nIdx;
+                        }
+                    }
+                }
+                const componentCount = tail;
+                const subDimX = maxX - minX + 1;
+                const subDimY = maxY - minY + 1;
+                const subDimZ = maxZ - minZ + 1;
+                const subTotal = subDimX * subDimY * subDimZ;
+                const subSlice = subDimX * subDimY;
+                let subOccupancy;
+                if (occupancy instanceof Uint8Array) {
+                    const typed = new Uint8Array(subTotal);
+                    for (let i = 0; i < tail; i += 1) {
+                        const vIdx = queueIdx[i];
+                        const vz = Math.floor(vIdx / sliceSize);
+                        const vrem = vIdx % sliceSize;
+                        const vy = Math.floor(vrem / dimX);
+                        const vx = vrem % dimX;
+                        const targetSubIdx = (vx - minX) + subDimX * (vy - minY) + subSlice * (vz - minZ);
+                        typed[targetSubIdx] = occupancy[vIdx];
+                    }
+                    subOccupancy = typed;
+                }
+                else {
+                    const arr = new Array(subTotal).fill(0);
+                    for (let i = 0; i < tail; i += 1) {
+                        const vIdx = queueIdx[i];
+                        const vz = Math.floor(vIdx / sliceSize);
+                        const vrem = vIdx % sliceSize;
+                        const vy = Math.floor(vrem / dimX);
+                        const vx = vrem % dimX;
+                        const targetSubIdx = (vx - minX) + subDimX * (vy - minY) + subSlice * (vz - minZ);
+                        arr[targetSubIdx] = occupancy[vIdx] !== 0 ? 1 : 0;
+                    }
+                    subOccupancy = arr;
+                }
+                subChunks.push({
+                    chunk: {
+                        dimX: subDimX,
+                        dimY: subDimY,
+                        dimZ: subDimZ,
+                        cellSize,
+                        occupancy: subOccupancy,
+                    },
+                    offsetCells: { x: minX, y: minY, z: minZ },
+                    occupiedCount: componentCount,
+                    anchored: isAnchored,
+                });
+            }
+        }
+    }
+    subChunks.sort((a, b) => {
+        if (a.anchored !== b.anchored) {
+            return a.anchored ? -1 : 1;
+        }
+        if (a.offsetCells.z !== b.offsetCells.z) {
+            return a.offsetCells.z - b.offsetCells.z;
+        }
+        if (a.offsetCells.y !== b.offsetCells.y) {
+            return a.offsetCells.y - b.offsetCells.y;
+        }
+        if (a.offsetCells.x !== b.offsetCells.x) {
+            return a.offsetCells.x - b.offsetCells.x;
+        }
+        if (a.chunk.dimZ !== b.chunk.dimZ) {
+            return a.chunk.dimZ - b.chunk.dimZ;
+        }
+        if (a.chunk.dimY !== b.chunk.dimY) {
+            return a.chunk.dimY - b.chunk.dimY;
+        }
+        if (a.chunk.dimX !== b.chunk.dimX) {
+            return a.chunk.dimX - b.chunk.dimX;
+        }
+        return a.occupiedCount - b.occupiedCount;
+    });
+    return subChunks;
+}

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;
@@ -272,6 +282,9 @@ export interface DeterministicPhysicsContactEvent3D {
     readonly sensor: boolean;
     /** Accumulated normal impulse (quantized) from the rigid solver; 0 for triggers/exits. */
     readonly normalImpulse?: number;
+    readonly point?: Point3D;
+    readonly normal?: Point3D;
+    readonly closingSpeed?: number;
 }
 export interface DeterministicPhysicsContactDetail3D {
     readonly pair: string;
@@ -384,6 +397,19 @@ export interface DeterministicPhysicsImpulseApplication3D {
  * fast path for per-frame controller output (vehicles, KCC pushes).
  */
 export declare function applyDeterministicImpulses3D(world: DeterministicPhysicsWorld3D, impulses: readonly DeterministicPhysicsImpulseApplication3D[]): DeterministicPhysicsWorld3D;
+export interface DeterministicPhysicsForceApplication3D {
+    readonly bodyId: string;
+    readonly force?: Point3D;
+    readonly torque?: Point3D;
+    readonly worldPoint?: Point3D;
+}
+/**
+ * Apply a batch of continuous deterministic forces and torques over a duration (defaulting to 1 dt tick),
+ * accumulating linear and angular delta-v and waking touched contact islands.
+ */
+export declare function applyDeterministicForces3D(world: DeterministicPhysicsWorld3D, forces: readonly DeterministicPhysicsForceApplication3D[], options?: {
+    readonly dtTicks?: number;
+}): DeterministicPhysicsWorld3D;
 export interface DeterministicPhysicsWorldEdit3D {
     readonly add?: readonly DeterministicPhysicsBody3D[];
     readonly remove?: readonly string[];
@@ -427,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/physics3d.js

@@ -257,6 +257,125 @@ export function applyDeterministicImpulses3D(world, impulses) {
     });
     return { ...world, bodies: normalizeBodies(bodies, 'trusted') };
 }
+/**
+ * Apply a batch of continuous deterministic forces and torques over a duration (defaulting to 1 dt tick),
+ * accumulating linear and angular delta-v and waking touched contact islands.
+ */
+export function applyDeterministicForces3D(world, forces, options) {
+    if (forces.length === 0) {
+        return world;
+    }
+    if (options?.dtTicks !== undefined && options.dtTicks <= 0) {
+        throw new Error(`applyDeterministicForces3D: dtTicks must be a positive finite number, received ${options.dtTicks}`);
+    }
+    const dt = options?.dtTicks ?? 1;
+    const bodyById = new Map(world.bodies.map((body) => [body.id, body]));
+    const linearDelta = new Map();
+    const angularDelta = new Map();
+    const invInertiaByBody = new Map();
+    for (const entry of forces) {
+        if (entry.force !== undefined) {
+            assertFinitePoint(entry.force, 'applyDeterministicForces3D: force');
+        }
+        if (entry.torque !== undefined) {
+            assertFinitePoint(entry.torque, 'applyDeterministicForces3D: torque');
+        }
+        if (entry.worldPoint !== undefined) {
+            assertFinitePoint(entry.worldPoint, 'applyDeterministicForces3D: worldPoint');
+        }
+        const target = bodyById.get(entry.bodyId);
+        if (target === undefined) {
+            throw new Error(`applyDeterministicForces3D: unknown body ${entry.bodyId}`);
+        }
+        if (entry.force !== undefined) {
+            const mass = target.mass ?? 1;
+            const baseInvMass = target.kind === 'dynamic' ? 1 / mass : 0;
+            const lockLinear = target.lockLinear ?? {};
+            const previousLinear = linearDelta.get(entry.bodyId) ?? { x: 0, y: 0, z: 0 };
+            linearDelta.set(entry.bodyId, {
+                x: previousLinear.x + entry.force.x * dt * (lockLinear.x === true ? 0 : baseInvMass),
+                y: previousLinear.y + entry.force.y * dt * (lockLinear.y === true ? 0 : baseInvMass),
+                z: previousLinear.z + entry.force.z * dt * (lockLinear.z === true ? 0 : baseInvMass),
+            });
+        }
+        let netTorque = undefined;
+        if (entry.torque !== undefined) {
+            netTorque = { x: entry.torque.x, y: entry.torque.y, z: entry.torque.z };
+        }
+        if (entry.force !== undefined && entry.worldPoint !== undefined && target.kind === 'dynamic') {
+            const center = worldCenterOfMassForBody(target);
+            const lever = { x: entry.worldPoint.x - center.x, y: entry.worldPoint.y - center.y, z: entry.worldPoint.z - center.z };
+            const torqueFromForce = cross(lever, entry.force);
+            netTorque = {
+                x: (netTorque?.x ?? 0) + torqueFromForce.x,
+                y: (netTorque?.y ?? 0) + torqueFromForce.y,
+                z: (netTorque?.z ?? 0) + torqueFromForce.z,
+            };
+        }
+        if (netTorque !== undefined && target.orientation !== undefined && target.kind === 'dynamic') {
+            let invInertia = invInertiaByBody.get(entry.bodyId);
+            if (invInertia === undefined) {
+                invInertia = worldInverseInertiaForBody(target);
+                invInertiaByBody.set(entry.bodyId, invInertia);
+            }
+            const angImpulse = { x: netTorque.x * dt, y: netTorque.y * dt, z: netTorque.z * dt };
+            const angularKick = mulMat3Vec(invInertia, angImpulse);
+            const previousAngular = angularDelta.get(entry.bodyId) ?? { x: 0, y: 0, z: 0 };
+            angularDelta.set(entry.bodyId, {
+                x: previousAngular.x + angularKick.x,
+                y: previousAngular.y + angularKick.y,
+                z: previousAngular.z + angularKick.z,
+            });
+        }
+    }
+    const touchedBodies = new Set();
+    for (const [bodyId, dv] of linearDelta.entries()) {
+        if (dv.x !== 0 || dv.y !== 0 || dv.z !== 0) {
+            touchedBodies.add(bodyId);
+        }
+    }
+    for (const [bodyId, dw] of angularDelta.entries()) {
+        if (dw.x !== 0 || dw.y !== 0 || dw.z !== 0) {
+            touchedBodies.add(bodyId);
+        }
+    }
+    const woken = new Set();
+    for (const bodyId of touchedBodies) {
+        for (const member of contactIslandFor(world, bodyId)) {
+            woken.add(member);
+        }
+    }
+    const bodies = world.bodies.map((body) => {
+        const dv = linearDelta.get(body.id);
+        const dw = angularDelta.get(body.id);
+        const hasKick = (dv !== undefined && (dv.x !== 0 || dv.y !== 0 || dv.z !== 0))
+            || (dw !== undefined && (dw.x !== 0 || dw.y !== 0 || dw.z !== 0));
+        const shouldWake = (hasKick || woken.has(body.id)) && body.kind === 'dynamic';
+        if (!hasKick && !shouldWake) {
+            return body;
+        }
+        const updated = {
+            ...body,
+            vx: dv !== undefined ? quantizeDistance(body.vx + dv.x) : body.vx,
+            vy: dv !== undefined ? quantizeDistance(body.vy + dv.y) : body.vy,
+            vz: dv !== undefined ? quantizeDistance(body.vz + dv.z) : body.vz,
+            sleeping: shouldWake ? false : body.sleeping,
+            lowVelFrames: shouldWake ? 0 : body.lowVelFrames,
+        };
+        if (dw === undefined) {
+            return updated;
+        }
+        return {
+            ...updated,
+            angularVel: {
+                x: quantizeDistance((body.angularVel?.x ?? 0) + dw.x),
+                y: quantizeDistance((body.angularVel?.y ?? 0) + dw.y),
+                z: quantizeDistance((body.angularVel?.z ?? 0) + dw.z),
+            },
+        };
+    });
+    return { ...world, bodies: normalizeBodies(bodies, 'trusted') };
+}
 /**
  * Atomic deterministic topology edit: add/remove/replace bodies without
  * recreating the world. Preserves `frame`, the object identity and sleep state
@@ -2255,14 +2374,56 @@ function runRigidSolver(world, dt, gravityY, velocityIterations, substeps, joint
         .map((entry) => entry.jointId);
     const impulseByPair = new Map();
     const solidContacts = [];
-    for (const impulse of result.contactImpulses) {
+    for (let i = 0; i < result.contactImpulses.length; i += 1) {
+        const impulse = result.contactImpulses[i];
+        const manifold = result.manifolds[i];
         impulseByPair.set(impulse.pair, quantizeDistance(impulse.normalImpulse));
+        let point = undefined;
+        let normal = undefined;
+        let closingSpeed = undefined;
+        if (manifold !== undefined && manifold.points.length > 0) {
+            let deepest = manifold.points[0];
+            for (let p = 1; p < manifold.points.length; p += 1) {
+                if (manifold.points[p].penetration > deepest.penetration) {
+                    deepest = manifold.points[p];
+                }
+            }
+            const sbA = solverBodies[impulse.a];
+            point = {
+                x: quantizeDistance(sbA.p.x + deepest.rA.x),
+                y: quantizeDistance(sbA.p.y + deepest.rA.y),
+                z: quantizeDistance(sbA.p.z + deepest.rA.z),
+            };
+            normal = {
+                x: quantizeDistance(manifold.normal.x),
+                y: quantizeDistance(manifold.normal.y),
+                z: quantizeDistance(manifold.normal.z),
+            };
+            const bodyA = source[impulse.a];
+            const bodyB = source[impulse.b];
+            const sbB = solverBodies[impulse.b];
+            const applyGravityA = sbA.isDynamic && !sbA.sleeping && sbA.invMassVec.y !== 0;
+            const applyGravityB = sbB.isDynamic && !sbB.sleeping && sbB.invMassVec.y !== 0;
+            const wA = bodyA.angularVel ?? { x: 0, y: 0, z: 0 };
+            const wB = bodyB.angularVel ?? { x: 0, y: 0, z: 0 };
+            const vAx = (bodyA.vx ?? 0) + (wA.y * deepest.rA.z - wA.z * deepest.rA.y);
+            const vAy = (bodyA.vy ?? 0) + (applyGravityA ? gravityY * dt * sbA.gravityScale : 0) + (wA.z * deepest.rA.x - wA.x * deepest.rA.z);
+            const vAz = (bodyA.vz ?? 0) + (wA.x * deepest.rA.y - wA.y * deepest.rA.x);
+            const vBx = (bodyB.vx ?? 0) + (wB.y * deepest.rB.z - wB.z * deepest.rB.y);
+            const vBy = (bodyB.vy ?? 0) + (applyGravityB ? gravityY * dt * sbB.gravityScale : 0) + (wB.z * deepest.rB.x - wB.x * deepest.rB.z);
+            const vBz = (bodyB.vz ?? 0) + (wB.x * deepest.rB.y - wB.y * deepest.rB.x);
+            const relApproach = (vAx - vBx) * manifold.normal.x + (vAy - vBy) * manifold.normal.y + (vAz - vBz) * manifold.normal.z;
+            closingSpeed = quantizeDistance(Math.max(0, relApproach));
+        }
         solidContacts.push({
             pair: impulse.pair,
             a: solverBodies[impulse.a].id,
             b: solverBodies[impulse.b].id,
             trigger: false,
             sensor: false,
+            ...(point !== undefined ? { point } : {}),
+            ...(normal !== undefined ? { normal } : {}),
+            ...(closingSpeed !== undefined ? { closingSpeed } : {}),
         });
     }
     return { bodies, contactCache, jointCache, impulseByPair, solidContacts, narrowphaseContacts: result.manifolds.length, brokenJointIds };

package/dist/schema-dsl-binary.d.ts

@@ -1,11 +1,11 @@
-export type DeterministicDslScalarFieldKind = 'int' | 'fixed' | 'bool' | 'button' | 'string' | 'asset-ref' | 'entity-ref' | 'player-ref' | `asset-ref:${string}` | `enum:${string}` | `flags:${string}` | `bitset:${string}`;
+export type DeterministicDslScalarFieldKind = 'int' | 'fixed' | 'bool' | 'button' | 'string' | 'bytes' | 'asset-ref' | 'entity-ref' | 'player-ref' | `asset-ref:${string}` | `enum:${string}` | `flags:${string}` | `bitset:${string}`;
 export type DeterministicDslFixedArrayFieldKind = `${DeterministicDslScalarFieldKind}[${number}]`;
 export type DeterministicDslListFieldKind = `list<${DeterministicDslScalarFieldKind}>`;
 export type DeterministicDslSetFieldKind = `set<${DeterministicDslScalarFieldKind}>`;
 export type DeterministicDslDictionaryFieldKind = `dictionary<${DeterministicDslScalarFieldKind},${DeterministicDslScalarFieldKind}>`;
 export type DeterministicDslFieldKind = DeterministicDslScalarFieldKind | `${DeterministicDslScalarFieldKind}[]` | DeterministicDslFixedArrayFieldKind | DeterministicDslListFieldKind | DeterministicDslSetFieldKind | DeterministicDslDictionaryFieldKind;
 export type DeterministicDslDeclarationKind = 'component' | 'singleton' | 'global' | 'input' | 'command' | 'event' | 'signal' | 'struct' | 'enum' | 'flags' | 'union';
-export type DeterministicDslScalarValue = boolean | number | string;
+export type DeterministicDslScalarValue = boolean | number | string | Uint8Array;
 export interface DeterministicDslDictionaryEntry {
     readonly key: DeterministicDslScalarValue;
     readonly value: DeterministicDslScalarValue;

package/dist/schema-dsl-binary.js

@@ -352,12 +352,25 @@ function appendField(bytes, kind, value) {
     if (Array.isArray(value)) {
         throw new Error(`Unexpected array for ${kind} field`);
     }
-    if (typeof value !== 'boolean' && typeof value !== 'number' && typeof value !== 'string') {
+    if (typeof value !== 'boolean' && typeof value !== 'number' && typeof value !== 'string' && !(value instanceof Uint8Array)) {
         throw new Error(`Invalid ${kind} field value`);
     }
     appendScalarField(bytes, kind, value);
 }
 function appendScalarField(bytes, kind, value) {
+    if (kind === 'bytes') {
+        if (!(value instanceof Uint8Array)) {
+            throw new Error(`${kind} field requires Uint8Array value`);
+        }
+        if (value.byteLength > 65535) {
+            throw new Error('Bytes field too large');
+        }
+        appendUint16(bytes, value.byteLength);
+        for (let i = 0; i < value.byteLength; i += 1) {
+            bytes.push(value[i]);
+        }
+        return;
+    }
     if (kind === 'bool' || kind === 'button') {
         if (typeof value !== 'boolean') {
             throw new Error(`${kind} field requires boolean value`);
@@ -421,6 +434,16 @@ function readField(bytes, offset, kind) {
     return readScalarField(bytes, offset, kind);
 }
 function readScalarField(bytes, offset, kind) {
+    if (kind === 'bytes') {
+        const length = readUint16(bytes, offset);
+        const start = offset + 2;
+        const end = start + length;
+        assertAvailable(bytes, start, length);
+        return {
+            value: bytes.slice(start, end),
+            offset: end,
+        };
+    }
     if (kind === 'bool' || kind === 'button') {
         assertAvailable(bytes, offset, 1);
         if (bytes[offset] !== 0 && bytes[offset] !== 1) {
@@ -529,7 +552,7 @@ function normalizeDslFieldKind(rawKind) {
         .replace(/\bbitset<([A-Za-z_][A-Za-z0-9_]*)>/g, 'bitset:$1');
 }
 function scalarKindPattern() {
-    return '(?:int|fixed|bool|button|string|asset-ref|entity-ref|player-ref|asset-ref:[A-Za-z_][A-Za-z0-9_]*|enum:[A-Za-z_][A-Za-z0-9_]*|flags:[A-Za-z_][A-Za-z0-9_]*|bitset:[A-Za-z_][A-Za-z0-9_]*)';
+    return '(?:int|fixed|bool|button|string|bytes|asset-ref|entity-ref|player-ref|asset-ref:[A-Za-z_][A-Za-z0-9_]*|enum:[A-Za-z_][A-Za-z0-9_]*|flags:[A-Za-z_][A-Za-z0-9_]*|bitset:[A-Za-z_][A-Za-z0-9_]*)';
 }
 function isTypedAssetRefKind(kind) {
     return kind.startsWith('asset-ref:');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@series-inc/rundot-syncplay",
-  "version": "5.28.0-beta.0",
+  "version": "5.28.0-beta.2",
   "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-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.test.ts tests/physics3d-world-edit.test.ts tests/physics3d.test.ts tests/physics-vector-generator.test.ts tests/random.test.ts tests/rollback-history.test.ts tests/schema-artifacts.test.ts tests/schema-codegen.test.ts tests/schema-dsl-binary.test.ts tests/schema.test.ts tests/signals.test.ts tests/sparse-set.test.ts tests/static-checker.test.ts tests/system-lifecycle.test.ts tests/wire-canonical-sentinels.test.ts tests/ws-frame.test.ts",
+    "test:extended": "tsx --test tests/kcc-vehicle-characterization.test.ts tests/animation.test.ts tests/asset-cooking.test.ts tests/backend-proof-checksum-vectors.test.ts tests/bot-documents.test.ts tests/bot-primitives.test.ts tests/collider-cooking.test.ts tests/collision.test.ts tests/command-timeline.test.ts tests/config-bundle.test.ts tests/cosmetic-physics3d.test.ts tests/deterministic-primitives.test.ts tests/ecs-lite.test.ts tests/effects-adapter.test.ts tests/engine-runtime.test.ts tests/errors.test.ts tests/events.test.ts tests/input-button.test.ts tests/load-128-players.test.ts tests/math.test.ts tests/movement.test.ts tests/movement3d.test.ts tests/multiclient-authority.test.ts tests/navigation.test.ts tests/noise.test.ts tests/physics-cert.test.ts tests/physics2d.test.ts tests/physics3d-ccd.test.ts tests/physics3d-coverage.test.ts tests/physics3d-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",