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

package/dist/browser.d.ts

@@ -24,8 +24,9 @@ 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, createDeterministicPhysicsWorld3D, createTrustedDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, setDeterministicKinematicPoses3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D } from './physics3d.js';
-export { cookDeterministicVoxelChunkCollider3D, raycastDeterministicVoxelChunk3D } from './physics3d-voxel.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 { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { createDeterministicCosmeticPhysicsWorld3D, setDeterministicCosmeticPhysicsAuthoritativeBodyProxies3D, stepDeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.js';
 export { stepDeterministicVehicle3D } from './physics3d-vehicle.js';
@@ -65,8 +66,9 @@ 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, 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 } from './physics3d-voxel.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 { PhysicsWorldDebugMesh, PhysicsWorldDebugMeshOptions } from './debug-wireframe.js';
 export type { DeterministicAuthoritativeBodyProxy3D, DeterministicCosmeticPhysicsBody3D, DeterministicCosmeticPhysicsStepOptions3D, DeterministicCosmeticPhysicsStepResult3D, DeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.js';
 export type { DeterministicPhysicsJoint3D } from './physics3d-joints.js';
 export type { DeterministicVehicle3D, DeterministicVehicleImpulse3D, DeterministicVehicleInput3D, DeterministicVehicleStepOptions3D, DeterministicVehicleStepResult3D, DeterministicVehicleWheel3D, DeterministicVehicleWheelTelemetry3D } from './physics3d-vehicle.js';

package/dist/browser.js

@@ -25,8 +25,9 @@ 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, createDeterministicPhysicsWorld3D, createTrustedDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, setDeterministicKinematicPoses3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D } from './physics3d.js';
-export { cookDeterministicVoxelChunkCollider3D, raycastDeterministicVoxelChunk3D } from './physics3d-voxel.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 { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { createDeterministicCosmeticPhysicsWorld3D, setDeterministicCosmeticPhysicsAuthoritativeBodyProxies3D, stepDeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.js';
 export { stepDeterministicVehicle3D } from './physics3d-vehicle.js';

package/dist/creator.d.ts

@@ -12,12 +12,14 @@ 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, createDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, setDeterministicKinematicPoses3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D, } from './physics3d.js';
-export { cookDeterministicVoxelChunkCollider3D, raycastDeterministicVoxelChunk3D } from './physics3d-voxel.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 { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { stepDeterministicVehicle3D } from './physics3d-vehicle.js';
-export type { DeterministicContactCacheEntry3D, DeterministicJointCacheEntry3D, DeterministicKinematicPose3D, 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 } from './physics3d-voxel.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 { 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';

package/dist/creator.js

@@ -9,7 +9,8 @@ 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, createDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, setDeterministicKinematicPoses3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D, } from './physics3d.js';
-export { cookDeterministicVoxelChunkCollider3D, raycastDeterministicVoxelChunk3D } from './physics3d-voxel.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 { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { stepDeterministicVehicle3D } from './physics3d-vehicle.js';

package/dist/debug-wireframe.d.ts

@@ -0,0 +1,22 @@
+import type { DeterministicPhysicsWorld3D } from './physics3d.js';
+export interface PhysicsWorldDebugMesh {
+    /** Flat vertex positions [x0, y0, z0, x1, y1, z1, ...] for gl.LINES. */
+    readonly positions: Float32Array;
+    /** Line segment index pairs [start0, end0, start1, end1, ...] for gl.LINES / Three.js LineSegments. */
+    readonly indices: Uint32Array;
+}
+export interface PhysicsWorldDebugMeshOptions {
+    readonly includeStatics?: boolean;
+    readonly includeKinematics?: boolean;
+    readonly includeDynamics?: boolean;
+    readonly includeTriggers?: boolean;
+    readonly includeSensors?: boolean;
+    readonly sphereSegments?: number;
+    readonly capsuleSegments?: number;
+}
+/**
+ * Generates flat position and index buffers of line segments representing all
+ * colliders in a deterministic physics world, compatible with Three.js LineSegments
+ * and WebGL line rendering pipelines.
+ */
+export declare function generatePhysicsWorldDebugMesh(world: DeterministicPhysicsWorld3D, options?: PhysicsWorldDebugMeshOptions): PhysicsWorldDebugMesh;

package/dist/debug-wireframe.js

