@holoscript/engine 6.0.3 → 6.0.4

package/dist/physics/index.cjs

@@ -22,10 +22,16 @@ var physics_exports = {};
 __export(physics_exports, {
   ActivationTriggerType: () => ActivationTriggerType,
   COLLISION_GROUPS: () => COLLISION_GROUPS,
+  ClothSim: () => ClothSim,
+  ConstraintSolver: () => ConstraintSolver,
   DEFAULT_ACTIVATION_CONFIG: () => DEFAULT_ACTIVATION_CONFIG,
   DEFAULT_INTENSITY_CURVE: () => DEFAULT_INTENSITY_CURVE,
   DEFAULT_LOCOMOTION_CONFIG: () => DEFAULT_LOCOMOTION_CONFIG,
+  DeformableMesh: () => DeformableMesh,
+  FluidSim: () => FluidSim,
+  HUMANOID_PRESET: () => HUMANOID_PRESET,
   IslandDetector: () => IslandDetector,
+  JointSystem: () => JointSystem,
   MLSMPMFluid: () => MLSMPMFluid,
   PBDSolverCPU: () => PBDSolverCPU,
   PBD_ATTACHMENT_SHADER: () => PBD_ATTACHMENT_SHADER,
@@ -48,14 +54,23 @@ __export(physics_exports, {
   PhysicsSyncReceiver: () => PhysicsSyncReceiver,
   PhysicsSyncSender: () => PhysicsSyncSender,
   PhysicsWorldImpl: () => PhysicsWorldImpl,
+  QUADRUPED_PRESET: () => QUADRUPED_PRESET,
+  RagdollController: () => RagdollController,
+  RagdollSystem: () => RagdollSystem,
+  RaycastSystem: () => RaycastSystem,
   RigidBody: () => RigidBody,
+  RopeSystem: () => RopeSystem,
   SOFT_BODY_PRESETS: () => SOFT_BODY_PRESETS,
   ScalarArithmetic: () => ScalarArithmetic,
   SoftBodyAdapter: () => SoftBodyAdapter,
   SoftBodyGrabController: () => SoftBodyGrabController,
   SoftBodySolver: () => SoftBodySolver,
+  SpatialHash: () => SpatialHash,
+  TriggerZoneSystem: () => TriggerZoneSystem,
   UnifiedParticleBuffer: () => UnifiedParticleBuffer,
+  VRPhysicsBridge: () => VRPhysicsBridge,
   Vector3Arithmetic: () => Vector3Arithmetic,
+  VehicleSystem: () => VehicleSystem,
   VelocityRingBuffer: () => VelocityRingBuffer,
   VelocitySmoother: () => VelocitySmoother,
   WindZoneManager: () => WindZoneManager,
@@ -65,10 +80,12 @@ __export(physics_exports, {
   colorConstraints: () => colorConstraints,
   computeRestLengths: () => computeRestLengths,
   computeSelfWind: () => computeSelfWind,
+  createDefaultCar: () => createDefaultCar,
   createPBDSolver: () => createPBDSolver,
   createPIDControllerTrait: () => createPIDControllerTrait,
   createPhysicsWorld: () => createPhysicsWorld,
   createScalarPIDController: () => createScalarPIDController,
+  createTruck: () => createTruck,
   createVector3PIDController: () => createVector3PIDController,
   defaultMaterial: () => defaultMaterial,
   defaultPIDConfig: () => defaultPIDConfig,
@@ -2662,11 +2679,11 @@ function extractBendingPairs(indices, positions) {
     const v0 = parseInt(minStr);
     const v1 = parseInt(maxStr);
     const v2 = tris[0].oppositeVertex;
-    const v3 = tris[1].oppositeVertex;
+    const v32 = tris[1].oppositeVertex;
     const p0x = positions[v0 * 3], p0y = positions[v0 * 3 + 1], p0z = positions[v0 * 3 + 2];
     const p1x = positions[v1 * 3], p1y = positions[v1 * 3 + 1], p1z = positions[v1 * 3 + 2];
     const p2x = positions[v2 * 3], p2y = positions[v2 * 3 + 1], p2z = positions[v2 * 3 + 2];
-    const p3x = positions[v3 * 3], p3y = positions[v3 * 3 + 1], p3z = positions[v3 * 3 + 2];
+    const p3x = positions[v32 * 3], p3y = positions[v32 * 3 + 1], p3z = positions[v32 * 3 + 2];
     const ex = p1x - p0x, ey = p1y - p0y, ez = p1z - p0z;
     const eLen = Math.sqrt(ex * ex + ey * ey + ez * ez);
     if (eLen < 1e-7) continue;
@@ -2689,7 +2706,7 @@ function extractBendingPairs(indices, positions) {
     const cy = n1nz * n2nx - n1nx * n2nz;
     const cz = n1nx * n2ny - n1ny * n2nx;
     const sinTheta = cx * enx + cy * eny + cz * enz;
-    bendingList.push([v0, v1, v2, v3]);
+    bendingList.push([v0, v1, v2, v32]);
     angleList.push(Math.atan2(sinTheta, cosTheta));
   }
   const constraints = new Uint32Array(bendingList.length * 4);
@@ -2872,11 +2889,11 @@ var PBDSolverCPU = class {
         const v0 = tetIndices[t * 4];
         const v1 = tetIndices[t * 4 + 1];
         const v2 = tetIndices[t * 4 + 2];
-        const v3 = tetIndices[t * 4 + 3];
-        const vol = this.computeTetVolume(v0, v1, v2, v3, positions);
+        const v32 = tetIndices[t * 4 + 3];
+        const vol = this.computeTetVolume(v0, v1, v2, v32, positions);
         this.volumeConstraints.push({
           type: "volume",
-          vertices: [v0, v1, v2, v3],
+          vertices: [v0, v1, v2, v32],
           restVolume: vol,
           compliance: compliance * 0.1
         });
@@ -2902,11 +2919,11 @@ var PBDSolverCPU = class {
       });
     }
   }
-  computeTetVolume(v0, v1, v2, v3, pos) {
+  computeTetVolume(v0, v1, v2, v32, pos) {
     const p0x = pos[v0 * 3], p0y = pos[v0 * 3 + 1], p0z = pos[v0 * 3 + 2];
     const d1x = pos[v1 * 3] - p0x, d1y = pos[v1 * 3 + 1] - p0y, d1z = pos[v1 * 3 + 2] - p0z;
     const d2x = pos[v2 * 3] - p0x, d2y = pos[v2 * 3 + 1] - p0y, d2z = pos[v2 * 3 + 2] - p0z;
-    const d3x = pos[v3 * 3] - p0x, d3y = pos[v3 * 3 + 1] - p0y, d3z = pos[v3 * 3 + 2] - p0z;
+    const d3x = pos[v32 * 3] - p0x, d3y = pos[v32 * 3 + 1] - p0y, d3z = pos[v32 * 3 + 2] - p0z;
     const crx = d2y * d3z - d2z * d3y;
     const cry = d2z * d3x - d2x * d3z;
     const crz = d2x * d3y - d2y * d3x;
@@ -3089,11 +3106,11 @@ var PBDSolverCPU = class {
   solveVolumeConstraint(c, dt) {
     const pred = this.state.predicted;
     const masses = this.config.masses;
-    const [v0, v1, v2, v3] = c.vertices;
+    const [v0, v1, v2, v32] = c.vertices;
     const p0x = pred[v0 * 3], p0y = pred[v0 * 3 + 1], p0z = pred[v0 * 3 + 2];
     const p1x = pred[v1 * 3], p1y = pred[v1 * 3 + 1], p1z = pred[v1 * 3 + 2];
     const p2x = pred[v2 * 3], p2y = pred[v2 * 3 + 1], p2z = pred[v2 * 3 + 2];
-    const p3x = pred[v3 * 3], p3y = pred[v3 * 3 + 1], p3z = pred[v3 * 3 + 2];
+    const p3x = pred[v32 * 3], p3y = pred[v32 * 3 + 1], p3z = pred[v32 * 3 + 2];
     const d1x = p1x - p0x, d1y = p1y - p0y, d1z = p1z - p0z;
     const d2x = p2x - p0x, d2y = p2y - p0y, d2z = p2z - p0z;
     const d3x = p3x - p0x, d3y = p3y - p0y, d3z = p3z - p0z;
@@ -3112,7 +3129,7 @@ var PBDSolverCPU = class {
     const w0 = masses[v0] > 0 ? 1 / masses[v0] : 0;
     const w1 = masses[v1] > 0 ? 1 / masses[v1] : 0;
     const w2 = masses[v2] > 0 ? 1 / masses[v2] : 0;
-    const w3 = masses[v3] > 0 ? 1 / masses[v3] : 0;
+    const w3 = masses[v32] > 0 ? 1 / masses[v32] : 0;
     const denom = w0 * (g0x * g0x + g0y * g0y + g0z * g0z) + w1 * (g1x * g1x + g1y * g1y + g1z * g1z) + w2 * (g2x * g2x + g2y * g2y + g2z * g2z) + w3 * (g3x * g3x + g3y * g3y + g3z * g3z);
     if (denom < 1e-7) return;
     const alpha = c.compliance / (dt * dt);
@@ -3133,19 +3150,19 @@ var PBDSolverCPU = class {
       pred[v2 * 3 + 2] += g2z * lambda * w2;
     }
     if (w3 > 0) {
-      pred[v3 * 3] += g3x * lambda * w3;
-      pred[v3 * 3 + 1] += g3y * lambda * w3;
-      pred[v3 * 3 + 2] += g3z * lambda * w3;
+      pred[v32 * 3] += g3x * lambda * w3;
+      pred[v32 * 3 + 1] += g3y * lambda * w3;
+      pred[v32 * 3 + 2] += g3z * lambda * w3;
     }
   }
   solveBendingConstraint(c, dt) {
     const pred = this.state.predicted;
     const masses = this.config.masses;
-    const [v0, v1, v2, v3] = c.vertices;
+    const [v0, v1, v2, v32] = c.vertices;
     const p0x = pred[v0 * 3], p0y = pred[v0 * 3 + 1], p0z = pred[v0 * 3 + 2];
     const p1x = pred[v1 * 3], p1y = pred[v1 * 3 + 1], p1z = pred[v1 * 3 + 2];
     const p2x = pred[v2 * 3], p2y = pred[v2 * 3 + 1], p2z = pred[v2 * 3 + 2];
-    const p3x = pred[v3 * 3], p3y = pred[v3 * 3 + 1], p3z = pred[v3 * 3 + 2];
+    const p3x = pred[v32 * 3], p3y = pred[v32 * 3 + 1], p3z = pred[v32 * 3 + 2];
     const ex = p1x - p0x, ey = p1y - p0y, ez = p1z - p0z;
     const eLen = Math.sqrt(ex * ex + ey * ey + ez * ez);
     if (eLen < 1e-7) return;
@@ -3184,7 +3201,7 @@ var PBDSolverCPU = class {
     const w0 = masses[v0] > 0 ? 1 / masses[v0] : 0;
     const w1 = masses[v1] > 0 ? 1 / masses[v1] : 0;
     const w2 = masses[v2] > 0 ? 1 / masses[v2] : 0;
-    const w3 = masses[v3] > 0 ? 1 / masses[v3] : 0;
+    const w3 = masses[v32] > 0 ? 1 / masses[v32] : 0;
     const denom = w0 * (g0x * g0x + g0y * g0y + g0z * g0z) + w1 * (g1x2 * g1x2 + g1y2 * g1y2 + g1z2 * g1z2) + w2 * (g2x * g2x + g2y * g2y + g2z * g2z) + w3 * (g3x * g3x + g3y * g3y + g3z * g3z);
     const alpha = c.compliance / (dt * dt);
     if (denom + alpha < 1e-10) return;
@@ -3205,9 +3222,9 @@ var PBDSolverCPU = class {
       pred[v2 * 3 + 2] += g2z * lambda * w2;
     }
     if (w3 > 0) {
-      pred[v3 * 3] += g3x * lambda * w3;
-      pred[v3 * 3 + 1] += g3y * lambda * w3;
-      pred[v3 * 3 + 2] += g3z * lambda * w3;
+      pred[v32 * 3] += g3x * lambda * w3;
+      pred[v32 * 3 + 1] += g3y * lambda * w3;
+      pred[v32 * 3 + 2] += g3z * lambda * w3;
     }
   }
   solveAttachmentConstraint(c, dt) {
@@ -5066,6 +5083,13 @@ var PIDLoop = class {
     this.filteredDerivative = math.zero();
     this.prevOutput = math.zero();
   }
+  gains;
+  outputLimit;
+  integralLimit;
+  filterAlpha;
+  derivativeOnMeasurement;
+  backCalcAntiWindup;
+  backCalcGain;
   math;
   integral;
   prevError;
@@ -6244,7 +6268,7 @@ var SoftBodyAdapter = class {
       });
       this.vertexMapping.push(i);
     }
-    const width = Math.sqrt(particles.length);
+    const _width = Math.sqrt(particles.length);
     for (let i = 0; i < particles.length - 1; i++) {
       constraints.push({
         p1: i,
@@ -6269,14 +6293,2335 @@ var SoftBodyAdapter = class {
     this.node.geometry.needsUpdate = true;
   }
 };
+
+// src/physics/VRPhysicsBridge.ts
+var VRPhysicsBridge = class {
+  world;
+  handBodies = /* @__PURE__ */ new Map();
+  // handId -> physicsBodyId
+  lastPositions = /* @__PURE__ */ new Map();
+  lastRotations = /* @__PURE__ */ new Map();
+  onHaptic;
+  constructor(world, onHaptic) {
+    this.world = world;
+    this.onHaptic = onHaptic || (() => {
+    });
+  }
+  update(vrContext, delta) {
+    this.updateHand(vrContext.hands.left, "left", delta);
+    this.updateHand(vrContext.hands.right, "right", delta);
+    this.checkCollisions();
+  }
+  checkCollisions() {
+    const contacts = this.world.getContacts();
+    for (const contact of contacts) {
+      if (contact.type === "begin") {
+        if (contact.bodyA === "hand_left" || contact.bodyB === "hand_left") {
+          this.onHaptic("left", 0.5, 50);
+        }
+        if (contact.bodyA === "hand_right" || contact.bodyB === "hand_right") {
+          this.onHaptic("right", 0.5, 50);
+        }
+      }
+    }
+  }
+  // Make public for testing
+  updateHand(hand, side, delta) {
+    const bodyId = `hand_${side}`;
+    if (!hand) {
+      return;
+    }
+    let body = this.world.getBody(bodyId);
+    if (!body) {
+      const config = {
+        id: bodyId,
+        type: "kinematic",
+        mass: 1,
+        // Infinite mass for kinematic
+        transform: {
+          position: { x: hand.position?.x ?? 0, y: hand.position?.y ?? 0, z: hand.position?.z ?? 0 },
+          rotation: {
+            x: hand.rotation?.x ?? 0,
+            y: hand.rotation?.y ?? 0,
+            z: hand.rotation?.z ?? 0,
+            w: 1
+          }
+        },
+        shape: {
+          type: "sphere",
+          radius: 0.05
+          // 5cm palm radius
+        },
+        material: {
+          friction: 0.5,
+          restitution: 0
+        }
+      };
+      this.world.createBody(config);
+      body = this.world.getBody(bodyId);
+    }
+    if (body) {
+      const safePosX = hand.position?.x ?? 0;
+      const safePosY = hand.position?.y ?? 0;
+      const safePosZ = hand.position?.z ?? 0;
+      const prevPos = this.lastPositions.get(bodyId) || {
+        x: safePosX,
+        y: safePosY,
+        z: safePosZ
+      };
+      const safeDelta = delta > 1e-3 ? delta : 0.016;
+      const rawVelocity = {
+        x: (safePosX - prevPos.x) / safeDelta,
+        y: (safePosY - prevPos.y) / safeDelta,
+        z: (safePosZ - prevPos.z) / safeDelta
+      };
+      const prevVel = body.linearVelocity || { x: 0, y: 0, z: 0 };
+      const smoothingFactor = 0.5;
+      const smoothedVelocity = {
+        x: prevVel.x * (1 - smoothingFactor) + rawVelocity.x * smoothingFactor,
+        y: prevVel.y * (1 - smoothingFactor) + rawVelocity.y * smoothingFactor,
+        z: prevVel.z * (1 - smoothingFactor) + rawVelocity.z * smoothingFactor
+      };
+      this.world.setPosition(bodyId, { x: safePosX, y: safePosY, z: safePosZ });
+      this.world.setLinearVelocity(bodyId, smoothedVelocity);
+      this.lastPositions.set(bodyId, { x: safePosX, y: safePosY, z: safePosZ });
+    }
+  }
+  getHandBodyId(side) {
+    const id = `hand_${side}`;
+    return this.world.getBody(id) ? id : null;
+  }
+};
+
+// src/physics/ClothSim.ts
+var ClothSim = class {
+  particles = [];
+  constraints = [];
+  config;
+  width = 0;
+  height = 0;
+  constructor(config) {
+    this.config = {
+      gravity: -9.81,
+      damping: 0.99,
+      iterations: 5,
+      wind: { x: 0, y: 0, z: 0 },
+      ...config
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Grid
+  // ---------------------------------------------------------------------------
+  createGrid(width, height, spacing) {
+    this.width = width;
+    this.height = height;
+    this.particles = [];
+    this.constraints = [];
+    for (let row = 0; row < height; row++) {
+      for (let col = 0; col < width; col++) {
+        this.particles.push({
+          x: col * spacing,
+          y: 0,
+          z: row * spacing,
+          prevX: col * spacing,
+          prevY: 0,
+          prevZ: row * spacing,
+          mass: 1,
+          pinned: false
+        });
+      }
+    }
+    for (let row = 0; row < height; row++) {
+      for (let col = 0; col < width; col++) {
+        const idx = row * width + col;
+        if (col < width - 1) {
+          this.addConstraint(idx, idx + 1, spacing);
+        }
+        if (row < height - 1) {
+          this.addConstraint(idx, idx + width, spacing);
+        }
+        if (col < width - 1 && row < height - 1) {
+          const diag = spacing * Math.SQRT2;
+          this.addConstraint(idx, idx + width + 1, diag);
+          this.addConstraint(idx + 1, idx + width, diag);
+        }
+      }
+    }
+  }
+  addConstraint(a, b, restLength, stiffness = 1) {
+    this.constraints.push({ particleA: a, particleB: b, restLength, stiffness });
+  }
+  // ---------------------------------------------------------------------------
+  // Pinning
+  // ---------------------------------------------------------------------------
+  pin(index) {
+    if (this.particles[index]) this.particles[index].pinned = true;
+  }
+  unpin(index) {
+    if (this.particles[index]) this.particles[index].pinned = false;
+  }
+  pinTopRow() {
+    for (let col = 0; col < this.width; col++) this.pin(col);
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    for (const p of this.particles) {
+      if (p.pinned) continue;
+      const vx = (p.x - p.prevX) * this.config.damping;
+      const vy = (p.y - p.prevY) * this.config.damping;
+      const vz = (p.z - p.prevZ) * this.config.damping;
+      p.prevX = p.x;
+      p.prevY = p.y;
+      p.prevZ = p.z;
+      p.x += vx + this.config.wind.x * dt * dt / p.mass;
+      p.y += vy + this.config.gravity * dt * dt;
+      p.z += vz + this.config.wind.z * dt * dt / p.mass;
+    }
+    for (let iter = 0; iter < this.config.iterations; iter++) {
+      for (const c of this.constraints) {
+        const a = this.particles[c.particleA];
+        const b = this.particles[c.particleB];
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        const dz = b.z - a.z;
+        const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        if (dist === 0) continue;
+        const diff = (c.restLength - dist) / dist * c.stiffness * 0.5;
+        const ox = dx * diff;
+        const oy = dy * diff;
+        const oz = dz * diff;
+        if (!a.pinned) {
+          a.x -= ox;
+          a.y -= oy;
+          a.z -= oz;
+        }
+        if (!b.pinned) {
+          b.x += ox;
+          b.y += oy;
+          b.z += oz;
+        }
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Wind
+  // ---------------------------------------------------------------------------
+  setWind(x, y, z) {
+    this.config.wind = { x, y, z };
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getParticle(index) {
+    return this.particles[index];
+  }
+  getParticleCount() {
+    return this.particles.length;
+  }
+  getConstraintCount() {
+    return this.constraints.length;
+  }
+  getGridSize() {
+    return { width: this.width, height: this.height };
+  }
+  getAABB() {
+    let minX = Infinity, minY = Infinity, minZ = Infinity;
+    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+    for (const p of this.particles) {
+      minX = Math.min(minX, p.x);
+      minY = Math.min(minY, p.y);
+      minZ = Math.min(minZ, p.z);
+      maxX = Math.max(maxX, p.x);
+      maxY = Math.max(maxY, p.y);
+      maxZ = Math.max(maxZ, p.z);
+    }
+    return { min: { x: minX, y: minY, z: minZ }, max: { x: maxX, y: maxY, z: maxZ } };
+  }
+};
+
+// src/physics/ConstraintSolver.ts
+function v3(x, y, z) {
+  return { x, y, z };
+}
+function v3Add(a, b) {
+  return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+}
+function v3Sub(a, b) {
+  return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+}
+function v3Scale(v, s) {
+  return { x: v.x * s, y: v.y * s, z: v.z * s };
+}
+function v3Dot(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function v3Length(v) {
+  return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+}
+function v3Normalize(v) {
+  const len = v3Length(v);
+  return len > 1e-10 ? v3Scale(v, 1 / len) : v3(0, 0, 0);
+}
+function v3Zero() {
+  return { x: 0, y: 0, z: 0 };
+}
+var DEFAULT_CONFIG2 = {
+  iterations: 10,
+  baumgarte: 0.2,
+  warmStarting: true,
+  slop: 5e-3
+};
+var ConstraintSolver = class {
+  config;
+  solved = [];
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+  }
+  // ---------------------------------------------------------------------------
+  // Public API
+  // ---------------------------------------------------------------------------
+  /**
+   * Add a constraint to be solved.
+   */
+  addConstraint(constraint, bodyA, bodyB = null) {
+    this.solved.push({
+      constraint,
+      bodyA,
+      bodyB,
+      accumulatedImpulse: v3Zero(),
+      accumulatedAngularImpulse: v3Zero(),
+      broken: false
+    });
+  }
+  /**
+   * Remove a constraint by ID.
+   */
+  removeConstraint(constraintId) {
+    const idx = this.solved.findIndex((s) => s.constraint.id === constraintId);
+    if (idx < 0) return false;
+    this.solved.splice(idx, 1);
+    return true;
+  }
+  /**
+   * Get all active constraints.
+   */
+  getConstraints() {
+    return this.solved.filter((s) => !s.broken).map((s) => s.constraint);
+  }
+  /**
+   * Solve all constraints for one timestep.
+   * Returns velocity corrections to apply to rigid bodies.
+   */
+  solve(dt) {
+    const corrections = /* @__PURE__ */ new Map();
+    if (this.config.warmStarting) {
+      for (const sc of this.solved) {
+        if (sc.broken) continue;
+        this.applyWarmStart(sc, corrections);
+      }
+    }
+    for (let iter = 0; iter < this.config.iterations; iter++) {
+      for (const sc of this.solved) {
+        if (sc.broken) continue;
+        this.solveConstraint(sc, dt, corrections);
+      }
+    }
+    for (const sc of this.solved) {
+      if (sc.broken) continue;
+      const breakForce = sc.constraint.breakForce;
+      if (breakForce !== void 0 && breakForce > 0) {
+        const impulseLen = v3Length(sc.accumulatedImpulse) / Math.max(dt, 1e-6);
+        if (impulseLen > breakForce) {
+          sc.broken = true;
+        }
+      }
+    }
+    return corrections;
+  }
+  /**
+   * Get broken constraint IDs.
+   */
+  getBrokenConstraints() {
+    return this.solved.filter((s) => s.broken).map((s) => s.constraint.id);
+  }
+  /**
+   * Clear all constraints.
+   */
+  clear() {
+    this.solved = [];
+  }
+  // ---------------------------------------------------------------------------
+  // Internal: Dispatch
+  // ---------------------------------------------------------------------------
+  solveConstraint(sc, dt, corrections) {
+    switch (sc.constraint.type) {
+      case "fixed":
+        this.solveFixed(sc, dt, corrections);
+        break;
+      case "distance":
+        this.solveDistance(
+          sc,
+          dt,
+          corrections
+        );
+        break;
+      case "spring":
+        this.solveSpring(
+          sc,
+          dt,
+          corrections
+        );
+        break;
+      case "hinge":
+        this.solveHinge(sc, dt, corrections);
+        break;
+      case "ball":
+        this.solveBall(sc, dt, corrections);
+        break;
+      case "slider":
+        this.solveSlider(
+          sc,
+          dt,
+          corrections
+        );
+        break;
+      case "cone":
+        this.solveCone(sc, dt, corrections);
+        break;
+      case "generic6dof":
+        this.solveGeneric6DOF(
+          sc,
+          dt,
+          corrections
+        );
+        break;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Constraint Solvers
+  // ---------------------------------------------------------------------------
+  solveFixed(sc, dt, corrections) {
+    const c = sc.constraint;
+    const pivotWorld = v3Add(sc.bodyA.position, c.pivotA);
+    const targetWorld = sc.bodyB ? v3Add(sc.bodyB.position, c.pivotB || v3Zero()) : pivotWorld;
+    const error = v3Sub(targetWorld, pivotWorld);
+    const correction = v3Scale(error, this.config.baumgarte / Math.max(dt, 1e-6));
+    this.accumulateCorrection(corrections, sc.bodyA.id, correction, v3Zero());
+    if (sc.bodyB) {
+      this.accumulateCorrection(corrections, sc.bodyB.id, v3Scale(correction, -1), v3Zero());
+    }
+    sc.accumulatedImpulse = v3Add(sc.accumulatedImpulse, correction);
+  }
+  solveDistance(sc, dt, corrections) {
+    const c = sc.constraint;
+    const anchorA = v3Add(sc.bodyA.position, c.pivotA);
+    const anchorB = sc.bodyB ? v3Add(sc.bodyB.position, c.pivotB || v3Zero()) : v3Add(sc.bodyA.position, v3(c.distance, 0, 0));
+    const delta = v3Sub(anchorB, anchorA);
+    const currentDist = v3Length(delta);
+    const dir = currentDist > 1e-10 ? v3Scale(delta, 1 / currentDist) : v3(1, 0, 0);
+    const penetration = currentDist - c.distance;
+    if (Math.abs(penetration) < this.config.slop) return;
+    const stiffness = c.stiffness ?? 1;
+    const baumgarte = this.config.baumgarte * stiffness;
+    const impulse = v3Scale(dir, penetration * baumgarte / Math.max(dt, 1e-6));
+    this.accumulateCorrection(corrections, sc.bodyA.id, impulse, v3Zero());
+    if (sc.bodyB) {
+      this.accumulateCorrection(corrections, sc.bodyB.id, v3Scale(impulse, -1), v3Zero());
+    }
+    sc.accumulatedImpulse = v3Add(sc.accumulatedImpulse, impulse);
+  }
+  solveSpring(sc, dt, corrections) {
+    const c = sc.constraint;
+    const anchorA = v3Add(sc.bodyA.position, c.pivotA);
+    const anchorB = sc.bodyB ? v3Add(sc.bodyB.position, c.pivotB || v3Zero()) : v3Add(sc.bodyA.position, v3(c.restLength, 0, 0));
+    const delta = v3Sub(anchorB, anchorA);
+    const currentLen = v3Length(delta);
+    const dir = currentLen > 1e-10 ? v3Scale(delta, 1 / currentLen) : v3(1, 0, 0);
+    const displacement = currentLen - c.restLength;
+    const springForce = -c.stiffness * displacement;
+    const relVel = sc.bodyB ? v3Sub(sc.bodyB.linearVelocity, sc.bodyA.linearVelocity) : v3Scale(sc.bodyA.linearVelocity, -1);
+    const dampingForce = -c.damping * v3Dot(relVel, dir);
+    const totalForce = springForce + dampingForce;
+    const impulse = v3Scale(dir, totalForce * dt);
+    this.accumulateCorrection(corrections, sc.bodyA.id, v3Scale(impulse, -1), v3Zero());
+    if (sc.bodyB) {
+      this.accumulateCorrection(corrections, sc.bodyB.id, impulse, v3Zero());
+    }
+    sc.accumulatedImpulse = v3Add(sc.accumulatedImpulse, impulse);
+  }
+  solveHinge(sc, dt, corrections) {
+    const c = sc.constraint;
+    const pivotWorld = v3Add(sc.bodyA.position, c.pivotA);
+    const targetWorld = sc.bodyB ? v3Add(sc.bodyB.position, c.pivotB || v3Zero()) : pivotWorld;
+    const posError = v3Sub(targetWorld, pivotWorld);
+    const posCorrection = v3Scale(posError, this.config.baumgarte / Math.max(dt, 1e-6));
+    this.accumulateCorrection(corrections, sc.bodyA.id, posCorrection, v3Zero());
+    if (sc.bodyB) {
+      this.accumulateCorrection(corrections, sc.bodyB.id, v3Scale(posCorrection, -1), v3Zero());
+    }
+    if (c.motor) {
+      const axis = v3Normalize(c.axisA);
+      const currentAngVel = v3Dot(sc.bodyA.angularVelocity, axis);
+      const velError = c.motor.targetVelocity - currentAngVel;
+      const motorImpulse = Math.min(Math.abs(velError * dt), c.motor.maxForce * dt) * Math.sign(velError);
+      const angImpulse = v3Scale(axis, motorImpulse);
+      this.accumulateCorrection(corrections, sc.bodyA.id, v3Zero(), angImpulse);
+    }
+    sc.accumulatedImpulse = v3Add(sc.accumulatedImpulse, posCorrection);
+  }
+  solveBall(sc, dt, corrections) {
+    const c = sc.constraint;
+    const pivotWorld = v3Add(sc.bodyA.position, c.pivotA);
+    const targetWorld = sc.bodyB ? v3Add(sc.bodyB.position, c.pivotB || v3Zero()) : pivotWorld;
+    const error = v3Sub(targetWorld, pivotWorld);
+    const correction = v3Scale(error, this.config.baumgarte / Math.max(dt, 1e-6));
+    this.accumulateCorrection(corrections, sc.bodyA.id, correction, v3Zero());
+    if (sc.bodyB) {
+      this.accumulateCorrection(corrections, sc.bodyB.id, v3Scale(correction, -1), v3Zero());
+    }
+    sc.accumulatedImpulse = v3Add(sc.accumulatedImpulse, correction);
+  }
+  solveSlider(sc, dt, corrections) {
+    const c = sc.constraint;
+    const axis = v3Normalize(c.axisA);
+    const pivotWorld = v3Add(sc.bodyA.position, c.pivotA);
+    const targetWorld = sc.bodyB ? v3Add(sc.bodyB.position, c.pivotB || v3Zero()) : pivotWorld;
+    const delta = v3Sub(targetWorld, pivotWorld);
+    const onAxis = v3Dot(delta, axis);
+    const perp = v3Sub(delta, v3Scale(axis, onAxis));
+    const perpCorrection = v3Scale(perp, this.config.baumgarte / Math.max(dt, 1e-6));
+    this.accumulateCorrection(corrections, sc.bodyA.id, perpCorrection, v3Zero());
+    if (sc.bodyB) {
+      this.accumulateCorrection(corrections, sc.bodyB.id, v3Scale(perpCorrection, -1), v3Zero());
+    }
+    if (c.limits) {
+      if (onAxis < c.limits.low) {
+        const limitImpulse = v3Scale(
+          axis,
+          (c.limits.low - onAxis) * this.config.baumgarte / Math.max(dt, 1e-6)
+        );
+        this.accumulateCorrection(corrections, sc.bodyA.id, limitImpulse, v3Zero());
+      } else if (onAxis > c.limits.high) {
+        const limitImpulse = v3Scale(
+          axis,
+          (c.limits.high - onAxis) * this.config.baumgarte / Math.max(dt, 1e-6)
+        );
+        this.accumulateCorrection(corrections, sc.bodyA.id, limitImpulse, v3Zero());
+      }
+    }
+    sc.accumulatedImpulse = v3Add(sc.accumulatedImpulse, perpCorrection);
+  }
+  solveCone(sc, dt, corrections) {
+    const c = sc.constraint;
+    const pivotWorld = v3Add(sc.bodyA.position, c.pivotA);
+    const targetWorld = sc.bodyB ? v3Add(sc.bodyB.position, c.pivotB || v3Zero()) : pivotWorld;
+    const posError = v3Sub(targetWorld, pivotWorld);
+    const posCorrection = v3Scale(posError, this.config.baumgarte / Math.max(dt, 1e-6));
+    this.accumulateCorrection(corrections, sc.bodyA.id, posCorrection, v3Zero());
+    if (sc.bodyB) {
+      this.accumulateCorrection(corrections, sc.bodyB.id, v3Scale(posCorrection, -1), v3Zero());
+    }
+    const twistAxis = v3Normalize(c.axisA);
+    const twistVel = v3Dot(sc.bodyA.angularVelocity, twistAxis);
+    if (Math.abs(twistVel) > c.twistSpan) {
+      const twistCorrection = v3Scale(twistAxis, -twistVel * 0.5);
+      this.accumulateCorrection(corrections, sc.bodyA.id, v3Zero(), twistCorrection);
+    }
+    sc.accumulatedImpulse = v3Add(sc.accumulatedImpulse, posCorrection);
+  }
+  solveGeneric6DOF(sc, dt, corrections) {
+    const c = sc.constraint;
+    const pos = sc.bodyA.position;
+    const linCorrection = v3Zero();
+    if (pos.x < c.linearLowerLimit.x)
+      linCorrection.x = (c.linearLowerLimit.x - pos.x) * this.config.baumgarte / Math.max(dt, 1e-6);
+    if (pos.x > c.linearUpperLimit.x)
+      linCorrection.x = (c.linearUpperLimit.x - pos.x) * this.config.baumgarte / Math.max(dt, 1e-6);
+    if (pos.y < c.linearLowerLimit.y)
+      linCorrection.y = (c.linearLowerLimit.y - pos.y) * this.config.baumgarte / Math.max(dt, 1e-6);
+    if (pos.y > c.linearUpperLimit.y)
+      linCorrection.y = (c.linearUpperLimit.y - pos.y) * this.config.baumgarte / Math.max(dt, 1e-6);
+    if (pos.z < c.linearLowerLimit.z)
+      linCorrection.z = (c.linearLowerLimit.z - pos.z) * this.config.baumgarte / Math.max(dt, 1e-6);
+    if (pos.z > c.linearUpperLimit.z)
+      linCorrection.z = (c.linearUpperLimit.z - pos.z) * this.config.baumgarte / Math.max(dt, 1e-6);
+    this.accumulateCorrection(corrections, sc.bodyA.id, linCorrection, v3Zero());
+    sc.accumulatedImpulse = v3Add(sc.accumulatedImpulse, linCorrection);
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  applyWarmStart(sc, corrections) {
+    const scaled = v3Scale(sc.accumulatedImpulse, 0.8);
+    this.accumulateCorrection(corrections, sc.bodyA.id, scaled, v3Zero());
+    if (sc.bodyB) {
+      this.accumulateCorrection(corrections, sc.bodyB.id, v3Scale(scaled, -1), v3Zero());
+    }
+  }
+  accumulateCorrection(corrections, bodyId, linear, angular) {
+    const existing = corrections.get(bodyId) || {
+      linearVelocity: v3Zero(),
+      angularVelocity: v3Zero()
+    };
+    corrections.set(bodyId, {
+      linearVelocity: v3Add(existing.linearVelocity, linear),
+      angularVelocity: v3Add(existing.angularVelocity, angular)
+    });
+  }
+};
+
+// src/physics/DeformableMesh.ts
+var DeformableMesh = class {
+  vertices = [];
+  springs = [];
+  config;
+  restCentroid = { x: 0, y: 0, z: 0 };
+  constructor(config) {
+    this.config = {
+      stiffness: 100,
+      damping: 0.95,
+      shapeMatchingStrength: 0.5,
+      maxDisplacement: 5,
+      plasticity: 0,
+      ...config
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Mesh Setup
+  // ---------------------------------------------------------------------------
+  setVertices(positions) {
+    this.vertices = positions.map((p) => ({
+      rest: { ...p },
+      current: { ...p },
+      velocity: { x: 0, y: 0, z: 0 },
+      mass: 1,
+      locked: false
+    }));
+    this.computeRestCentroid();
+  }
+  addSpring(a, b, stiffness, damping) {
+    const pa = this.vertices[a].rest, pb = this.vertices[b].rest;
+    const dx = pb.x - pa.x, dy = pb.y - pa.y, dz = pb.z - pa.z;
+    this.springs.push({
+      a,
+      b,
+      restLength: Math.sqrt(dx * dx + dy * dy + dz * dz),
+      stiffness: stiffness ?? this.config.stiffness,
+      damping: damping ?? 5
+    });
+  }
+  autoConnectRadius(radius) {
+    for (let i = 0; i < this.vertices.length; i++) {
+      for (let j = i + 1; j < this.vertices.length; j++) {
+        const a = this.vertices[i].rest, b = this.vertices[j].rest;
+        const dx = b.x - a.x, dy = b.y - a.y, dz = b.z - a.z;
+        const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        if (dist <= radius) this.addSpring(i, j);
+      }
+    }
+  }
+  computeRestCentroid() {
+    let cx = 0, cy = 0, cz = 0;
+    for (const v of this.vertices) {
+      cx += v.rest.x;
+      cy += v.rest.y;
+      cz += v.rest.z;
+    }
+    const n = this.vertices.length || 1;
+    this.restCentroid = { x: cx / n, y: cy / n, z: cz / n };
+  }
+  // ---------------------------------------------------------------------------
+  // Deformation
+  // ---------------------------------------------------------------------------
+  applyImpact(center, radius, force) {
+    for (const v of this.vertices) {
+      if (v.locked) continue;
+      const dx = v.current.x - center.x;
+      const dy = v.current.y - center.y;
+      const dz = v.current.z - center.z;
+      const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      if (dist > radius || dist === 0) continue;
+      const falloff = 1 - dist / radius;
+      const strength = force * falloff / v.mass;
+      const n = dist;
+      v.velocity.x += dx / n * strength;
+      v.velocity.y += dy / n * strength;
+      v.velocity.z += dz / n * strength;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Simulation
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    for (const s of this.springs) {
+      const a = this.vertices[s.a], b = this.vertices[s.b];
+      const dx = b.current.x - a.current.x;
+      const dy = b.current.y - a.current.y;
+      const dz = b.current.z - a.current.z;
+      const dist = Math.sqrt(dx * dx + dy * dy + dz * dz) || 1e-4;
+      const stretch = dist - s.restLength;
+      const fx = dx / dist * stretch * s.stiffness;
+      const fy = dy / dist * stretch * s.stiffness;
+      const fz = dz / dist * stretch * s.stiffness;
+      const dvx = b.velocity.x - a.velocity.x;
+      const dvy = b.velocity.y - a.velocity.y;
+      const dvz = b.velocity.z - a.velocity.z;
+      if (!a.locked) {
+        a.velocity.x += (fx + dvx * s.damping) * dt / a.mass;
+        a.velocity.y += (fy + dvy * s.damping) * dt / a.mass;
+        a.velocity.z += (fz + dvz * s.damping) * dt / a.mass;
+      }
+      if (!b.locked) {
+        b.velocity.x -= (fx + dvx * s.damping) * dt / b.mass;
+        b.velocity.y -= (fy + dvy * s.damping) * dt / b.mass;
+        b.velocity.z -= (fz + dvz * s.damping) * dt / b.mass;
+      }
+    }
+    if (this.config.shapeMatchingStrength > 0) {
+      let cx = 0, cy = 0, cz = 0;
+      for (const v of this.vertices) {
+        cx += v.current.x;
+        cy += v.current.y;
+        cz += v.current.z;
+      }
+      const n = this.vertices.length || 1;
+      cx /= n;
+      cy /= n;
+      cz /= n;
+      for (const v of this.vertices) {
+        if (v.locked) continue;
+        const goalX = v.rest.x - this.restCentroid.x + cx;
+        const goalY = v.rest.y - this.restCentroid.y + cy;
+        const goalZ = v.rest.z - this.restCentroid.z + cz;
+        v.velocity.x += (goalX - v.current.x) * this.config.shapeMatchingStrength * dt * 10;
+        v.velocity.y += (goalY - v.current.y) * this.config.shapeMatchingStrength * dt * 10;
+        v.velocity.z += (goalZ - v.current.z) * this.config.shapeMatchingStrength * dt * 10;
+      }
+    }
+    for (const v of this.vertices) {
+      if (v.locked) continue;
+      v.velocity.x *= this.config.damping;
+      v.velocity.y *= this.config.damping;
+      v.velocity.z *= this.config.damping;
+      v.current.x += v.velocity.x * dt;
+      v.current.y += v.velocity.y * dt;
+      v.current.z += v.velocity.z * dt;
+      const dx = v.current.x - v.rest.x;
+      const dy = v.current.y - v.rest.y;
+      const dz = v.current.z - v.rest.z;
+      const disp = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      if (disp > this.config.maxDisplacement) {
+        const scale = this.config.maxDisplacement / disp;
+        v.current.x = v.rest.x + dx * scale;
+        v.current.y = v.rest.y + dy * scale;
+        v.current.z = v.rest.z + dz * scale;
+      }
+      if (this.config.plasticity > 0 && disp > 0.01) {
+        v.rest.x += dx * this.config.plasticity * dt;
+        v.rest.y += dy * this.config.plasticity * dt;
+        v.rest.z += dz * this.config.plasticity * dt;
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getVertices() {
+    return this.vertices;
+  }
+  getVertex(index) {
+    return this.vertices[index];
+  }
+  getVertexCount() {
+    return this.vertices.length;
+  }
+  getSpringCount() {
+    return this.springs.length;
+  }
+  getDisplacement(index) {
+    const v = this.vertices[index];
+    if (!v) return 0;
+    const dx = v.current.x - v.rest.x, dy = v.current.y - v.rest.y, dz = v.current.z - v.rest.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+  getMaxDisplacement() {
+    let max = 0;
+    for (let i = 0; i < this.vertices.length; i++) max = Math.max(max, this.getDisplacement(i));
+    return max;
+  }
+};
+
+// src/physics/FluidSim.ts
+var FluidSim = class {
+  particles = [];
+  config;
+  constructor(config) {
+    this.config = {
+      restDensity: 1e3,
+      gasConstant: 2e3,
+      viscosity: 200,
+      surfaceTension: 0.5,
+      gravity: { x: 0, y: -9.81, z: 0 },
+      smoothingRadius: 1,
+      timeStep: 0.016,
+      boundaryMin: { x: -10, y: -10, z: -10 },
+      boundaryMax: { x: 10, y: 10, z: 10 },
+      boundaryDamping: 0.3,
+      ...config
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Particle Management
+  // ---------------------------------------------------------------------------
+  addParticle(position, velocity) {
+    this.particles.push({
+      position: { ...position },
+      velocity: velocity ? { ...velocity } : { x: 0, y: 0, z: 0 },
+      density: this.config.restDensity,
+      pressure: 0,
+      mass: 1
+    });
+  }
+  addBlock(min, max, spacing) {
+    let count = 0;
+    for (let x = min.x; x <= max.x; x += spacing) {
+      for (let y = min.y; y <= max.y; y += spacing) {
+        for (let z = min.z; z <= max.z; z += spacing) {
+          this.addParticle([x, y, z]);
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+  // ---------------------------------------------------------------------------
+  // SPH Kernels
+  // ---------------------------------------------------------------------------
+  poly6(r2, h) {
+    if (r2 >= h * h) return 0;
+    const h2 = h * h;
+    const diff = h2 - r2;
+    return 315 / (64 * Math.PI * Math.pow(h, 9)) * diff * diff * diff;
+  }
+  spikyGrad(r, h) {
+    if (r >= h || r === 0) return 0;
+    const diff = h - r;
+    return -(45 / (Math.PI * Math.pow(h, 6))) * diff * diff;
+  }
+  viscosityLaplacian(r, h) {
+    if (r >= h) return 0;
+    return 45 / (Math.PI * Math.pow(h, 6)) * (h - r);
+  }
+  // ---------------------------------------------------------------------------
+  // Simulation Step
+  // ---------------------------------------------------------------------------
+  update() {
+    const h = this.config.smoothingRadius;
+    const dt = this.config.timeStep;
+    for (const pi of this.particles) {
+      pi.density = 0;
+      for (const pj of this.particles) {
+        const dx = pj.position[0] - pi.position[0];
+        const dy = pj.position[1] - pi.position[1];
+        const dz = pj.position[2] - pi.position[2];
+        const r2 = dx * dx + dy * dy + dz * dz;
+        pi.density += pj.mass * this.poly6(r2, h);
+      }
+      pi.pressure = this.config.gasConstant * (pi.density - this.config.restDensity);
+    }
+    for (const pi of this.particles) {
+      let fx = 0, fy = 0, fz = 0;
+      for (const pj of this.particles) {
+        if (pi === pj) continue;
+        const dx = pj.position[0] - pi.position[0];
+        const dy = pj.position[1] - pi.position[1];
+        const dz = pj.position[2] - pi.position[2];
+        const r = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        if (r < h && r > 0) {
+          const pressGrad = this.spikyGrad(r, h);
+          const pressScale = -pj.mass * (pi.pressure + pj.pressure) / (2 * pj.density || 1) * pressGrad;
+          fx += dx / r * pressScale;
+          fy += dy / r * pressScale;
+          fz += dz / r * pressScale;
+          const viscLap = this.viscosityLaplacian(r, h);
+          const viscScale = this.config.viscosity * pj.mass / (pj.density || 1) * viscLap;
+          fx += (pj.velocity.x - pi.velocity.x) * viscScale;
+          fy += (pj.velocity.y - pi.velocity.y) * viscScale;
+          fz += (pj.velocity.z - pi.velocity.z) * viscScale;
+        }
+      }
+      fx += this.config.gravity.x * pi.density;
+      fy += this.config.gravity.y * pi.density;
+      fz += this.config.gravity.z * pi.density;
+      const invDensity = 1 / (pi.density || 1);
+      pi.velocity.x += fx * invDensity * dt;
+      pi.velocity.y += fy * invDensity * dt;
+      pi.velocity.z += fz * invDensity * dt;
+      pi.position[0] += pi.velocity[0] * dt;
+      pi.position[1] += pi.velocity[1] * dt;
+      pi.position[2] += pi.velocity[2] * dt;
+    }
+    this.enforceBoundaries();
+  }
+  enforceBoundaries() {
+    const { boundaryMin: mn, boundaryMax: mx, boundaryDamping: d } = this.config;
+    for (const p of this.particles) {
+      if (p.position[0] < mn[0]) {
+        p.position[0] = mn[0];
+        p.velocity.x *= -d;
+      }
+      if (p.position[0] > mx[0]) {
+        p.position[0] = mx[0];
+        p.velocity.x *= -d;
+      }
+      if (p.position[1] < mn[1]) {
+        p.position[1] = mn[1];
+        p.velocity.y *= -d;
+      }
+      if (p.position[1] > mx[1]) {
+        p.position[1] = mx[1];
+        p.velocity.y *= -d;
+      }
+      if (p.position[2] < mn[2]) {
+        p.position[2] = mn[2];
+        p.velocity.z *= -d;
+      }
+      if (p.position[2] > mx[2]) {
+        p.position[2] = mx[2];
+        p.velocity.z *= -d;
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getParticles() {
+    return this.particles;
+  }
+  getParticleCount() {
+    return this.particles.length;
+  }
+  getAverageDensity() {
+    if (this.particles.length === 0) return 0;
+    return this.particles.reduce((s, p) => s + p.density, 0) / this.particles.length;
+  }
+  getKineticEnergy() {
+    return this.particles.reduce((s, p) => {
+      return s + 0.5 * p.mass * (p.velocity.x ** 2 + p.velocity.y ** 2 + p.velocity.z ** 2);
+    }, 0);
+  }
+  clear() {
+    this.particles = [];
+  }
+  setConfig(config) {
+    Object.assign(this.config, config);
+  }
+};
+
+// src/physics/JointSystem.ts
+var _jointId = 0;
+var JointSystem = class {
+  joints = /* @__PURE__ */ new Map();
+  states = /* @__PURE__ */ new Map();
+  bodyJoints = /* @__PURE__ */ new Map();
+  // body → joint ids
+  // ---------------------------------------------------------------------------
+  // Joint Creation
+  // ---------------------------------------------------------------------------
+  createJoint(type, bodyA, bodyB, config) {
+    const id = config?.id ?? `joint_${_jointId++}`;
+    const joint = {
+      id,
+      type,
+      bodyA,
+      bodyB,
+      anchorA: config?.anchorA ?? { x: 0, y: 0, z: 0 },
+      anchorB: config?.anchorB ?? { x: 0, y: 0, z: 0 },
+      axis: config?.axis ?? { x: 0, y: 1, z: 0 },
+      limits: config?.limits,
+      breakForce: config?.breakForce ?? Infinity,
+      stiffness: config?.stiffness ?? 1,
+      damping: config?.damping ?? 0.1,
+      motorSpeed: config?.motorSpeed ?? 0,
+      motorForce: config?.motorForce ?? 0,
+      broken: false,
+      enabled: true
+    };
+    this.joints.set(id, joint);
+    this.states.set(id, { currentForce: 0, currentAngle: 0, currentDistance: 0 });
+    for (const body of [bodyA, bodyB]) {
+      if (!this.bodyJoints.has(body)) this.bodyJoints.set(body, /* @__PURE__ */ new Set());
+      this.bodyJoints.get(body).add(id);
+    }
+    return joint;
+  }
+  removeJoint(id) {
+    const joint = this.joints.get(id);
+    if (!joint) return false;
+    this.bodyJoints.get(joint.bodyA)?.delete(id);
+    this.bodyJoints.get(joint.bodyB)?.delete(id);
+    this.states.delete(id);
+    return this.joints.delete(id);
+  }
+  // ---------------------------------------------------------------------------
+  // Constraint Solving
+  // ---------------------------------------------------------------------------
+  solve(dt) {
+    for (const [id, joint] of this.joints) {
+      if (!joint.enabled || joint.broken) continue;
+      const state = this.states.get(id);
+      switch (joint.type) {
+        case "spring": {
+          const restLength = this.distance3D(joint.anchorA, joint.anchorB);
+          const force = joint.stiffness * (state.currentDistance - restLength) + joint.damping * state.currentForce;
+          state.currentForce = force;
+          break;
+        }
+        case "distance": {
+          const target = this.distance3D(joint.anchorA, joint.anchorB);
+          state.currentDistance = target;
+          state.currentForce = joint.stiffness * Math.abs(state.currentDistance - target);
+          break;
+        }
+        case "hinge": {
+          if (joint.limits) {
+            state.currentAngle = Math.max(
+              joint.limits.min,
+              Math.min(joint.limits.max, state.currentAngle)
+            );
+          }
+          if (joint.motorForce > 0) {
+            state.currentAngle += joint.motorSpeed * dt;
+          }
+          state.currentForce = Math.abs(joint.stiffness * state.currentAngle);
+          break;
+        }
+        case "slider": {
+          if (joint.limits) {
+            state.currentDistance = Math.max(
+              joint.limits.min,
+              Math.min(joint.limits.max, state.currentDistance)
+            );
+          }
+          state.currentForce = joint.stiffness * Math.abs(state.currentDistance);
+          break;
+        }
+        default:
+          state.currentForce = 0;
+          break;
+      }
+      if (state.currentForce > joint.breakForce) {
+        joint.broken = true;
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Controls
+  // ---------------------------------------------------------------------------
+  setMotor(id, speed, force) {
+    const joint = this.joints.get(id);
+    if (joint) {
+      joint.motorSpeed = speed;
+      joint.motorForce = force;
+    }
+  }
+  setEnabled(id, enabled) {
+    const joint = this.joints.get(id);
+    if (joint) joint.enabled = enabled;
+  }
+  setAngle(id, angle) {
+    const state = this.states.get(id);
+    if (state) state.currentAngle = angle;
+  }
+  setDistance(id, dist) {
+    const state = this.states.get(id);
+    if (state) state.currentDistance = dist;
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getJoint(id) {
+    return this.joints.get(id);
+  }
+  getState(id) {
+    return this.states.get(id);
+  }
+  getJointCount() {
+    return this.joints.size;
+  }
+  getBrokenJoints() {
+    return [...this.joints.values()].filter((j) => j.broken);
+  }
+  getJointsForBody(bodyId) {
+    const ids = this.bodyJoints.get(bodyId);
+    if (!ids) return [];
+    return [...ids].map((id) => this.joints.get(id)).filter(Boolean);
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  distance3D(a, b) {
+    const dx = b.x - a.x, dy = b.y - a.y, dz = b.z - a.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+};
+
+// src/physics/RagdollController.ts
+var RagdollController = class {
+  bones = /* @__PURE__ */ new Map();
+  rootBone = null;
+  state = "active";
+  blendFactor = 0;
+  // 0 = animated, 1 = ragdoll
+  blendSpeed = 2;
+  config;
+  constructor(config) {
+    this.config = { gravity: -9.81, damping: 0.98, iterations: 4, ...config };
+  }
+  // ---------------------------------------------------------------------------
+  // Bone Chain Setup
+  // ---------------------------------------------------------------------------
+  addBone(name, parentId, mass, length, limits) {
+    const bone = {
+      id: name,
+      name,
+      parentId,
+      position: [0, 0, 0],
+      rotation: { x: 0, y: 0, z: 0 },
+      velocity: { x: 0, y: 0, z: 0 },
+      angularVelocity: { x: 0, y: 0, z: 0 },
+      mass,
+      length,
+      jointLimits: limits ?? { min: { x: -1, y: -1, z: -1 }, max: { x: 1, y: 1, z: 1 } }
+    };
+    this.bones.set(name, bone);
+    if (!parentId) this.rootBone = name;
+    return bone;
+  }
+  removeBone(name) {
+    return this.bones.delete(name);
+  }
+  // ---------------------------------------------------------------------------
+  // State Control
+  // ---------------------------------------------------------------------------
+  activate() {
+    this.state = "active";
+    this.blendFactor = 0;
+  }
+  goRagdoll() {
+    this.state = "ragdoll";
+    this.blendFactor = 1;
+  }
+  startBlend(toRagdoll = true) {
+    this.state = "blending";
+    this.blendFactor = toRagdoll ? 0 : 1;
+  }
+  getState() {
+    return this.state;
+  }
+  getBlendFactor() {
+    return this.blendFactor;
+  }
+  // ---------------------------------------------------------------------------
+  // Physics Update
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    if (this.state === "blending") {
+      this.blendFactor = Math.min(1, this.blendFactor + this.blendSpeed * dt);
+      if (this.blendFactor >= 1) this.state = "ragdoll";
+    }
+    if (this.state === "active") return;
+    for (const bone of this.bones.values()) {
+      bone.velocity.y += this.config.gravity * dt * this.blendFactor;
+      bone.velocity.x *= this.config.damping;
+      bone.velocity.y *= this.config.damping;
+      bone.velocity.z *= this.config.damping;
+      bone.position[0] += bone.velocity[0] * dt;
+      bone.position[1] += bone.velocity[1] * dt;
+      bone.position[2] += bone.velocity[2] * dt;
+    }
+    for (let iter = 0; iter < this.config.iterations; iter++) {
+      for (const bone of this.bones.values()) {
+        if (!bone.parentId) continue;
+        const parent = this.bones.get(bone.parentId);
+        if (!parent) continue;
+        const dx = bone.position[0] - parent.position[0];
+        const dy = bone.position[1] - parent.position[1];
+        const dz = bone.position[2] - parent.position[2];
+        const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        if (dist > 0 && dist !== bone.length) {
+          const diff = (dist - bone.length) / dist;
+          const mx = dx * diff * 0.5;
+          const my = dy * diff * 0.5;
+          const mz = dz * diff * 0.5;
+          bone.position[0] -= mx;
+          bone.position[1] -= my;
+          bone.position[2] -= mz;
+          parent.position[0] += mx;
+          parent.position[1] += my;
+          parent.position[2] += mz;
+        }
+        bone.rotation.x = Math.max(
+          bone.jointLimits.min.x,
+          Math.min(bone.jointLimits.max.x, bone.rotation.x)
+        );
+        bone.rotation.y = Math.max(
+          bone.jointLimits.min.y,
+          Math.min(bone.jointLimits.max.y, bone.rotation.y)
+        );
+        bone.rotation.z = Math.max(
+          bone.jointLimits.min.z,
+          Math.min(bone.jointLimits.max.z, bone.rotation.z)
+        );
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Impulse
+  // ---------------------------------------------------------------------------
+  applyImpulse(boneId, impulse) {
+    const bone = this.bones.get(boneId);
+    if (!bone) return;
+    bone.velocity.x += impulse.x / bone.mass;
+    bone.velocity.y += impulse.y / bone.mass;
+    bone.velocity.z += impulse.z / bone.mass;
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getBone(id) {
+    return this.bones.get(id);
+  }
+  getBoneCount() {
+    return this.bones.size;
+  }
+  getRootBone() {
+    return this.rootBone ? this.bones.get(this.rootBone) : void 0;
+  }
+  getChildren(boneId) {
+    return [...this.bones.values()].filter((b) => b.parentId === boneId);
+  }
+};
+
+// src/physics/RagdollSystem.ts
+var HUMANOID_PRESET = [
+  // Torso
+  {
+    id: "pelvis",
+    length: 0.25,
+    radius: 0.12,
+    mass: 15,
+    localOffset: { x: 0, y: 0, z: 0 },
+    jointType: "cone"
+  },
+  {
+    id: "spine",
+    parentBone: "pelvis",
+    length: 0.3,
+    radius: 0.1,
+    mass: 12,
+    localOffset: { x: 0, y: 0.25, z: 0 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 0.3, swingSpan2: 0.3, twistSpan: 0.2 }
+  },
+  {
+    id: "chest",
+    parentBone: "spine",
+    length: 0.25,
+    radius: 0.12,
+    mass: 10,
+    localOffset: { x: 0, y: 0.3, z: 0 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 0.2, swingSpan2: 0.2, twistSpan: 0.15 }
+  },
+  {
+    id: "head",
+    parentBone: "chest",
+    length: 0.2,
+    radius: 0.1,
+    mass: 5,
+    localOffset: { x: 0, y: 0.25, z: 0 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 0.5, swingSpan2: 0.3, twistSpan: 0.4 }
+  },
+  // Left arm
+  {
+    id: "l_upper_arm",
+    parentBone: "chest",
+    length: 0.28,
+    radius: 0.04,
+    mass: 3,
+    localOffset: { x: -0.18, y: 0.15, z: 0 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 1.5, swingSpan2: 1, twistSpan: 0.8 }
+  },
+  {
+    id: "l_forearm",
+    parentBone: "l_upper_arm",
+    length: 0.25,
+    radius: 0.035,
+    mass: 2,
+    localOffset: { x: 0, y: -0.28, z: 0 },
+    jointType: "hinge",
+    jointLimits: { low: 0, high: 2.5 }
+  },
+  {
+    id: "l_hand",
+    parentBone: "l_forearm",
+    length: 0.1,
+    radius: 0.03,
+    mass: 0.5,
+    localOffset: { x: 0, y: -0.25, z: 0 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 0.5, swingSpan2: 0.3, twistSpan: 0.3 }
+  },
+  // Right arm
+  {
+    id: "r_upper_arm",
+    parentBone: "chest",
+    length: 0.28,
+    radius: 0.04,
+    mass: 3,
+    localOffset: { x: 0.18, y: 0.15, z: 0 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 1.5, swingSpan2: 1, twistSpan: 0.8 }
+  },
+  {
+    id: "r_forearm",
+    parentBone: "r_upper_arm",
+    length: 0.25,
+    radius: 0.035,
+    mass: 2,
+    localOffset: { x: 0, y: -0.28, z: 0 },
+    jointType: "hinge",
+    jointLimits: { low: 0, high: 2.5 }
+  },
+  {
+    id: "r_hand",
+    parentBone: "r_forearm",
+    length: 0.1,
+    radius: 0.03,
+    mass: 0.5,
+    localOffset: { x: 0, y: -0.25, z: 0 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 0.5, swingSpan2: 0.3, twistSpan: 0.3 }
+  },
+  // Left leg
+  {
+    id: "l_thigh",
+    parentBone: "pelvis",
+    length: 0.4,
+    radius: 0.06,
+    mass: 8,
+    localOffset: { x: -0.1, y: -0.15, z: 0 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 1.2, swingSpan2: 0.5, twistSpan: 0.3 }
+  },
+  {
+    id: "l_shin",
+    parentBone: "l_thigh",
+    length: 0.38,
+    radius: 0.05,
+    mass: 5,
+    localOffset: { x: 0, y: -0.4, z: 0 },
+    jointType: "hinge",
+    jointLimits: { low: -2.5, high: 0 }
+  },
+  {
+    id: "l_foot",
+    parentBone: "l_shin",
+    length: 0.15,
+    radius: 0.04,
+    mass: 1,
+    localOffset: { x: 0, y: -0.38, z: 0.05 },
+    jointType: "hinge",
+    jointLimits: { low: -0.5, high: 0.5 }
+  },
+  // Right leg
+  {
+    id: "r_thigh",
+    parentBone: "pelvis",
+    length: 0.4,
+    radius: 0.06,
+    mass: 8,
+    localOffset: { x: 0.1, y: -0.15, z: 0 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 1.2, swingSpan2: 0.5, twistSpan: 0.3 }
+  },
+  {
+    id: "r_shin",
+    parentBone: "r_thigh",
+    length: 0.38,
+    radius: 0.05,
+    mass: 5,
+    localOffset: { x: 0, y: -0.4, z: 0 },
+    jointType: "hinge",
+    jointLimits: { low: -2.5, high: 0 }
+  },
+  {
+    id: "r_foot",
+    parentBone: "r_shin",
+    length: 0.15,
+    radius: 0.04,
+    mass: 1,
+    localOffset: { x: 0, y: -0.38, z: 0.05 },
+    jointType: "hinge",
+    jointLimits: { low: -0.5, high: 0.5 }
+  }
+];
+var QUADRUPED_PRESET = [
+  // Body
+  {
+    id: "body",
+    length: 0.6,
+    radius: 0.15,
+    mass: 20,
+    localOffset: { x: 0, y: 0, z: 0 },
+    jointType: "cone"
+  },
+  {
+    id: "neck",
+    parentBone: "body",
+    length: 0.2,
+    radius: 0.06,
+    mass: 3,
+    localOffset: { x: 0, y: 0.1, z: 0.3 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 0.8, swingSpan2: 0.4, twistSpan: 0.3 }
+  },
+  {
+    id: "head",
+    parentBone: "neck",
+    length: 0.15,
+    radius: 0.08,
+    mass: 2,
+    localOffset: { x: 0, y: 0.05, z: 0.2 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 0.6, swingSpan2: 0.4, twistSpan: 0.3 }
+  },
+  {
+    id: "tail",
+    parentBone: "body",
+    length: 0.3,
+    radius: 0.02,
+    mass: 0.5,
+    localOffset: { x: 0, y: 0.05, z: -0.35 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 1, swingSpan2: 0.5, twistSpan: 0.5 }
+  },
+  // Front legs
+  {
+    id: "fl_upper",
+    parentBone: "body",
+    length: 0.25,
+    radius: 0.03,
+    mass: 2,
+    localOffset: { x: -0.12, y: -0.15, z: 0.2 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 0.8, swingSpan2: 0.4, twistSpan: 0.2 }
+  },
+  {
+    id: "fl_lower",
+    parentBone: "fl_upper",
+    length: 0.2,
+    radius: 0.025,
+    mass: 1.5,
+    localOffset: { x: 0, y: -0.25, z: 0 },
+    jointType: "hinge",
+    jointLimits: { low: -2, high: 0 }
+  },
+  {
+    id: "fr_upper",
+    parentBone: "body",
+    length: 0.25,
+    radius: 0.03,
+    mass: 2,
+    localOffset: { x: 0.12, y: -0.15, z: 0.2 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 0.8, swingSpan2: 0.4, twistSpan: 0.2 }
+  },
+  {
+    id: "fr_lower",
+    parentBone: "fr_upper",
+    length: 0.2,
+    radius: 0.025,
+    mass: 1.5,
+    localOffset: { x: 0, y: -0.25, z: 0 },
+    jointType: "hinge",
+    jointLimits: { low: -2, high: 0 }
+  },
+  // Hind legs
+  {
+    id: "hl_upper",
+    parentBone: "body",
+    length: 0.28,
+    radius: 0.04,
+    mass: 3,
+    localOffset: { x: -0.12, y: -0.15, z: -0.2 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 1, swingSpan2: 0.5, twistSpan: 0.2 }
+  },
+  {
+    id: "hl_lower",
+    parentBone: "hl_upper",
+    length: 0.22,
+    radius: 0.03,
+    mass: 2,
+    localOffset: { x: 0, y: -0.28, z: 0 },
+    jointType: "hinge",
+    jointLimits: { low: 0, high: 2 }
+  },
+  {
+    id: "hr_upper",
+    parentBone: "body",
+    length: 0.28,
+    radius: 0.04,
+    mass: 3,
+    localOffset: { x: 0.12, y: -0.15, z: -0.2 },
+    jointType: "cone",
+    jointLimits: { swingSpan1: 1, swingSpan2: 0.5, twistSpan: 0.2 }
+  },
+  {
+    id: "hr_lower",
+    parentBone: "hr_upper",
+    length: 0.22,
+    radius: 0.03,
+    mass: 2,
+    localOffset: { x: 0, y: -0.28, z: 0 },
+    jointType: "hinge",
+    jointLimits: { low: 0, high: 2 }
+  }
+];
+var RagdollSystem = class {
+  ragdolls = /* @__PURE__ */ new Map();
+  /**
+   * Create a ragdoll from a definition at a given world position.
+   */
+  createRagdoll(definition, rootPosition) {
+    const bodies = [];
+    const constraints = [];
+    const bonePositions = /* @__PURE__ */ new Map();
+    for (const bone of definition.bones) {
+      const parentPos = bone.parentBone ? bonePositions.get(bone.parentBone) || rootPosition : rootPosition;
+      const worldPos = {
+        x: parentPos.x + bone.localOffset.x,
+        y: parentPos.y + bone.localOffset.y,
+        z: parentPos.z + bone.localOffset.z
+      };
+      bonePositions.set(bone.id, worldPos);
+      const bodyConfig = {
+        id: `${definition.id}_${bone.id}`,
+        type: "dynamic",
+        transform: {
+          position: worldPos,
+          rotation: { x: 0, y: 0, z: 0, w: 1 },
+          scale: { x: 1, y: 1, z: 1 }
+        },
+        shape: {
+          type: "capsule",
+          radius: bone.radius,
+          height: bone.length
+        },
+        mass: bone.mass,
+        material: {
+          friction: 0.6,
+          restitution: 0.1
+        },
+        linearDamping: 0.05,
+        angularDamping: 0.85
+      };
+      bodies.push(bodyConfig);
+    }
+    for (const bone of definition.bones) {
+      if (!bone.parentBone) continue;
+      const bodyAId = `${definition.id}_${bone.parentBone}`;
+      const bodyBId = `${definition.id}_${bone.id}`;
+      const constraintId = `${definition.id}_joint_${bone.parentBone}_${bone.id}`;
+      if (bone.jointType === "cone") {
+        const coneConstraint = {
+          type: "cone",
+          id: constraintId,
+          bodyA: bodyAId,
+          bodyB: bodyBId,
+          pivotA: bone.localOffset,
+          pivotB: { x: 0, y: 0, z: 0 },
+          axisA: { x: 0, y: 1, z: 0 },
+          axisB: { x: 0, y: 1, z: 0 },
+          swingSpan1: bone.jointLimits?.swingSpan1 ?? 0.5,
+          swingSpan2: bone.jointLimits?.swingSpan2 ?? 0.3,
+          twistSpan: bone.jointLimits?.twistSpan ?? 0.2
+        };
+        constraints.push(coneConstraint);
+      } else {
+        const hingeConstraint = {
+          type: "hinge",
+          id: constraintId,
+          bodyA: bodyAId,
+          bodyB: bodyBId,
+          pivotA: bone.localOffset,
+          pivotB: { x: 0, y: 0, z: 0 },
+          axisA: { x: 1, y: 0, z: 0 },
+          axisB: { x: 1, y: 0, z: 0 },
+          limits: {
+            low: bone.jointLimits?.low ?? -1,
+            high: bone.jointLimits?.high ?? 1
+          }
+        };
+        constraints.push(hingeConstraint);
+      }
+    }
+    const instance = {
+      id: definition.id,
+      definition,
+      bodies,
+      constraints,
+      rootPosition
+    };
+    this.ragdolls.set(definition.id, instance);
+    return instance;
+  }
+  /**
+   * Create humanoid ragdoll from preset.
+   */
+  createHumanoid(id, rootPosition) {
+    return this.createRagdoll({ id, bones: HUMANOID_PRESET }, rootPosition);
+  }
+  /**
+   * Create quadruped ragdoll from preset.
+   */
+  createQuadruped(id, rootPosition) {
+    return this.createRagdoll({ id, bones: QUADRUPED_PRESET }, rootPosition);
+  }
+  /**
+   * Get a ragdoll instance by ID.
+   */
+  getRagdoll(id) {
+    return this.ragdolls.get(id);
+  }
+  /**
+   * Remove a ragdoll.
+   */
+  removeRagdoll(id) {
+    return this.ragdolls.delete(id);
+  }
+  /**
+   * Get total mass of a ragdoll.
+   */
+  getTotalMass(id) {
+    const ragdoll = this.ragdolls.get(id);
+    if (!ragdoll) return 0;
+    return ragdoll.definition.bones.reduce((sum, bone) => sum + bone.mass, 0);
+  }
+};
+
+// src/physics/RaycastSystem.ts
+var RaycastSystem = class {
+  colliders = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // Registration
+  // ---------------------------------------------------------------------------
+  addCollider(collider) {
+    this.colliders.set(collider.entityId, collider);
+  }
+  removeCollider(entityId) {
+    this.colliders.delete(entityId);
+  }
+  getColliderCount() {
+    return this.colliders.size;
+  }
+  // ---------------------------------------------------------------------------
+  // Raycasting
+  // ---------------------------------------------------------------------------
+  raycast(ray, maxDistance = Infinity, layerMask = 4294967295) {
+    const hits = this.raycastAll(ray, maxDistance, layerMask);
+    return hits.length > 0 ? hits[0] : null;
+  }
+  raycastAll(ray, maxDistance = Infinity, layerMask = 4294967295) {
+    const hits = [];
+    const dir = this.normalize(ray.direction);
+    for (const collider of this.colliders.values()) {
+      if ((collider.layer & layerMask) === 0) continue;
+      let hit = null;
+      switch (collider.type) {
+        case "aabb":
+          hit = this.rayAABB(ray.origin, dir, collider.shape, collider.entityId);
+          break;
+        case "sphere":
+          hit = this.raySphere(ray.origin, dir, collider.shape, collider.entityId);
+          break;
+        case "plane":
+          hit = this.rayPlane(ray.origin, dir, collider.shape, collider.entityId);
+          break;
+      }
+      if (hit && hit.distance <= maxDistance) hits.push(hit);
+    }
+    return hits.sort((a, b) => a.distance - b.distance);
+  }
+  // ---------------------------------------------------------------------------
+  // Intersection Tests
+  // ---------------------------------------------------------------------------
+  rayAABB(origin, dir, aabb, entityId) {
+    let tmin = -Infinity, tmax = Infinity;
+    const axes = ["x", "y", "z"];
+    let hitNormal = { x: 0, y: 0, z: 0 };
+    for (const axis of axes) {
+      if (Math.abs(dir[axis]) < 1e-10) {
+        if (origin[axis] < aabb.min[axis] || origin[axis] > aabb.max[axis]) return null;
+        continue;
+      }
+      const t1 = (aabb.min[axis] - origin[axis]) / dir[axis];
+      const t2 = (aabb.max[axis] - origin[axis]) / dir[axis];
+      const tNear = Math.min(t1, t2);
+      const tFar = Math.max(t1, t2);
+      if (tNear > tmin) {
+        tmin = tNear;
+        hitNormal = { x: 0, y: 0, z: 0 };
+        hitNormal[axis] = dir[axis] > 0 ? -1 : 1;
+      }
+      tmax = Math.min(tmax, tFar);
+      if (tmin > tmax || tmax < 0) return null;
+    }
+    const t = tmin >= 0 ? tmin : tmax;
+    if (t < 0) return null;
+    return {
+      entityId,
+      distance: t,
+      point: { x: origin.x + dir.x * t, y: origin.y + dir.y * t, z: origin.z + dir.z * t },
+      normal: hitNormal
+    };
+  }
+  raySphere(origin, dir, sphere, entityId) {
+    const ox = origin.x - sphere.center.x, oy = origin.y - sphere.center.y, oz = origin.z - sphere.center.z;
+    const a = dir.x * dir.x + dir.y * dir.y + dir.z * dir.z;
+    const b = 2 * (ox * dir.x + oy * dir.y + oz * dir.z);
+    const c = ox * ox + oy * oy + oz * oz - sphere.radius * sphere.radius;
+    const disc = b * b - 4 * a * c;
+    if (disc < 0) return null;
+    const sqrtDisc = Math.sqrt(disc);
+    let t = (-b - sqrtDisc) / (2 * a);
+    if (t < 0) t = (-b + sqrtDisc) / (2 * a);
+    if (t < 0) return null;
+    const point = { x: origin.x + dir.x * t, y: origin.y + dir.y * t, z: origin.z + dir.z * t };
+    const nx = point.x - sphere.center.x, ny = point.y - sphere.center.y, nz = point.z - sphere.center.z;
+    const nLen = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+    return {
+      entityId,
+      distance: t,
+      point,
+      normal: { x: nx / nLen, y: ny / nLen, z: nz / nLen }
+    };
+  }
+  rayPlane(origin, dir, plane, entityId) {
+    const denom = plane.normal.x * dir.x + plane.normal.y * dir.y + plane.normal.z * dir.z;
+    if (Math.abs(denom) < 1e-10) return null;
+    const t = -(plane.normal.x * origin.x + plane.normal.y * origin.y + plane.normal.z * origin.z + plane.distance) / denom;
+    if (t < 0) return null;
+    return {
+      entityId,
+      distance: t,
+      point: { x: origin.x + dir.x * t, y: origin.y + dir.y * t, z: origin.z + dir.z * t },
+      normal: { ...plane.normal }
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  normalize(v) {
+    const len = Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z) || 1;
+    return { x: v.x / len, y: v.y / len, z: v.z / len };
+  }
+};
+
+// src/physics/RopeSystem.ts
+var RopeSystem = class {
+  ropes = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // Creation
+  // ---------------------------------------------------------------------------
+  createRope(id, start, end, config) {
+    const segCount = config?.segmentCount ?? 10;
+    const dx = end.x - start.x, dy = end.y - start.y, dz = end.z - start.z;
+    const totalLength = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    const autoSegmentLength = totalLength / segCount;
+    const cfg = {
+      segmentCount: segCount,
+      segmentLength: autoSegmentLength,
+      gravity: { x: 0, y: -9.81, z: 0 },
+      damping: 0.98,
+      iterations: 8,
+      elasticity: 1,
+      ...config
+    };
+    const nodes = [];
+    for (let i = 0; i <= cfg.segmentCount; i++) {
+      const t = i / cfg.segmentCount;
+      nodes.push({
+        position: [start.x + (end.x - start.x) * t, start.y + (end.y - start.y) * t, start.z + (end.z - start.z) * t],
+        previous: {
+          x: start.x + (end.x - start.x) * t,
+          y: start.y + (end.y - start.y) * t,
+          z: start.z + (end.z - start.z) * t
+        },
+        mass: 1,
+        pinned: false
+      });
+    }
+    this.ropes.set(id, { nodes, config: cfg, attachments: [] });
+  }
+  // ---------------------------------------------------------------------------
+  // Pin / Attach
+  // ---------------------------------------------------------------------------
+  pinNode(ropeId, nodeIndex) {
+    const rope = this.ropes.get(ropeId);
+    if (rope?.nodes[nodeIndex]) rope.nodes[nodeIndex].pinned = true;
+  }
+  unpinNode(ropeId, nodeIndex) {
+    const rope = this.ropes.get(ropeId);
+    if (rope?.nodes[nodeIndex]) rope.nodes[nodeIndex].pinned = false;
+  }
+  attach(ropeId, attachment) {
+    const rope = this.ropes.get(ropeId);
+    if (rope) rope.attachments.push(attachment);
+  }
+  // ---------------------------------------------------------------------------
+  // Simulation
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    const dt2 = dt * dt;
+    for (const rope of this.ropes.values()) {
+      const { nodes, config } = rope;
+      for (const n of nodes) {
+        if (n.pinned) continue;
+        const vx = (n.position[0] - n.previous[0]) * config.damping;
+        const vy = (n.position[1] - n.previous[1]) * config.damping;
+        const vz = (n.position[2] - n.previous[2]) * config.damping;
+        n.previous = { ...n.position };
+        n.position[0] += vx + config.gravity[0] * dt2;
+        n.position[1] += vy + config.gravity[1] * dt2;
+        n.position[2] += vz + config.gravity[2] * dt2;
+      }
+      for (let iter = 0; iter < config.iterations; iter++) {
+        for (let i = 0; i < nodes.length - 1; i++) {
+          const a = nodes[i], b = nodes[i + 1];
+          const dx = b.position[0] - a.position[0];
+          const dy = b.position[1] - a.position[1];
+          const dz = b.position[2] - a.position[2];
+          const dist = Math.sqrt(dx * dx + dy * dy + dz * dz) || 1e-4;
+          const diff = (config.segmentLength - dist) / dist * config.elasticity * 0.5;
+          const ox = dx * diff, oy = dy * diff, oz = dz * diff;
+          if (!a.pinned) {
+            a.position[0] -= ox;
+            a.position[1] -= oy;
+            a.position[2] -= oz;
+          }
+          if (!b.pinned) {
+            b.position[0] += ox;
+            b.position[1] += oy;
+            b.position[2] += oz;
+          }
+        }
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getRopeNodes(ropeId) {
+    return this.ropes.get(ropeId)?.nodes ?? [];
+  }
+  getRopeLength(ropeId) {
+    const nodes = this.ropes.get(ropeId)?.nodes;
+    if (!nodes || nodes.length < 2) return 0;
+    let len = 0;
+    for (let i = 1; i < nodes.length; i++) {
+      const a = nodes[i - 1].position, b = nodes[i].position;
+      const dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
+      len += Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+    return len;
+  }
+  getTension(ropeId, nodeIndex) {
+    const rope = this.ropes.get(ropeId);
+    if (!rope || nodeIndex < 0 || nodeIndex >= rope.nodes.length - 1) return 0;
+    const a = rope.nodes[nodeIndex].position, b = rope.nodes[nodeIndex + 1].position;
+    const dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
+    const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    return Math.abs(dist - rope.config.segmentLength) / rope.config.segmentLength;
+  }
+  getRopeCount() {
+    return this.ropes.size;
+  }
+  removeRope(id) {
+    this.ropes.delete(id);
+  }
+};
+
+// src/physics/TriggerZone.ts
+var TriggerZoneSystem = class {
+  zones = /* @__PURE__ */ new Map();
+  callbacks = /* @__PURE__ */ new Map();
+  // Per zone: set of entity IDs currently inside
+  occupants = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // Zone Management
+  // ---------------------------------------------------------------------------
+  addZone(config) {
+    this.zones.set(config.id, config);
+    this.occupants.set(config.id, /* @__PURE__ */ new Set());
+  }
+  removeZone(id) {
+    this.zones.delete(id);
+    this.occupants.delete(id);
+    this.callbacks.delete(id);
+  }
+  enableZone(id, enabled) {
+    const z = this.zones.get(id);
+    if (z) z.enabled = enabled;
+  }
+  // ---------------------------------------------------------------------------
+  // Callbacks
+  // ---------------------------------------------------------------------------
+  onTrigger(zoneId, callback) {
+    if (!this.callbacks.has(zoneId)) this.callbacks.set(zoneId, []);
+    this.callbacks.get(zoneId).push(callback);
+  }
+  fire(zoneId, entityId, event) {
+    const cbs = this.callbacks.get(zoneId);
+    if (cbs) for (const cb of cbs) cb(entityId, zoneId, event);
+  }
+  // ---------------------------------------------------------------------------
+  // Update (test entities against zones)
+  // ---------------------------------------------------------------------------
+  update(entities) {
+    for (const [zoneId, zone] of this.zones) {
+      if (!zone.enabled) continue;
+      const current = this.occupants.get(zoneId);
+      const nowInside = /* @__PURE__ */ new Set();
+      for (const entity of entities) {
+        if (this.overlaps(zone.shape, entity.position, entity.radius ?? 0)) {
+          nowInside.add(entity.id);
+          if (current.has(entity.id)) {
+            this.fire(zoneId, entity.id, "stay");
+          } else {
+            this.fire(zoneId, entity.id, "enter");
+          }
+        }
+      }
+      for (const prevId of current) {
+        if (!nowInside.has(prevId)) {
+          this.fire(zoneId, prevId, "exit");
+        }
+      }
+      this.occupants.set(zoneId, nowInside);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Overlap Tests
+  // ---------------------------------------------------------------------------
+  overlaps(shape, pos, entityRadius) {
+    if (shape.type === "sphere" && shape.radius !== void 0) {
+      const dx = pos[0] - shape.position[0], dy = pos[1] - shape.position[1], dz = pos[2] - shape.position[2];
+      const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      return dist <= shape.radius + entityRadius;
+    }
+    if (shape.type === "box" && shape.halfExtents) {
+      const he = shape.halfExtents;
+      const dx = Math.abs(pos[0] - shape.position[0]), dy = Math.abs(pos[1] - shape.position[1]), dz = Math.abs(pos[2] - shape.position[2]);
+      return dx <= he.x + entityRadius && dy <= he.y + entityRadius && dz <= he.z + entityRadius;
+    }
+    return false;
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  isInside(entityId, zoneId) {
+    return this.occupants.get(zoneId)?.has(entityId) ?? false;
+  }
+  getOccupants(zoneId) {
+    const occ = this.occupants.get(zoneId);
+    return occ ? [...occ] : [];
+  }
+  getZonesForEntity(entityId) {
+    const zones = [];
+    for (const [zoneId, occ] of this.occupants) {
+      if (occ.has(entityId)) zones.push(zoneId);
+    }
+    return zones;
+  }
+  getZoneCount() {
+    return this.zones.size;
+  }
+};
+
+// src/physics/VehicleSystem.ts
+function createDefaultCar(id) {
+  const wheelConfig = (x, z, isSteering, isDriving) => ({
+    id: `${id}_wheel_${x > 0 ? "r" : "l"}_${z > 0 ? "f" : "r"}`,
+    connectionPoint: { x, y: -0.3, z },
+    direction: { x: 0, y: -1, z: 0 },
+    axle: { x: 1, y: 0, z: 0 },
+    suspensionRestLength: 0.3,
+    suspensionStiffness: 25,
+    suspensionDamping: 4.4,
+    maxSuspensionTravel: 0.2,
+    wheelRadius: 0.35,
+    frictionSlip: 1.2,
+    isSteering,
+    isDriving,
+    rollInfluence: 0.1
+  });
+  return {
+    id,
+    chassisMass: 1500,
+    chassisSize: { x: 1.8, y: 0.6, z: 4.2 },
+    wheels: [
+      wheelConfig(-0.8, 1.4, true, false),
+      // Front Left
+      wheelConfig(0.8, 1.4, true, false),
+      // Front Right
+      wheelConfig(-0.8, -1.4, false, true),
+      // Rear Left
+      wheelConfig(0.8, -1.4, false, true)
+      // Rear Right
+    ],
+    maxSteerAngle: 0.5,
+    maxEngineForce: 3e3,
+    maxBrakeForce: 100
+  };
+}
+function createTruck(id) {
+  const wheelConfig = (x, z, isSteering, isDriving) => ({
+    id: `${id}_wheel_${x > 0 ? "r" : "l"}_${z.toFixed(0)}`,
+    connectionPoint: { x, y: -0.5, z },
+    direction: { x: 0, y: -1, z: 0 },
+    axle: { x: 1, y: 0, z: 0 },
+    suspensionRestLength: 0.4,
+    suspensionStiffness: 40,
+    suspensionDamping: 6,
+    maxSuspensionTravel: 0.3,
+    wheelRadius: 0.5,
+    frictionSlip: 1.5,
+    isSteering,
+    isDriving,
+    rollInfluence: 0.05
+  });
+  return {
+    id,
+    chassisMass: 5e3,
+    chassisSize: { x: 2.4, y: 1, z: 7 },
+    wheels: [
+      wheelConfig(-1, 2.8, true, false),
+      wheelConfig(1, 2.8, true, false),
+      wheelConfig(-1, -1.5, false, true),
+      wheelConfig(1, -1.5, false, true),
+      wheelConfig(-1, -2.8, false, true),
+      wheelConfig(1, -2.8, false, true)
+    ],
+    maxSteerAngle: 0.4,
+    maxEngineForce: 6e3,
+    maxBrakeForce: 200
+  };
+}
+var VehicleSystem = class {
+  vehicles = /* @__PURE__ */ new Map();
+  /**
+   * Create a vehicle from a definition at a given position.
+   */
+  createVehicle(definition, position) {
+    const wheels = definition.wheels.map((wc) => ({
+      config: wc,
+      suspensionLength: wc.suspensionRestLength,
+      suspensionForce: 0,
+      contactPoint: null,
+      isGrounded: false,
+      rotation: 0,
+      steerAngle: 0,
+      skidFactor: 0
+    }));
+    const state = {
+      id: definition.id,
+      definition,
+      position: { ...position },
+      rotation: { x: 0, y: 0, z: 0, w: 1 },
+      linearVelocity: { x: 0, y: 0, z: 0 },
+      angularVelocity: { x: 0, y: 0, z: 0 },
+      wheels,
+      speed: 0,
+      engineForce: 0,
+      brakeForce: 0,
+      steerAngle: 0
+    };
+    this.vehicles.set(definition.id, state);
+    return state;
+  }
+  /**
+   * Update vehicle physics for one timestep.
+   */
+  update(vehicleId, dt) {
+    const vehicle = this.vehicles.get(vehicleId);
+    if (!vehicle) return null;
+    const def = vehicle.definition;
+    for (const wheel of vehicle.wheels) {
+      if (wheel.config.isSteering) {
+        wheel.steerAngle = vehicle.steerAngle;
+      }
+    }
+    let totalSuspensionForce = 0;
+    const forwardDir = this.getForwardVector(vehicle);
+    for (const wheel of vehicle.wheels) {
+      const wheelWorldY = vehicle.position.y + wheel.config.connectionPoint.y;
+      const rayEnd = wheelWorldY - wheel.config.suspensionRestLength - wheel.config.wheelRadius;
+      if (rayEnd <= 0) {
+        wheel.isGrounded = true;
+        const compression = -rayEnd;
+        wheel.suspensionLength = Math.max(
+          wheel.config.suspensionRestLength - compression,
+          wheel.config.suspensionRestLength - wheel.config.maxSuspensionTravel
+        );
+        const springDelta = wheel.config.suspensionRestLength - wheel.suspensionLength;
+        const springForce = springDelta * wheel.config.suspensionStiffness;
+        const relVel = vehicle.linearVelocity.y;
+        const dampForce = -relVel * wheel.config.suspensionDamping;
+        wheel.suspensionForce = Math.max(0, springForce + dampForce);
+        totalSuspensionForce += wheel.suspensionForce;
+        wheel.contactPoint = {
+          x: vehicle.position.x + wheel.config.connectionPoint.x,
+          y: 0,
+          z: vehicle.position.z + wheel.config.connectionPoint.z
+        };
+      } else {
+        wheel.isGrounded = false;
+        wheel.suspensionForce = 0;
+        wheel.contactPoint = null;
+        wheel.suspensionLength = wheel.config.suspensionRestLength;
+      }
+    }
+    for (const wheel of vehicle.wheels) {
+      if (!wheel.isGrounded) continue;
+      if (wheel.config.isDriving && vehicle.engineForce !== 0) {
+        const driveForce = vehicle.engineForce / vehicle.wheels.filter((w) => w.config.isDriving).length;
+        vehicle.linearVelocity.x += forwardDir.x * driveForce / def.chassisMass * dt;
+        vehicle.linearVelocity.z += forwardDir.z * driveForce / def.chassisMass * dt;
+      }
+      if (vehicle.brakeForce > 0) {
+        const speed = Math.sqrt(vehicle.linearVelocity.x ** 2 + vehicle.linearVelocity.z ** 2);
+        if (speed > 0.01) {
+          const brakeDec = Math.min(vehicle.brakeForce / def.chassisMass * dt, speed);
+          const factor = 1 - brakeDec / speed;
+          vehicle.linearVelocity.x *= factor;
+          vehicle.linearVelocity.z *= factor;
+        }
+      }
+      const wheelSpeed = Math.sqrt(vehicle.linearVelocity.x ** 2 + vehicle.linearVelocity.z ** 2);
+      wheel.rotation += wheelSpeed / wheel.config.wheelRadius * dt;
+      const lateralSpeed = Math.abs(vehicle.angularVelocity.y * 0.5);
+      wheel.skidFactor = Math.min(lateralSpeed / (wheel.config.frictionSlip + 1e-3), 1);
+    }
+    const isGrounded = vehicle.wheels.some((w) => w.isGrounded);
+    if (!isGrounded) {
+      vehicle.linearVelocity.y -= 9.81 * dt;
+    } else {
+      const suspensionAccel = totalSuspensionForce / def.chassisMass;
+      vehicle.linearVelocity.y += (suspensionAccel - 9.81) * dt;
+      const refWheel = vehicle.wheels[0].config;
+      if (vehicle.position.y <= refWheel.wheelRadius + refWheel.suspensionRestLength) {
+        vehicle.linearVelocity.y = Math.max(vehicle.linearVelocity.y, 0);
+      }
+    }
+    if (vehicle.steerAngle !== 0 && isGrounded) {
+      const speed = Math.sqrt(vehicle.linearVelocity.x ** 2 + vehicle.linearVelocity.z ** 2);
+      const turnRate = vehicle.steerAngle * speed * 0.5;
+      vehicle.angularVelocity.y = turnRate;
+    } else {
+      vehicle.angularVelocity.y *= 0.95;
+    }
+    vehicle.position.x += vehicle.linearVelocity.x * dt;
+    vehicle.position.y += vehicle.linearVelocity.y * dt;
+    vehicle.position.z += vehicle.linearVelocity.z * dt;
+    vehicle.speed = Math.sqrt(vehicle.linearVelocity.x ** 2 + vehicle.linearVelocity.z ** 2) * 3.6;
+    return vehicle;
+  }
+  // ---------------------------------------------------------------------------
+  // Controls
+  // ---------------------------------------------------------------------------
+  setThrottle(vehicleId, throttle) {
+    const v = this.vehicles.get(vehicleId);
+    if (!v) return;
+    v.engineForce = throttle * v.definition.maxEngineForce;
+  }
+  setBrake(vehicleId, brake) {
+    const v = this.vehicles.get(vehicleId);
+    if (!v) return;
+    v.brakeForce = brake * v.definition.maxBrakeForce;
+  }
+  setSteering(vehicleId, steering) {
+    const v = this.vehicles.get(vehicleId);
+    if (!v) return;
+    v.steerAngle = Math.max(-1, Math.min(1, steering)) * v.definition.maxSteerAngle;
+  }
+  getVehicle(vehicleId) {
+    return this.vehicles.get(vehicleId);
+  }
+  removeVehicle(vehicleId) {
+    return this.vehicles.delete(vehicleId);
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  getForwardVector(vehicle) {
+    const yaw = vehicle.angularVelocity.y;
+    return { x: Math.sin(yaw), y: 0, z: Math.cos(yaw) };
+  }
+};
+
+// src/physics/SpatialHash.ts
+var SpatialHash = class {
+  cellSize;
+  cells = /* @__PURE__ */ new Map();
+  entries = /* @__PURE__ */ new Map();
+  constructor(cellSize) {
+    this.cellSize = cellSize;
+  }
+  // ---------------------------------------------------------------------------
+  // Insert / Remove
+  // ---------------------------------------------------------------------------
+  insert(entry) {
+    this.entries.set(entry.id, entry);
+    const cells = this.getCellsForEntry(entry);
+    for (const key of cells) {
+      if (!this.cells.has(key)) this.cells.set(key, /* @__PURE__ */ new Set());
+      this.cells.get(key).add(entry.id);
+    }
+  }
+  remove(id) {
+    const entry = this.entries.get(id);
+    if (!entry) return;
+    const cells = this.getCellsForEntry(entry);
+    for (const key of cells) {
+      const cell = this.cells.get(key);
+      if (cell) {
+        cell.delete(id);
+        if (cell.size === 0) this.cells.delete(key);
+      }
+    }
+    this.entries.delete(id);
+  }
+  update(id, x, y, z) {
+    this.remove(id);
+    const entry = this.entries.get(id) ?? { id, x, y, z, radius: 0 };
+    entry.x = x;
+    entry.y = y;
+    entry.z = z;
+    this.insert(entry);
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  queryPoint(x, y, z) {
+    const key = this.cellKey(
+      Math.floor(x / this.cellSize),
+      Math.floor(y / this.cellSize),
+      Math.floor(z / this.cellSize)
+    );
+    const cell = this.cells.get(key);
+    return cell ? [...cell] : [];
+  }
+  queryRadius(x, y, z, radius) {
+    const results = /* @__PURE__ */ new Set();
+    const minCx = Math.floor((x - radius) / this.cellSize);
+    const maxCx = Math.floor((x + radius) / this.cellSize);
+    const minCy = Math.floor((y - radius) / this.cellSize);
+    const maxCy = Math.floor((y + radius) / this.cellSize);
+    const minCz = Math.floor((z - radius) / this.cellSize);
+    const maxCz = Math.floor((z + radius) / this.cellSize);
+    for (let cx = minCx; cx <= maxCx; cx++) {
+      for (let cy = minCy; cy <= maxCy; cy++) {
+        for (let cz = minCz; cz <= maxCz; cz++) {
+          const cell = this.cells.get(this.cellKey(cx, cy, cz));
+          if (!cell) continue;
+          for (const id of cell) {
+            const entry = this.entries.get(id);
+            if (entry) {
+              const dx = entry.x - x, dy = entry.y - y, dz = entry.z - z;
+              const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+              if (dist <= radius + entry.radius) results.add(id);
+            }
+          }
+        }
+      }
+    }
+    return [...results];
+  }
+  getNearbyPairs() {
+    const pairs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const cell of this.cells.values()) {
+      const ids = [...cell];
+      for (let i = 0; i < ids.length; i++) {
+        for (let j = i + 1; j < ids.length; j++) {
+          const key = ids[i] < ids[j] ? `${ids[i]}:${ids[j]}` : `${ids[j]}:${ids[i]}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            pairs.push([ids[i], ids[j]]);
+          }
+        }
+      }
+    }
+    return pairs;
+  }
+  // ---------------------------------------------------------------------------
+  // Internals
+  // ---------------------------------------------------------------------------
+  getCellsForEntry(entry) {
+    const keys = [];
+    const minCx = Math.floor((entry.x - entry.radius) / this.cellSize);
+    const maxCx = Math.floor((entry.x + entry.radius) / this.cellSize);
+    const minCy = Math.floor((entry.y - entry.radius) / this.cellSize);
+    const maxCy = Math.floor((entry.y + entry.radius) / this.cellSize);
+    const minCz = Math.floor((entry.z - entry.radius) / this.cellSize);
+    const maxCz = Math.floor((entry.z + entry.radius) / this.cellSize);
+    for (let cx = minCx; cx <= maxCx; cx++) {
+      for (let cy = minCy; cy <= maxCy; cy++) {
+        for (let cz = minCz; cz <= maxCz; cz++) {
+          keys.push(this.cellKey(cx, cy, cz));
+        }
+      }
+    }
+    return keys;
+  }
+  cellKey(cx, cy, cz) {
+    return `${cx}:${cy}:${cz}`;
+  }
+  // ---------------------------------------------------------------------------
+  // Stats
+  // ---------------------------------------------------------------------------
+  getEntryCount() {
+    return this.entries.size;
+  }
+  getCellCount() {
+    return this.cells.size;
+  }
+  clear() {
+    this.cells.clear();
+    this.entries.clear();
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ActivationTriggerType,
   COLLISION_GROUPS,
+  ClothSim,
+  ConstraintSolver,
   DEFAULT_ACTIVATION_CONFIG,
   DEFAULT_INTENSITY_CURVE,
   DEFAULT_LOCOMOTION_CONFIG,
+  DeformableMesh,
+  FluidSim,
+  HUMANOID_PRESET,
   IslandDetector,
+  JointSystem,
   MLSMPMFluid,
   PBDSolverCPU,
   PBD_ATTACHMENT_SHADER,
@@ -6299,14 +8644,23 @@ var SoftBodyAdapter = class {
   PhysicsSyncReceiver,
   PhysicsSyncSender,
   PhysicsWorldImpl,
+  QUADRUPED_PRESET,
+  RagdollController,
+  RagdollSystem,
+  RaycastSystem,
   RigidBody,
+  RopeSystem,
   SOFT_BODY_PRESETS,
   ScalarArithmetic,
   SoftBodyAdapter,
   SoftBodyGrabController,
   SoftBodySolver,
+  SpatialHash,
+  TriggerZoneSystem,
   UnifiedParticleBuffer,
+  VRPhysicsBridge,
   Vector3Arithmetic,
+  VehicleSystem,
   VelocityRingBuffer,
   VelocitySmoother,
   WindZoneManager,
@@ -6316,10 +8670,12 @@ var SoftBodyAdapter = class {
   colorConstraints,
   computeRestLengths,
   computeSelfWind,
+  createDefaultCar,
   createPBDSolver,
   createPIDControllerTrait,
   createPhysicsWorld,
   createScalarPIDController,
+  createTruck,
   createVector3PIDController,
   defaultMaterial,
   defaultPIDConfig,