@@ -0,0 +1,226 @@
+import { canonicalQuarterTurns, quaternionFromQuarterTurns, rotatePointByQuat, } from './physics3d-shared.js';
+import { buildSolverHull } from './physics3d-hull.js';
+function createCircleLines(radius, segments, plane, center = { x: 0, y: 0, z: 0 }) {
+    const vertices = [];
+    const indices = [];
+    const step = (Math.PI * 2) / segments;
+    for (let i = 0; i < segments; i += 1) {
+        const angle = i * step;
+        const cos = Math.cos(angle) * radius;
+        const sin = Math.sin(angle) * radius;
+        if (plane === 'xy') {
+            vertices.push({ x: center.x + cos, y: center.y + sin, z: center.z });
+        }
+        else if (plane === 'xz') {
+            vertices.push({ x: center.x + cos, y: center.y, z: center.z + sin });
+        }
+        else {
+            vertices.push({ x: center.x, y: center.y + cos, z: center.z + sin });
+        }
+        indices.push(i, (i + 1) % segments);
+    }
+    return { vertices, indices };
+}
+function createArcLines(radius, segments, plane, center, startAngle, endAngle) {
+    const vertices = [];
+    const indices = [];
+    const span = endAngle - startAngle;
+    for (let i = 0; i <= segments; i += 1) {
+        const angle = startAngle + (i / segments) * span;
+        const cos = Math.cos(angle) * radius;
+        const sin = Math.sin(angle) * radius;
+        if (plane === 'xy') {
+            vertices.push({ x: center.x + cos, y: center.y + sin, z: center.z });
+        }
+        else {
+            vertices.push({ x: center.x, y: center.y + cos, z: center.z + sin });
+        }
+        if (i < segments) {
+            indices.push(i, i + 1);
+        }
+    }
+    return { vertices, indices };
+}
+function appendGeometry(target, source, transform) {
+    const vertexOffset = target.vertices.length;
+    for (const vertex of source.vertices) {
+        let transformed = vertex;
+        if (transform?.orientation !== undefined) {
+            transformed = rotatePointByQuat(transform.orientation, transformed);
+        }
+        if (transform?.offset !== undefined) {
+            transformed = {
+                x: transformed.x + transform.offset.x,
+                y: transformed.y + transform.offset.y,
+                z: transformed.z + transform.offset.z,
+            };
+        }
+        target.vertices.push(transformed);
+    }
+    for (const idx of source.indices) {
+        target.indices.push(vertexOffset + idx);
+    }
+}
+function buildShapeLines(shape, options) {
+    const result = { vertices: [], indices: [] };
+    const sphereSegs = options.sphereSegments ?? 16;
+    const capsuleSegs = options.capsuleSegments ?? 12;
+    if (shape.type === 'box') {
+        const { halfX, halfY, halfZ } = shape;
+        const verts = [
+            { x: -halfX, y: -halfY, z: -halfZ },
+            { x: halfX, y: -halfY, z: -halfZ },
+            { x: halfX, y: -halfY, z: halfZ },
+            { x: -halfX, y: -halfY, z: halfZ },
+            { x: -halfX, y: halfY, z: -halfZ },
+            { x: halfX, y: halfY, z: -halfZ },
+            { x: halfX, y: halfY, z: halfZ },
+            { x: -halfX, y: halfY, z: halfZ },
+        ];
+        const indices = [
+            0, 1, 1, 2, 2, 3, 3, 0, // bottom
+            4, 5, 5, 6, 6, 7, 7, 4, // top
+            0, 4, 1, 5, 2, 6, 3, 7, // pillars
+        ];
+        return { vertices: verts, indices };
+    }
+    if (shape.type === 'sphere') {
+        appendGeometry(result, createCircleLines(shape.radius, sphereSegs, 'xy'));
+        appendGeometry(result, createCircleLines(shape.radius, sphereSegs, 'xz'));
+        appendGeometry(result, createCircleLines(shape.radius, sphereSegs, 'yz'));
+        return result;
+    }
+    if (shape.type === 'capsule') {
+        const { radius: r, halfHeight: h } = shape;
+        const halfSegs = Math.max(4, Math.floor(capsuleSegs / 2));
+        // 4 cylinder side pillars
+        const baseIndex = result.vertices.length;
+        result.vertices.push({ x: -r, y: -h, z: 0 }, { x: -r, y: h, z: 0 }, { x: r, y: -h, z: 0 }, { x: r, y: h, z: 0 }, { x: 0, y: -h, z: -r }, { x: 0, y: h, z: -r }, { x: 0, y: -h, z: r }, { x: 0, y: h, z: r });
+        result.indices.push(baseIndex, baseIndex + 1, baseIndex + 2, baseIndex + 3, baseIndex + 4, baseIndex + 5, baseIndex + 6, baseIndex + 7);
+        // 2 horizontal equator rings
+        appendGeometry(result, createCircleLines(r, capsuleSegs, 'xz', { x: 0, y: h, z: 0 }));
+        appendGeometry(result, createCircleLines(r, capsuleSegs, 'xz', { x: 0, y: -h, z: 0 }));
+        // Top dome arcs
+        appendGeometry(result, createArcLines(r, halfSegs, 'xy', { x: 0, y: h, z: 0 }, Math.PI, 0));
+        appendGeometry(result, createArcLines(r, halfSegs, 'yz', { x: 0, y: h, z: 0 }, -Math.PI / 2, Math.PI / 2));
+        // Bottom dome arcs
+        appendGeometry(result, createArcLines(r, halfSegs, 'xy', { x: 0, y: -h, z: 0 }, Math.PI, Math.PI * 2));
+        appendGeometry(result, createArcLines(r, halfSegs, 'yz', { x: 0, y: -h, z: 0 }, Math.PI / 2, (3 * Math.PI) / 2));
+        return result;
+    }
+    if (shape.type === 'hull') {
+        const hullData = buildSolverHull(shape.vertices);
+        const vertices = [...hullData.vertices];
+        const indices = [];
+        for (const face of hullData.faces) {
+            const len = face.verts.length;
+            for (let i = 0; i < len; i += 1) {
+                indices.push(face.verts[i], face.verts[(i + 1) % len]);
+            }
+        }
+        return { vertices, indices };
+    }
+    if (shape.type === 'mesh') {
+        const vertices = [...shape.vertices];
+        const indices = [];
+        for (let i = 0; i < vertices.length; i += 3) {
+            indices.push(i, i + 1, i + 1, i + 2, i + 2, i);
+        }
+        return { vertices, indices };
+    }
+    if (shape.type === 'heightfield') {
+        const { columns, rows, scale, heights } = shape;
+        const vertices = [];
+        const indices = [];
+        for (let r = 0; r < rows; r += 1) {
+            for (let c = 0; c < columns; c += 1) {
+                const h = heights[c + columns * r] ?? 0;
+                vertices.push({ x: c * scale.x, y: h * scale.y, z: r * scale.z });
+            }
+        }
+        for (let r = 0; r < rows; r += 1) {
+            for (let c = 0; c < columns; c += 1) {
+                const curr = c + columns * r;
+                if (c + 1 < columns) {
+                    indices.push(curr, curr + 1);
+                }
+                if (r + 1 < rows) {
+                    indices.push(curr, curr + columns);
+                }
+                if (c + 1 < columns && r + 1 < rows) {
+                    indices.push(curr + columns, curr + 1);
+                }
+            }
+        }
+        return { vertices, indices };
+    }
+    if (shape.type === 'compound') {
+        for (const child of shape.children) {
+            const childLines = buildShapeLines(child.shape, options);
+            const orientation = child.quarterTurns !== undefined
+                ? quaternionFromQuarterTurns({
+                    x: canonicalQuarterTurns(child.quarterTurns.x),
+                    y: canonicalQuarterTurns(child.quarterTurns.y),
+                    z: canonicalQuarterTurns(child.quarterTurns.z),
+                })
+                : undefined;
+            appendGeometry(result, childLines, {
+                offset: child.offset,
+                orientation,
+            });
+        }
+        return result;
+    }
+    return result;
+}
+function bodyMatchesFilter(body, options) {
+    if (body.kind === 'static' && options.includeStatics === false)
+        return false;
+    if (body.kind === 'kinematic' && options.includeKinematics === false)
+        return false;
+    if (body.kind === 'dynamic' && options.includeDynamics === false)
+        return false;
+    if (body.trigger === true && options.includeTriggers === false)
+        return false;
+    if (body.sensor === true && options.includeSensors === false)
+        return false;
+    return true;
+}
+/**
+ * Generates flat position and index buffers of line segments representing all
+ * colliders in a deterministic physics world, compatible with Three.js LineSegments
+ * and WebGL line rendering pipelines.
+ */
+export function generatePhysicsWorldDebugMesh(world, options = {}) {
+    const worldVertices = [];
+    const worldIndices = [];
+    let vertexIndexOffset = 0;
+    for (const body of world.bodies) {
+        if (!bodyMatchesFilter(body, options)) {
+            continue;
+        }
+        const localGeometry = buildShapeLines(body.shape, options);
+        const orientation = body.orientation ?? (body.rx !== undefined || body.ry !== undefined || body.rz !== undefined
+            ? quaternionFromQuarterTurns({
+                x: canonicalQuarterTurns(body.rx ?? 0),
+                y: canonicalQuarterTurns(body.ry ?? 0),
+                z: canonicalQuarterTurns(body.rz ?? 0),
+            })
+            : undefined);
+        for (const vertex of localGeometry.vertices) {
+            let worldPos = vertex;
+            if (orientation !== undefined) {
+                worldPos = rotatePointByQuat(orientation, worldPos);
+            }
+            worldVertices.push(worldPos.x + body.x, worldPos.y + body.y, worldPos.z + body.z);
+        }
+        for (const idx of localGeometry.indices) {
+            worldIndices.push(vertexIndexOffset + idx);
+        }
+        vertexIndexOffset += localGeometry.vertices.length;
+    }
+    return {
+        positions: new Float32Array(worldVertices),
+        indices: new Uint32Array(worldIndices),
+    };
+}

package/dist/index.d.ts

@@ -27,8 +27,9 @@ 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, createDeterministicPhysicsWorld3D, createTrustedDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, setDeterministicKinematicPoses3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D } from './physics3d.js';
-export { cookDeterministicVoxelChunkCollider3D, raycastDeterministicVoxelChunk3D } from './physics3d-voxel.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 { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { runDeterministicPhysics3DDestructionCert } from './physics3d-destruction-cert.js';
 export { createDeterministicCosmeticPhysicsWorld3D, setDeterministicCosmeticPhysicsAuthoritativeBodyProxies3D, stepDeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.js';
@@ -77,8 +78,9 @@ 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, 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 } from './physics3d-voxel.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 { 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';
 export type { DeterministicPhysicsJoint3D } from './physics3d-joints.js';

package/dist/index.js

@@ -28,8 +28,9 @@ 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, createDeterministicPhysicsWorld3D, createTrustedDeterministicPhysicsWorld3D, deriveInverseInertia, deterministicPhysicsBodyById3D, deterministicPhysicsCallback3D, overlapDeterministicPhysics3D, raycastDeterministicPhysics3D, raycastDeterministicPhysics3DDetailed, runDeterministicPhysics3DStress, setDeterministicBodyVelocity3D, setDeterministicKinematicPoses3D, shapeCastDeterministicPhysics3D, shapeCastDeterministicPhysics3DDetailed, stepDeterministicPhysicsWorld3D } from './physics3d.js';
-export { cookDeterministicVoxelChunkCollider3D, raycastDeterministicVoxelChunk3D } from './physics3d-voxel.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 { generatePhysicsWorldDebugMesh } from './debug-wireframe.js';
 export { cylinderHullVertices } from './physics3d-hull.js';
 export { runDeterministicPhysics3DDestructionCert } from './physics3d-destruction-cert.js';
 export { createDeterministicCosmeticPhysicsWorld3D, setDeterministicCosmeticPhysicsAuthoritativeBodyProxies3D, stepDeterministicCosmeticPhysicsWorld3D } from './cosmetic-physics3d.js';

package/dist/physics3d-voxel.d.ts

@@ -40,3 +40,32 @@ export declare function raycastDeterministicVoxelChunk3D(chunk: DeterministicVox
  * of the occupancy grid.
  */
 export declare function cookDeterministicVoxelChunkCollider3D(chunk: DeterministicVoxelChunk3D): DeterministicVoxelCompoundShape3D;
+export interface VoxelCarveRegion3D {
+    readonly minX: number;
+    readonly minY: number;
+    readonly minZ: number;
+    readonly maxX: number;
+    readonly maxY: number;
+    readonly maxZ: number;
+    readonly operation: 'carve' | 'fill';
+}
+/**
+ * Carves or fills a 3D axis-aligned cell region in a voxel chunk occupancy grid.
+ * Computes interval intersection with chunk dimensions, returning chunk unchanged
+ * if disjoint or no-op.
+ */
+export declare function carveDeterministicVoxelChunk3D(chunk: DeterministicVoxelChunk3D, region: VoxelCarveRegion3D): DeterministicVoxelChunk3D;
+/**
+ * Re-cooks compound collider boxes intersecting a dirty AABB cell region,
+ * iteratively expanding the re-cook volume to cover any intersecting previously-merged
+ * boxes so uncarved solid voxels are never dropped. Preserves disjoint children
+ * without full-chunk re-cooking. Returns undefined if 0 voxels remain across the chunk.
+ */
+export declare function cookDeterministicVoxelSubregion3D(chunk: DeterministicVoxelChunk3D, existingShape: DeterministicVoxelCompoundShape3D, dirtyRegion: {
+    readonly minX: number;
+    readonly minY: number;
+    readonly minZ: number;
+    readonly maxX: number;
+    readonly maxY: number;
+    readonly maxZ: number;
+}): DeterministicVoxelCompoundShape3D | undefined;

package/dist/physics3d-voxel.js

@@ -227,3 +227,202 @@ 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
+ * 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));
+    if (startX > endX || startY > endY || startZ > endZ) {
+        return chunk;
+    }
+    const targetVal = region.operation === 'carve' ? 0 : 1;
+    let changed = false;
+    const nextOccupancy = [...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) {
+                const index = x + dimX * (y + dimY * z);
+                if (nextOccupancy[index] !== targetVal) {
+                    nextOccupancy[index] = targetVal;
+                    changed = true;
+                }
+            }
+        }
+    }
+    if (!changed) {
+        return chunk;
+    }
+    return {
+        dimX,
+        dimY,
+        dimZ,
+        cellSize,
+        occupancy: nextOccupancy,
+    };
+}
+function cookSubregionBoxes(chunk, minX, minY, minZ, maxX, maxY, maxZ) {
+    const { dimX, dimY, dimZ, cellSize, occupancy } = chunk;
+    const solid = (x, y, z) => occupancy[x + dimX * (y + dimY * z)] !== 0;
+    const consumed = new Uint8Array(dimX * dimY * dimZ);
+    const free = (x, y, z) => solid(x, y, z) && consumed[x + dimX * (y + dimY * z)] === 0;
+    const children = [];
+    for (let z = minZ; z <= maxZ; z += 1) {
+        for (let y = minY; y <= maxY; y += 1) {
+            for (let x = minX; x <= maxX; x += 1) {
+                if (!free(x, y, z)) {
+                    continue;
+                }
+                let x1 = x;
+                while (x1 + 1 <= maxX && free(x1 + 1, y, z)) {
+                    x1 += 1;
+                }
+                const rowFree = (yy, zz) => {
+                    for (let xx = x; xx <= x1; xx += 1) {
+                        if (!free(xx, yy, zz)) {
+                            return false;
+                        }
+                    }
+                    return true;
+                };
+                let y1 = y;
+                while (y1 + 1 <= maxY && rowFree(y1 + 1, z)) {
+                    y1 += 1;
+                }
+                const slabFree = (zz) => {
+                    for (let yy = y; yy <= y1; yy += 1) {
+                        if (!rowFree(yy, zz)) {
+                            return false;
+                        }
+                    }
+                    return true;
+                };
+                let z1 = z;
+                while (z1 + 1 <= maxZ && slabFree(z1 + 1)) {
+                    z1 += 1;
+                }
+                for (let zz = z; zz <= z1; zz += 1) {
+                    for (let yy = y; yy <= y1; yy += 1) {
+                        for (let xx = x; xx <= x1; xx += 1) {
+                            consumed[xx + dimX * (yy + dimY * zz)] = 1;
+                        }
+                    }
+                }
+                children.push({
+                    shape: {
+                        type: 'box',
+                        halfX: ((x1 - x + 1) * cellSize) / 2,
+                        halfY: ((y1 - y + 1) * cellSize) / 2,
+                        halfZ: ((z1 - z + 1) * cellSize) / 2,
+                    },
+                    offset: {
+                        x: ((x + x1) / 2) * cellSize,
+                        y: ((y + y1) / 2) * cellSize,
+                        z: ((z + z1) / 2) * cellSize,
+                    },
+                });
+            }
+        }
+    }
+    return children;
+}
+/**
+ * Re-cooks compound collider boxes intersecting a dirty AABB cell region,
+ * iteratively expanding the re-cook volume to cover any intersecting previously-merged
+ * boxes so uncarved solid voxels are never dropped. Preserves disjoint children
+ * without full-chunk re-cooking. Returns undefined if 0 voxels remain across the chunk.
+ */
+export function cookDeterministicVoxelSubregion3D(chunk, existingShape, dirtyRegion) {
+    const { dimX, dimY, dimZ, cellSize } = chunk;
+    let activeMinX = Math.max(0, Math.min(dirtyRegion.minX, dirtyRegion.maxX));
+    let activeMaxX = Math.min(dimX - 1, Math.max(dirtyRegion.minX, dirtyRegion.maxX));
+    let activeMinY = Math.max(0, Math.min(dirtyRegion.minY, dirtyRegion.maxY));
+    let activeMaxY = Math.min(dimY - 1, Math.max(dirtyRegion.minY, dirtyRegion.maxY));
+    let activeMinZ = Math.max(0, Math.min(dirtyRegion.minZ, dirtyRegion.maxZ));
+    let activeMaxZ = Math.min(dimZ - 1, Math.max(dirtyRegion.minZ, dirtyRegion.maxZ));
+    if (activeMinX > activeMaxX || activeMinY > activeMaxY || activeMinZ > activeMaxZ) {
+        return existingShape;
+    }
+    // Iterative fixed-point expansion to absorb all intersecting merged boxes
+    let expanded = true;
+    while (expanded) {
+        expanded = false;
+        for (const child of existingShape.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);
+            const overlaps = boxMinX <= activeMaxX && boxMaxX >= activeMinX
+                && boxMinY <= activeMaxY && boxMaxY >= activeMinY
+                && boxMinZ <= activeMaxZ && boxMaxZ >= activeMinZ;
+            if (overlaps) {
+                if (boxMinX < activeMinX) {
+                    activeMinX = Math.max(0, boxMinX);
+                    expanded = true;
+                }
+                if (boxMaxX > activeMaxX) {
+                    activeMaxX = Math.min(dimX - 1, boxMaxX);
+                    expanded = true;
+                }
+                if (boxMinY < activeMinY) {
+                    activeMinY = Math.max(0, boxMinY);
+                    expanded = true;
+                }
+                if (boxMaxY > activeMaxY) {
+                    activeMaxY = Math.min(dimY - 1, boxMaxY);
+                    expanded = true;
+                }
+                if (boxMinZ < activeMinZ) {
+                    activeMinZ = Math.max(0, boxMinZ);
+                    expanded = true;
+                }
+                if (boxMaxZ > activeMaxZ) {
+                    activeMaxZ = Math.min(dimZ - 1, boxMaxZ);
+                    expanded = true;
+                }
+            }
+        }
+    }
+    // Preserve disjoint children
+    const preservedChildren = [];
+    for (const child of existingShape.children) {
+        if (child.shape.type !== 'box') {
+            preservedChildren.push(child);
+            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);
+        const overlaps = boxMinX <= activeMaxX && boxMaxX >= activeMinX
+            && boxMinY <= activeMaxY && boxMaxY >= activeMinY
+            && boxMinZ <= activeMaxZ && boxMaxZ >= activeMinZ;
+        if (!overlaps) {
+            preservedChildren.push(child);
+        }
+    }
+    // Cook newly carved/filled subregion
+    const subCooked = cookSubregionBoxes(chunk, activeMinX, activeMinY, activeMinZ, activeMaxX, activeMaxY, activeMaxZ);
+    const finalChildren = [...preservedChildren, ...subCooked];
+    if (finalChildren.length === 0) {
+        return undefined;
+    }
+    return {
+        type: 'compound',
+        children: finalChildren,
+    };
+}

package/dist/physics3d.d.ts

@@ -58,6 +58,24 @@ export type DeterministicPhysicsShape3D = DeterministicPhysicsPrimitiveShape3D |
     readonly type: 'compound';
     readonly children: readonly DeterministicPhysicsCompoundChild3D[];
 };
+/**
+ * Creates a centered axis-aligned box shape from full dimensional sizes (sizeX, sizeY, sizeZ).
+ */
+export declare function createBoxShapeFromExtents(sizeX: number, sizeY: number, sizeZ: number): Extract<DeterministicPhysicsShape3D, {
+    readonly type: 'box';
+}>;
+/**
+ * Creates a box shape from min and max bounding coordinates.
+ * Returns a simple box if centered at (0,0,0), or a single-child compound with offset if not centered.
+ */
+export declare function createBoxShapeFromMinMax(min: Point3D, max: Point3D): DeterministicPhysicsShape3D;
+/**
+ * Creates an upright capsule shape anchored at its base (y = 0), matching character controller conventions.
+ * Encapsulates the offset into a single-child compound shape centered at y = halfHeight + radius.
+ */
+export declare function createCapsuleShapeFromBase(radius: number, totalHeight: number): Extract<DeterministicPhysicsShape3D, {
+    readonly type: 'compound';
+}>;
 export declare const deterministicPhysicsCallback3D: {
     readonly collisionEnter: 1;
     readonly collisionStay: 2;
@@ -220,6 +238,11 @@ export interface DeterministicKinematicPose3D {
     readonly angularVelY?: number;
     readonly angularVelZ?: number;
 }
+export interface DeterministicKinematicTransformBuffer3D {
+    readonly bodyIds: readonly string[];
+    /** Flat [x, y, z, qx, qy, qz, qw] buffer per body. Length must be bodyIds.length * 7. */
+    readonly transforms: Float64Array | Float32Array | readonly number[];
+}
 export interface DeterministicPhysicsScheduledQuery3D {
     readonly id: string;
     readonly phase: 'pre-physics' | 'post-physics';
@@ -389,6 +412,14 @@ export declare function applyDeterministicWorldEdit3D(world: DeterministicPhysic
 export declare function setDeterministicKinematicPoses3D(world: DeterministicPhysicsWorld3D, poses: readonly DeterministicKinematicPose3D[], options?: {
     readonly dtTicks?: number;
 }): DeterministicPhysicsWorld3D;
+/**
+ * Allocation-free flat buffer batch update of kinematic body transforms.
+ * Accepts flat [x, y, z, qx, qy, qz, qw] arrays with stride 7 per bodyId,
+ * eliminating caller-side object allocations on high-frequency animation loops.
+ */
+export declare function setDeterministicKinematicTransforms3D(world: DeterministicPhysicsWorld3D, buffer: DeterministicKinematicTransformBuffer3D, options?: {
+    readonly dtTicks?: number;
+}): DeterministicPhysicsWorld3D;
 /**
  * Apply a deterministic impulse to a body (linear + angular via lever arm),
  * waking the body and its contact island. Returns a new canonical world.

package/dist/physics3d.js

@@ -7,6 +7,73 @@ import { buildSolverHull, rayHullIntervalLocal, } from './physics3d-hull.js';
 import { computeShapeMassProperties } from './physics3d-mass.js';
 import { heightfieldLocalBounds, heightfieldLocalTriangles } from './physics3d-heightfield.js';
 import { conservativeToi, toiProxiesOf, toiProxyOf, } from './physics3d-toi.js';
+/**
+ * Creates a centered axis-aligned box shape from full dimensional sizes (sizeX, sizeY, sizeZ).
+ */
+export function createBoxShapeFromExtents(sizeX, sizeY, sizeZ) {
+    if (!Number.isFinite(sizeX) || sizeX <= 0 || !Number.isFinite(sizeY) || sizeY <= 0 || !Number.isFinite(sizeZ) || sizeZ <= 0) {
+        throw new Error(`createBoxShapeFromExtents: sizeX, sizeY, sizeZ must be positive finite numbers, received (${sizeX}, ${sizeY}, ${sizeZ})`);
+    }
+    return {
+        type: 'box',
+        halfX: sizeX / 2,
+        halfY: sizeY / 2,
+        halfZ: sizeZ / 2,
+    };
+}
+/**
+ * Creates a box shape from min and max bounding coordinates.
+ * Returns a simple box if centered at (0,0,0), or a single-child compound with offset if not centered.
+ */
+export function createBoxShapeFromMinMax(min, max) {
+    if (!Number.isFinite(min.x) || !Number.isFinite(min.y) || !Number.isFinite(min.z)
+        || !Number.isFinite(max.x) || !Number.isFinite(max.y) || !Number.isFinite(max.z)) {
+        throw new Error('createBoxShapeFromMinMax: min and max coordinates must be finite numbers');
+    }
+    if (max.x <= min.x || max.y <= min.y || max.z <= min.z) {
+        throw new Error(`createBoxShapeFromMinMax: max must be strictly greater than min on all axes, received min (${min.x},${min.y},${min.z}) max (${max.x},${max.y},${max.z})`);
+    }
+    const halfX = (max.x - min.x) / 2;
+    const halfY = (max.y - min.y) / 2;
+    const halfZ = (max.z - min.z) / 2;
+    const cx = (min.x + max.x) / 2;
+    const cy = (min.y + max.y) / 2;
+    const cz = (min.z + max.z) / 2;
+    if (cx === 0 && cy === 0 && cz === 0) {
+        return { type: 'box', halfX, halfY, halfZ };
+    }
+    return {
+        type: 'compound',
+        children: [
+            {
+                shape: { type: 'box', halfX, halfY, halfZ },
+                offset: { x: cx, y: cy, z: cz },
+            },
+        ],
+    };
+}
+/**
+ * Creates an upright capsule shape anchored at its base (y = 0), matching character controller conventions.
+ * Encapsulates the offset into a single-child compound shape centered at y = halfHeight + radius.
+ */
+export function createCapsuleShapeFromBase(radius, totalHeight) {
+    if (!Number.isFinite(radius) || radius <= 0 || !Number.isFinite(totalHeight) || totalHeight <= 0) {
+        throw new Error(`createCapsuleShapeFromBase: radius and totalHeight must be positive finite numbers, received radius ${radius}, totalHeight ${totalHeight}`);
+    }
+    if (totalHeight <= 2 * radius) {
+        throw new Error(`createCapsuleShapeFromBase: totalHeight must be strictly greater than 2 * radius (${2 * radius}), received ${totalHeight}`);
+    }
+    const halfHeight = (totalHeight - 2 * radius) / 2;
+    return {
+        type: 'compound',
+        children: [
+            {
+                shape: { type: 'capsule', radius, halfHeight },
+                offset: { x: 0, y: halfHeight + radius, z: 0 },
+            },
+        ],
+    };
+}
 export const deterministicPhysicsCallback3D = {
     collisionEnter: 1,
     collisionStay: 2,
@@ -281,24 +348,7 @@ export function applyDeterministicWorldEdit3D(world, edit) {
             : world.jointCache.filter((entry) => !removeJointIds.has(entry.jointId)),
     };
 }
-/**
- * Fast batch update of kinematic body transforms and velocities without
- * allocating Set instances or re-sorting world bodies. Wakes touching dynamic
- * bodies across active contact pairs. If linear velocity (vx, vy, vz) is omitted
- * and dtTicks (> 0) is supplied, linear velocity is derived as (newPos - oldPos) / dtTicks.
- */
-export function setDeterministicKinematicPoses3D(world, poses, options = {}) {
-    if (poses.length === 0) {
-        return world;
-    }
-    const dt = options.dtTicks !== undefined && options.dtTicks > 0 ? options.dtTicks : undefined;
-    const poseById = new Map();
-    for (const pose of poses) {
-        if (!Number.isFinite(pose.x) || !Number.isFinite(pose.y) || !Number.isFinite(pose.z)) {
-            throw new Error(`setDeterministicKinematicPoses3D: body ${pose.id} position must be finite numbers`);
-        }
-        poseById.set(pose.id, pose);
-    }
+function applyKinematicUpdatesInternal(world, poseById, dt, callerName) {
     const updatedIds = new Set();
     const movedBodies = new Map();
     const newBodies = world.bodies.map((body) => {
@@ -307,7 +357,7 @@ export function setDeterministicKinematicPoses3D(world, poses, options = {}) {
             return body;
         }
         if (body.kind !== 'kinematic') {
-            throw new Error(`setDeterministicKinematicPoses3D: body ${body.id} is ${body.kind}, expected kinematic`);
+            throw new Error(`${callerName}: body ${body.id} is ${body.kind}, expected kinematic`);
         }
         updatedIds.add(body.id);
         let vx = pose.vx;
@@ -350,9 +400,9 @@ export function setDeterministicKinematicPoses3D(world, poses, options = {}) {
         movedBodies.set(body.id, updated);
         return updated;
     });
-    for (const pose of poses) {
-        if (!updatedIds.has(pose.id)) {
-            throw new Error(`setDeterministicKinematicPoses3D: cannot update unknown kinematic body ${pose.id}`);
+    for (const id of poseById.keys()) {
+        if (!updatedIds.has(id)) {
+            throw new Error(`${callerName}: cannot update unknown kinematic body ${id}`);
         }
     }
     // Wake any dynamic bodies that share active pairs with updated kinematics
@@ -379,6 +429,64 @@ export function setDeterministicKinematicPoses3D(world, poses, options = {}) {
         bodies: finalBodies,
     };
 }
+/**
+ * Fast batch update of kinematic body transforms and velocities without
+ * allocating Set instances or re-sorting world bodies. Wakes touching dynamic
+ * bodies across active contact pairs. If linear velocity (vx, vy, vz) is omitted
+ * and dtTicks (> 0) is supplied, linear velocity is derived as (newPos - oldPos) / dtTicks.
+ */
+export function setDeterministicKinematicPoses3D(world, poses, options = {}) {
+    if (poses.length === 0) {
+        return world;
+    }
+    const dt = options.dtTicks !== undefined && options.dtTicks > 0 ? options.dtTicks : undefined;
+    const poseById = new Map();
+    for (const pose of poses) {
+        if (!Number.isFinite(pose.x) || !Number.isFinite(pose.y) || !Number.isFinite(pose.z)) {
+            throw new Error(`setDeterministicKinematicPoses3D: body ${pose.id} position must be finite numbers`);
+        }
+        poseById.set(pose.id, pose);
+    }
+    return applyKinematicUpdatesInternal(world, poseById, dt, 'setDeterministicKinematicPoses3D');
+}
+/**
+ * Allocation-free flat buffer batch update of kinematic body transforms.
+ * Accepts flat [x, y, z, qx, qy, qz, qw] arrays with stride 7 per bodyId,
+ * eliminating caller-side object allocations on high-frequency animation loops.
+ */
+export function setDeterministicKinematicTransforms3D(world, buffer, options = {}) {
+    const { bodyIds, transforms } = buffer;
+    if (transforms.length !== bodyIds.length * 7) {
+        throw new Error(`setDeterministicKinematicTransforms3D: transforms length must equal bodyIds.length * 7 (${bodyIds.length * 7}), received ${transforms.length}`);
+    }
+    if (bodyIds.length === 0) {
+        return world;
+    }
+    const dt = options.dtTicks !== undefined && options.dtTicks > 0 ? options.dtTicks : undefined;
+    const poseById = new Map();
+    for (let i = 0; i < bodyIds.length; i += 1) {
+        const id = bodyIds[i];
+        const offset = i * 7;
+        const x = transforms[offset];
+        const y = transforms[offset + 1];
+        const z = transforms[offset + 2];
+        const qx = transforms[offset + 3];
+        const qy = transforms[offset + 4];
+        const qz = transforms[offset + 5];
+        const qw = transforms[offset + 6];
+        if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)
+            || !Number.isFinite(qx) || !Number.isFinite(qy) || !Number.isFinite(qz) || !Number.isFinite(qw)) {
+            throw new Error(`setDeterministicKinematicTransforms3D: body ${id} transform contains non-finite numbers`);
+        }
+        poseById.set(id, {
+            x,
+            y,
+            z,
+            orientation: { x: qx, y: qy, z: qz, w: qw },
+        });
+    }
+    return applyKinematicUpdatesInternal(world, poseById, dt, 'setDeterministicKinematicTransforms3D');
+}
 /**
  * Apply a deterministic impulse to a body (linear + angular via lever arm),
  * waking the body and its contact island. Returns a new canonical world.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@series-inc/rundot-syncplay",
-  "version": "5.27.0",
+  "version": "5.28.0-beta.0",
   "description": "Kinetix orchestration, rollback, replay, late-join, and deterministic networking for RUN.game",
   "repository": {
     "type": "git",
@@ -42,6 +42,11 @@
       "import": "./dist/tools/index.js",
       "default": "./dist/tools/index.js"
     },
+    "./debug": {
+      "types": "./dist/debug-wireframe.d.ts",
+      "import": "./dist/debug-wireframe.js",
+      "default": "./dist/debug-wireframe.js"
+    },
     "./modules/component-model": {
       "types": "./dist/modules/component-model.d.ts",
       "import": "./dist/modules/component-model.js",
@@ -163,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-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-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-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-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-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: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",