@adatechnology/game-destruction-three 0.1.0 → 0.1.1

package/dist/index.global.js

@@ -716,6 +716,8 @@ void main() {
   var SLEEP_AFTER = 0.5;
   var HARD_LANDING = 3;
   var SLOP = 2e-3;
+  var NARROW = 0.3;
+  var TOPPLE = 3;
   var PieceSystem = class {
     constructor(THREE, o) {
       __publicField(this, "THREE", THREE);
@@ -847,6 +849,7 @@ void main() {
       let landPoint = [pos[0], pos[1], pos[2]];
       let contactedLast = false;
       let touched = false;
+      let unstable = false;
       for (let s = 0; s < steps; s++) {
         v[1] -= this.o.gravity * h;
         pos[0] += v[0] * h;
@@ -935,6 +938,25 @@ void main() {
             }
           }
         }
+        let x0 = Infinity, x1 = -Infinity, z0 = Infinity, z1 = -Infinity, low = 0;
+        for (const r of rs) {
+          x0 = Math.min(x0, r[0]);
+          x1 = Math.max(x1, r[0]);
+          z0 = Math.min(z0, r[2]);
+          z1 = Math.max(z1, r[2]);
+          low = Math.min(low, r[1]);
+        }
+        const height = -low;
+        const wx = x1 - x0;
+        const wz = z1 - z0;
+        unstable = Math.min(wx, wz) < NARROW * height || x0 > 0 || x1 < 0 || z0 > 0 || z1 < 0;
+        if (unstable) {
+          const dirX = x0 + x1 > 0 ? -1 : 1;
+          const dirZ = z0 + z1 > 0 ? -1 : 1;
+          const k = TOPPLE * Math.min(height, 1) * h;
+          if (wx <= wz) w[2] -= dirX * k;
+          else w[0] += dirZ * k;
+        }
         const rd = Math.exp((rs.length >= 3 ? -3 : -1.5) * h);
         w[0] *= rd;
         w[1] *= rd;
@@ -952,7 +974,7 @@ void main() {
         b.lastHit = this.time;
         this.o.onHardLanding(b, landPoint, landing);
       }
-      const still = touched && Math.hypot(v[0], v[1], v[2]) < 0.12 && Math.hypot(w[0], w[1], w[2]) < 0.45;
+      const still = touched && !unstable && Math.hypot(v[0], v[1], v[2]) < 0.12 && Math.hypot(w[0], w[1], w[2]) < 0.45;
       if (still) {
         b.still += dt;
         if (b.still >= SLEEP_AFTER) {
@@ -1012,1437 +1034,88 @@ void main() {
     }
   };
 
-  // src/heat.ts
-  var STOPS = [
-    [450, 0],
-    [500, 2753536],
-    [650, 9049344],
-    [800, 14174728],
-    [950, 16747540],
-    [1100, 16761402],
-    [1250, 16771232],
-    [1400, 16777215]
-  ];
-  function heatColor(temperatureC) {
-    if (!(temperatureC > STOPS[0][0])) return 0;
-    const last = STOPS[STOPS.length - 1];
-    if (temperatureC >= last[0]) return last[1];
-    for (let i = 1; i < STOPS.length; i++) {
-      const [t1, c1] = STOPS[i];
-      if (temperatureC <= t1) {
-        const [t0, c0] = STOPS[i - 1];
-        return mixHex(c0, c1, (temperatureC - t0) / (t1 - t0));
+  // ../game-destruction/dist/index.js
+  var EPS = 1e-9;
+  var IDENTITY = [0, 0, 0, 1];
+  var quat = {
+    identity: () => [IDENTITY[0], IDENTITY[1], IDENTITY[2], IDENTITY[3]],
+    /** Hamilton product `a * b` (apply `b` first, then `a`). */
+    mul: (a, b) => [
+      a[3] * b[0] + a[0] * b[3] + a[1] * b[2] - a[2] * b[1],
+      a[3] * b[1] - a[0] * b[2] + a[1] * b[3] + a[2] * b[0],
+      a[3] * b[2] + a[0] * b[1] - a[1] * b[0] + a[2] * b[3],
+      a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2]
+    ],
+    conjugate: (q) => [-q[0], -q[1], -q[2], q[3]],
+    normalize: (q) => {
+      const l = Math.hypot(q[0], q[1], q[2], q[3]);
+      return l < EPS ? [0, 0, 0, 1] : [q[0] / l, q[1] / l, q[2] / l, q[3] / l];
+    },
+    /** Rotation of `angle` radians around a unit `axis`. */
+    fromAxisAngle: (axis, angle) => {
+      const s = Math.sin(angle / 2);
+      return [axis[0] * s, axis[1] * s, axis[2] * s, Math.cos(angle / 2)];
+    },
+    /** Rotation matrix, row-major 3x3. */
+    toMatrix: (q) => {
+      const [x, y, z, w] = q;
+      const xx = x * x, yy = y * y, zz = z * z, xy = x * y, xz = x * z, yz = y * z, wx = w * x, wy = w * y, wz = w * z;
+      return [1 - 2 * (yy + zz), 2 * (xy - wz), 2 * (xz + wy), 2 * (xy + wz), 1 - 2 * (xx + zz), 2 * (yz - wx), 2 * (xz - wy), 2 * (yz + wx), 1 - 2 * (xx + yy)];
+    },
+    /** Quaternion from three orthonormal columns (the images of the x, y and z axes). */
+    fromColumns: (cx, cy, cz) => {
+      const m00 = cx[0], m10 = cx[1], m20 = cx[2];
+      const m01 = cy[0], m11 = cy[1], m21 = cy[2];
+      const m02 = cz[0], m12 = cz[1], m22 = cz[2];
+      const tr = m00 + m11 + m22;
+      let q;
+      if (tr > 0) {
+        const s = Math.sqrt(tr + 1) * 2;
+        q = [(m21 - m12) / s, (m02 - m20) / s, (m10 - m01) / s, 0.25 * s];
+      } else if (m00 > m11 && m00 > m22) {
+        const s = Math.sqrt(1 + m00 - m11 - m22) * 2;
+        q = [0.25 * s, (m01 + m10) / s, (m02 + m20) / s, (m21 - m12) / s];
+      } else if (m11 > m22) {
+        const s = Math.sqrt(1 + m11 - m00 - m22) * 2;
+        q = [(m01 + m10) / s, 0.25 * s, (m12 + m21) / s, (m02 - m20) / s];
+      } else {
+        const s = Math.sqrt(1 + m22 - m00 - m11) * 2;
+        q = [(m02 + m20) / s, (m12 + m21) / s, 0.25 * s, (m10 - m01) / s];
       }
+      return quat.normalize(q);
     }
-    return last[1];
-  }
-
-  // src/visual.ts
-  var POS_ATTR = "position";
-  function positionAttr(geo) {
-    const a = geo.getAttribute(POS_ATTR);
-    return a && !a.isInterleavedBufferAttribute ? a : null;
-  }
-  function materialsOf(m) {
-    return Array.isArray(m) ? m : [m];
-  }
-  function colorOf(m) {
-    const c = m.color;
-    return c && c.isColor ? c : null;
-  }
-  var DecalKit = class {
-    constructor(THREE) {
-      __publicField(this, "THREE", THREE);
-      __publicField(this, "disc", null);
-      __publicField(this, "discMat", null);
-      __publicField(this, "lineMats", /* @__PURE__ */ new Map());
-    }
-    discGeometry() {
-      return this.disc ?? (this.disc = new this.THREE.CircleGeometry(1, 14));
-    }
-    discMaterial() {
-      return this.discMat ?? (this.discMat = new this.THREE.MeshBasicMaterial({
-        color: 328965,
-        transparent: true,
-        opacity: 0.92,
-        depthWrite: false,
-        polygonOffset: true,
-        polygonOffsetFactor: -4,
-        polygonOffsetUnits: -4
-      }));
-    }
-    lineMaterial(color) {
-      let m = this.lineMats.get(color);
-      if (!m) {
-        m = new this.THREE.LineBasicMaterial({ color, transparent: true, opacity: 0.9, depthWrite: false });
-        this.lineMats.set(color, m);
+  };
+  var quatFromEuler = (x, y, z) => {
+    const c1 = Math.cos(x / 2), c2 = Math.cos(y / 2), c3 = Math.cos(z / 2);
+    const s1 = Math.sin(x / 2), s2 = Math.sin(y / 2), s3 = Math.sin(z / 2);
+    return [s1 * c2 * c3 + c1 * s2 * s3, c1 * s2 * c3 - s1 * c2 * s3, c1 * c2 * s3 + s1 * s2 * c3, c1 * c2 * c3 - s1 * s2 * s3];
+  };
+  var shapeDims = (s) => {
+    if (s.kind === "box") return [s.size[0], s.size[1], s.size[2]];
+    if (s.kind === "cylinder") return [s.radius * 2, s.height, s.radius * 2];
+    return [s.radius * 2, s.radius * 2, s.radius * 2];
+  };
+  var aabbOf = (s, center, q) => {
+    let hx, hy, hz;
+    if (s.kind === "sphere") {
+      hx = hy = hz = s.radius;
+    } else {
+      const m = quat.toMatrix(q);
+      if (s.kind === "box") {
+        const a = s.size[0] / 2, b = s.size[1] / 2, c = s.size[2] / 2;
+        hx = Math.abs(m[0]) * a + Math.abs(m[1]) * b + Math.abs(m[2]) * c;
+        hy = Math.abs(m[3]) * a + Math.abs(m[4]) * b + Math.abs(m[5]) * c;
+        hz = Math.abs(m[6]) * a + Math.abs(m[7]) * b + Math.abs(m[8]) * c;
+      } else {
+        const ax = [m[1], m[4], m[7]];
+        const hh = s.height / 2;
+        const e = (i) => s.radius * Math.sqrt(Math.max(0, 1 - ax[i] * ax[i])) + hh * Math.abs(ax[i]);
+        hx = e(0);
+        hy = e(1);
+        hz = e(2);
       }
-      return m;
-    }
-    dispose() {
-      this.disc?.dispose();
-      this.discMat?.dispose();
-      for (const m of this.lineMats.values()) m.dispose();
-      this.disc = null;
-      this.discMat = null;
-      this.lineMats.clear();
     }
-  };
-  var tmpV = (THREE) => new THREE.Vector3();
-  var Visuals = class {
-    constructor(THREE, lowQuality, decalCap) {
-      __publicField(this, "THREE", THREE);
-      __publicField(this, "lowQuality", lowQuality);
-      __publicField(this, "decalCap", decalCap);
-      __publicField(this, "kit");
-      __publicField(this, "a");
-      __publicField(this, "b");
-      __publicField(this, "m4");
-      __publicField(this, "box");
-      /** Total live decals across meshes (kept in sync by add/remove). */
-      __publicField(this, "decalCount", 0);
-      this.kit = new DecalKit(THREE);
-      this.a = tmpV(THREE);
-      this.b = tmpV(THREE);
-      this.m4 = new THREE.Matrix4();
-      this.box = new THREE.Box3();
-    }
-    makeMeshVis(mesh, home) {
-      return {
-        mesh,
-        home,
-        origGeometry: mesh.geometry,
-        origMaterial: mesh.material,
-        origVisible: mesh.visible,
-        origParent: mesh.parent,
-        origPosition: mesh.position.clone(),
-        origQuaternion: mesh.quaternion.clone(),
-        origScale: mesh.scale.clone(),
-        ownMat: false,
-        ownGeo: false,
-        work: null,
-        baseColors: null,
-        decals: [],
-        meltApplied: 0,
-        bottomY: 0,
-        moved: false
-      };
-    }
-    vertexCount(mv) {
-      return mv.mesh.geometry.getAttribute(POS_ATTR)?.count ?? 0;
-    }
-    /** Colour of the original material (before any char), `0xRRGGBB`, or -1. */
-    baseColorHex(mv) {
-      const c = mv.baseColors?.[0] ?? colorOf(materialsOf(mv.origMaterial)[0]);
-      return c ? c.getHex() : -1;
-    }
-    /** Is the original material transparent? */
-    isTransparent(mv) {
-      return materialsOf(mv.origMaterial).some((m) => m.transparent && m.opacity < 1);
-    }
-    ownMaterial(mv) {
-      if (mv.ownMat) return;
-      mv.ownMat = true;
-      const src = materialsOf(mv.origMaterial);
-      const cloned = src.map((m) => m.clone());
-      mv.baseColors = src.map((m) => colorOf(m)?.clone() ?? new this.THREE.Color(8947848));
-      mv.mesh.material = Array.isArray(mv.origMaterial) ? cloned : cloned[0];
-    }
-    /** Clone the geometry (vertex edits); false when its positions cannot be edited. */
-    ownGeometry(mv) {
-      if (mv.ownGeo) return true;
-      const pos = positionAttr(mv.mesh.geometry);
-      if (!pos) return false;
-      mv.ownGeo = true;
-      const g = mv.mesh.geometry.clone();
-      mv.mesh.geometry = g;
-      mv.work = new Float32Array(positionAttr(g).array);
-      return true;
-    }
-    // ------------------------------------------------------------------------------------------------------------------------------------
-    // Dents
-    // ------------------------------------------------------------------------------------------------------------------------------------
-    /**
-     * Push the vertices of the mesh within `dent.radius` of `worldPoint` inwards along `worldNormal` by `depth * (1 - (d/r)^2)^2`.
-     * Returns false when nothing was changed (too far, low quality on a heavy mesh, or no editable positions).
-     */
-    applyDent(mv, worldPoint, worldNormal, dent) {
-      const mesh = mv.mesh;
-      if (this.lowQuality && this.vertexCount(mv) > 2e4) return false;
-      mesh.updateWorldMatrix(true, false);
-      const s = mesh.matrixWorld.getMaxScaleOnAxis() || 1;
-      const lp = mesh.worldToLocal(this.a.copy(worldPoint));
-      const ln = this.b.copy(worldNormal).transformDirection(this.m4.copy(mesh.matrixWorld).invert()).normalize();
-      const r = dent.radius / s;
-      const depth = dent.depth / s;
-      const geo = mesh.geometry;
-      if (!geo.boundingBox) geo.computeBoundingBox();
-      if (geo.boundingBox && geo.boundingBox.distanceToPoint(lp) > r) return false;
-      if (!this.ownGeometry(mv)) return false;
-      const work = mv.work;
-      const pos = positionAttr(mesh.geometry);
-      const r2 = r * r;
-      let touched = false;
-      const px = lp.x;
-      const py = lp.y;
-      const pz = lp.z;
-      const nx = ln.x;
-      const ny = ln.y;
-      const nz = ln.z;
-      for (let i = 0; i < work.length; i += 3) {
-        const dx = work[i] - px;
-        const dy = work[i + 1] - py;
-        const dz = work[i + 2] - pz;
-        const d2 = dx * dx + dy * dy + dz * dz;
-        if (d2 >= r2) continue;
-        const f = 1 - d2 / r2;
-        const k = depth * f * f;
-        work[i] -= nx * k;
-        work[i + 1] -= ny * k;
-        work[i + 2] -= nz * k;
-        touched = true;
-      }
-      if (!touched) return false;
-      this.writePositions(mv, pos);
-      return true;
-    }
-    /** Copy `work` (dents) into the geometry, adding the melt sag when the mesh is melting. */
-    writePositions(mv, pos) {
-      const work = mv.work;
-      const arr = pos.array;
-      const melt = mv.meltApplied;
-      if (melt <= 0 || this.lowQuality && work.length / 3 > 2e4) {
-        arr.set(work);
-      } else {
-        const geo2 = mv.mesh.geometry;
-        if (!geo2.boundingBox) geo2.computeBoundingBox();
-        const bb = geo2.boundingBox;
-        const h = Math.max(1e-4, bb.max.y - bb.min.y);
-        const minY = bb.min.y;
-        for (let i = 0, v = 0; i < work.length; i += 3, v++) {
-          const n = (Math.imul(v + 1, 2654435761) >>> 0) % 1e3 / 1e3;
-          const n2 = (Math.imul(v + 7, 40503) >>> 0) % 1e3 / 1e3;
-          const lowness = 1 - (work[i + 1] - minY) / h;
-          const spread = 1 + 0.12 * melt * (0.4 + n2) * (0.3 + lowness);
-          arr[i] = work[i] * spread;
-          arr[i + 2] = work[i + 2] * spread;
-          arr[i + 1] = Math.max(minY, work[i + 1] - n * melt * h * 0.08);
-        }
-      }
-      pos.needsUpdate = true;
-      const geo = mv.mesh.geometry;
-      geo.computeVertexNormals();
-      geo.boundingBox = null;
-      geo.boundingSphere = null;
-    }
-    // ------------------------------------------------------------------------------------------------------------------------------------
-    // Decals
-    // ------------------------------------------------------------------------------------------------------------------------------------
-    /** Decal pose in mesh space: position and a rotation taking +Z to the surface normal. */
-    decalPose(mesh, worldPoint, worldNormal, lift) {
-      mesh.updateWorldMatrix(true, false);
-      const s = mesh.matrixWorld.getMaxScaleOnAxis() || 1;
-      const ln = worldNormal.clone().transformDirection(this.m4.copy(mesh.matrixWorld).invert()).normalize();
-      const pos = mesh.worldToLocal(worldPoint.clone()).addScaledVector(ln, lift / s);
-      const quat2 = new this.THREE.Quaternion().setFromUnitVectors(new this.THREE.Vector3(0, 0, 1), ln);
-      return { s, pos, quat: quat2 };
-    }
-    addDecal(mv, decal) {
-      mv.mesh.add(decal.obj);
-      mv.decals.push(decal);
-      this.decalCount++;
-      while (mv.decals.length > 48 || this.decalCount > this.decalCap) {
-        const old = mv.decals.shift();
-        if (!old) break;
-        this.disposeDecal(old);
-      }
-    }
-    disposeDecal(d) {
-      d.obj.parent?.remove(d.obj);
-      d.geometry?.dispose();
-      this.decalCount = Math.max(0, this.decalCount - 1);
-    }
-    addHole(mv, worldPoint, worldNormal, diameter) {
-      const { s, pos, quat: quat2 } = this.decalPose(mv.mesh, worldPoint, worldNormal, 25e-4);
-      const disc = new this.THREE.Mesh(this.kit.discGeometry(), this.kit.discMaterial());
-      disc.position.copy(pos);
-      disc.quaternion.copy(quat2);
-      disc.scale.setScalar(Math.max(4e-3, diameter) * 0.5 * 1.25 / s);
-      disc.renderOrder = 2;
-      this.addDecal(mv, { obj: disc });
-    }
-    /** A star of jagged lines: `rays` rays up to `length` metres, seeded so the same event always draws the same star. */
-    addCrack(mv, worldPoint, worldNormal, rays, length, color, seed) {
-      const { s, pos, quat: quat2 } = this.decalPose(mv.mesh, worldPoint, worldNormal, 2e-3);
-      const rnd = createRng(seed);
-      const verts = [];
-      const n = clamp(Math.round(rays), 3, 16);
-      const L = Math.max(0.02, length) / s;
-      for (let r = 0; r < n; r++) {
-        let ang = r / n * Math.PI * 2 + (rnd() - 0.5) * 0.5;
-        let x = 0;
-        let y = 0;
-        const segs = 3;
-        const total = L * (0.6 + 0.4 * rnd());
-        for (let k = 0; k < segs; k++) {
-          const step = total / segs * (0.7 + 0.6 * rnd());
-          ang += (rnd() - 0.5) * 0.45;
-          const nx = x + Math.cos(ang) * step;
-          const ny = y + Math.sin(ang) * step;
-          verts.push(x, y, 0, nx, ny, 0);
-          if (k > 0 && rnd() < 0.5) {
-            const ba = ang + (rnd() < 0.5 ? -1 : 1) * (0.5 + rnd() * 0.5);
-            const bl = step * (0.6 + 0.6 * rnd());
-            verts.push(nx, ny, 0, nx + Math.cos(ba) * bl, ny + Math.sin(ba) * bl, 0);
-          }
-          x = nx;
-          y = ny;
-        }
-      }
-      const ringR = L * 0.12;
-      for (let k = 0; k < 8; k++) {
-        const a0 = k / 8 * Math.PI * 2;
-        const a1 = (k + 1) / 8 * Math.PI * 2;
-        if (rnd() < 0.75) verts.push(Math.cos(a0) * ringR, Math.sin(a0) * ringR, 0, Math.cos(a1) * ringR, Math.sin(a1) * ringR, 0);
-      }
-      const geo = new this.THREE.BufferGeometry();
-      geo.setAttribute("position", new this.THREE.Float32BufferAttribute(verts, 3));
-      const lines = new this.THREE.LineSegments(geo, this.kit.lineMaterial(color));
-      lines.position.copy(pos);
-      lines.quaternion.copy(quat2);
-      lines.renderOrder = 2;
-      this.addDecal(mv, { obj: lines, geometry: geo });
-    }
-    // ------------------------------------------------------------------------------------------------------------------------------------
-    // Char and heat glow
-    // ------------------------------------------------------------------------------------------------------------------------------------
-    setChar(pv, char, charColor) {
-      if (Math.abs(char - pv.charApplied) < 4e-3) return;
-      pv.charApplied = char;
-      const target = new this.THREE.Color(charColor);
-      for (const mv of pv.meshes) {
-        this.ownMaterial(mv);
-        const mats = materialsOf(mv.mesh.material);
-        mats.forEach((m, i) => {
-          const c = colorOf(m);
-          const base = mv.baseColors?.[i];
-          if (c && base) c.copy(base).lerp(target, clamp(char, 0, 1));
-        });
-      }
-    }
-    /** Emissive glow of a hot part. `temperature` below the glow threshold switches it off. */
-    setGlow(pv, temperatureC) {
-      const hex = heatColor(temperatureC);
-      const key = hex === 0 ? 0 : Math.round(temperatureC / 5) * 5;
-      if (key === pv.glowApplied) return;
-      pv.glowApplied = key;
-      const intensity = hex === 0 ? 0 : clamp(0.35 + (temperatureC - 450) / 900, 0, 1.4);
-      for (const mv of pv.meshes) {
-        this.ownMaterial(mv);
-        for (const m of materialsOf(mv.mesh.material)) {
-          const e = m.emissive;
-          if (e && e.isColor) {
-            e.setHex(hex);
-            m.emissiveIntensity = intensity;
-          }
-        }
-      }
-    }
-    // ------------------------------------------------------------------------------------------------------------------------------------
-    // Melt
-    // ------------------------------------------------------------------------------------------------------------------------------------
-    /** Sag the part: shorter in Y (down to 25 %), a bit wider, vertices pushed down with noise, the bottom stays put. */
-    setMelt(pv, melt) {
-      const m = clamp(melt, 0, 1);
-      if (Math.abs(m - pv.meltApplied) < 0.01) return;
-      pv.meltApplied = m;
-      for (const mv of pv.meshes) {
-        const mesh = mv.mesh;
-        if (mv.meltApplied === 0 && m > 0) {
-          mesh.updateWorldMatrix(true, false);
-          mv.bottomY = this.box.setFromObject(mesh).min.y;
-        }
-        mv.meltApplied = m;
-        mv.moved = true;
-        const sy = lerp(1, 0.25, m);
-        const sxz = 1 + 0.18 * m;
-        mesh.scale.set(mv.origScale.x * sxz, mv.origScale.y * sy, mv.origScale.z * sxz);
-        mesh.position.copy(mv.origPosition);
-        mesh.updateWorldMatrix(true, false);
-        const bottom = this.box.setFromObject(mesh).min.y;
-        const dy = mv.bottomY - bottom;
-        if (Math.abs(dy) > 1e-6 && mesh.parent) {
-          mesh.parent.updateWorldMatrix(true, false);
-          const inv = this.m4.copy(mesh.parent.matrixWorld).invert();
-          this.a.set(0, dy, 0).applyMatrix4(inv);
-          this.b.set(0, 0, 0).applyMatrix4(inv);
-          mesh.position.copy(mv.origPosition).add(this.a.sub(this.b));
-        }
-        if (!(this.lowQuality && this.vertexCount(mv) > 2e4) && this.ownGeometry(mv)) {
-          this.writePositions(mv, positionAttr(mesh.geometry));
-        }
-      }
-    }
-    // ------------------------------------------------------------------------------------------------------------------------------------
-    // Visibility and restore
-    // ------------------------------------------------------------------------------------------------------------------------------------
-    hide(pv, reason) {
-      pv.gone = reason;
-      for (const mv of pv.meshes) mv.mesh.visible = false;
-    }
-    /** Bring one mesh back to how it was when it was bound. */
-    restoreMesh(mv) {
-      const mesh = mv.mesh;
-      for (const d of mv.decals) this.disposeDecal(d);
-      mv.decals.length = 0;
-      if (mv.ownGeo) {
-        mesh.geometry.dispose();
-        mesh.geometry = mv.origGeometry;
-        mv.ownGeo = false;
-        mv.work = null;
-      }
-      if (mv.ownMat) {
-        for (const m of materialsOf(mesh.material)) m.dispose();
-        mesh.material = mv.origMaterial;
-        mv.ownMat = false;
-        mv.baseColors = null;
-      }
-      mesh.visible = mv.origVisible;
-      if (mv.origParent && mesh.parent !== mv.origParent) {
-        mv.origParent.add(mesh);
-        mv.moved = true;
-      }
-      if (mv.moved) {
-        mesh.position.copy(mv.origPosition);
-        mesh.quaternion.copy(mv.origQuaternion);
-        mesh.scale.copy(mv.origScale);
-        mv.moved = false;
-      }
-      mv.meltApplied = 0;
-    }
-    restorePart(pv) {
-      for (const mv of pv.meshes) this.restoreMesh(mv);
-      pv.charApplied = 0;
-      pv.glowApplied = 0;
-      pv.meltApplied = 0;
-      pv.gone = "none";
-    }
-    dispose() {
-      this.kit.dispose();
-    }
-  };
-
-  // src/renderer.ts
-  var GLOW_FROM_C = 430;
-  var QUEUE_CAP = 4e3;
-  var FLUID_COLORS = {
-    water: 9226495,
-    fuel: 14262322,
-    oil: 2760728,
-    gas: 15921906,
-    sap: 12098362,
-    acid: 10211900,
-    blood: 9046538
-  };
-  var SMOKE_TONES = { white: 15132390, grey: 9079434, black: 2763306 };
-  var DEFAULT_SPEED = {
-    sparks: 3,
-    splinters: 2.5,
-    dust: 1,
-    shards: 2.5,
-    fibers: 1.2,
-    leaves: 1.2,
-    drips: 0.5,
-    ash: 0.8,
-    chips: 2.5,
-    smoke: 0.8,
-    steam: 1,
-    fire: 1.2,
-    flash: 0,
-    foam: 2.5
-  };
-  function impactKey(def) {
-    if (!def) return "impact_wood";
-    const tags = def.tags ?? [];
-    if (tags.includes("metal")) return "impact_metal";
-    if (def.visual?.transparent || def.fracture === "shatter") return "impact_glass";
-    if (def.fracture === "crumble") return "impact_masonry";
-    if (def.fracture === "tear") return "impact_soft";
-    return def.fracture === "none" ? "impact_metal" : "impact_wood";
-  }
-  function fractureKey(def, style) {
-    switch (style) {
-      case "shatter":
-        return "shatter_glass";
-      case "crumble":
-        return "crumble";
-      case "splinter":
-        return "splinter";
-      default:
-        return impactKey(def);
-    }
-  }
-  function fallbackColor(id, def) {
-    if (def?.tags?.includes("metal")) return 9080726;
-    if (def?.visual?.transparent) return 10473696;
-    const h = hashString(id);
-    return mixHex(7035464, 10130568, h % 100 / 100);
-  }
-  function materialsOf2(m) {
-    return Array.isArray(m) ? m : [m];
-  }
-  function createDestructionRenderer(THREE, options) {
-    return new Renderer(THREE, options);
-  }
-  var Renderer = class {
-    constructor(THREE, o) {
-      __publicField(this, "THREE", THREE);
-      __publicField(this, "o", o);
-      __publicField(this, "world");
-      __publicField(this, "scene");
-      __publicField(this, "quality");
-      __publicField(this, "low");
-      __publicField(this, "groundAt");
-      __publicField(this, "gravity");
-      __publicField(this, "autoSplit");
-      __publicField(this, "maxFragments");
-      __publicField(this, "bounds", /* @__PURE__ */ new Map());
-      __publicField(this, "queue", []);
-      __publicField(this, "unsubscribe");
-      __publicField(this, "visuals");
-      __publicField(this, "particles");
-      __publicField(this, "fragments");
-      __publicField(this, "ground");
-      __publicField(this, "pieceSys");
-      __publicField(this, "active", /* @__PURE__ */ new Map());
-      __publicField(this, "fires", /* @__PURE__ */ new Map());
-      __publicField(this, "leaks", []);
-      __publicField(this, "homeTags", []);
-      __publicField(this, "throttles", /* @__PURE__ */ new Map());
-      __publicField(this, "rng", createRng(12648430));
-      __publicField(this, "light", null);
-      __publicField(this, "lightT", 0);
-      __publicField(this, "lightDur", 0.3);
-      __publicField(this, "lightPeak", 0);
-      __publicField(this, "time", 0);
-      __publicField(this, "scanTimer", 0);
-      __publicField(this, "disposed", false);
-      __publicField(this, "box");
-      __publicField(this, "tmpQ");
-      __publicField(this, "v1");
-      __publicField(this, "v2");
-      this.world = o.world;
-      this.scene = o.scene;
-      this.quality = o.quality ?? "medium";
-      this.low = this.quality === "low";
-      this.groundAt = o.groundAt ?? (() => 0);
-      this.gravity = o.gravity ?? 9.81;
-      this.autoSplit = o.autoSplit !== false;
-      this.maxFragments = o.maxFragments ?? 160;
-      this.box = new THREE.Box3();
-      this.tmpQ = new THREE.Quaternion();
-      this.v1 = new THREE.Vector3();
-      this.v2 = new THREE.Vector3();
-      const maxParticles = Math.max(8, Math.floor((o.maxParticles ?? 2500) * (this.low ? 0.5 : 1)));
-      this.visuals = new Visuals(THREE, this.low, 600);
-      this.ground = new GroundSpots(THREE, o.scene, this.groundAt, 48);
-      this.particles = new ParticleSystem(THREE, {
-        capacity: maxParticles,
-        scene: o.scene,
-        density: this.low ? 0.6 : 1,
-        pointScale: o.pointScale ?? 700,
-        groundAt: this.groundAt,
-        gravity: this.gravity,
-        onLand: (x, _y, z, color, tag) => {
-          const home = this.homeTags[tag - 1] ?? "";
-          this.ground.add("puddle", x, z, 0.05 + this.rng() * 0.04, color, home);
-        }
-      });
-      this.fragments = new FragmentSystem(THREE, {
-        scene: o.scene,
-        groundAt: this.groundAt,
-        gravity: this.gravity,
-        max: this.maxFragments,
-        life: o.fragmentLife ?? 12
-      });
-      this.pieceSys = new PieceSystem(THREE, {
-        groundAt: this.groundAt,
-        gravity: this.gravity,
-        scene: o.scene,
-        onHardLanding: (p, point, speed) => this.hardLanding(p, point, speed)
-      });
-      this.unsubscribe = this.world.on("*", (ev) => {
-        if (this.queue.length < QUEUE_CAP) this.queue.push(ev);
-      });
-    }
-    // ----------------------------------------------------------------------------------------------------------------------------------
-    // Binding
-    // ----------------------------------------------------------------------------------------------------------------------------------
-    bind(objectId, root, options = {}) {
-      if (this.bounds.has(objectId)) this.unbind(objectId);
-      const state = this.world.state(objectId);
-      const partIds = new Set((state?.parts ?? []).map((p) => p.id));
-      const byPart = /* @__PURE__ */ new Map();
-      const taken = /* @__PURE__ */ new Set();
-      const add = (pid, m) => {
-        if (taken.has(m)) return;
-        taken.add(m);
-        const l = byPart.get(pid);
-        if (l) l.push(m);
-        else byPart.set(pid, [m]);
-      };
-      const meshesIn = (o) => {
-        const out = [];
-        o.traverse((c) => {
-          if (c.isMesh) out.push(c);
-        });
-        return out;
-      };
-      if (options.parts) {
-        for (const [pid, v] of Object.entries(options.parts)) {
-          for (const o of Array.isArray(v) ? v : [v]) for (const m of meshesIn(o)) add(pid, m);
-        }
-      } else {
-        const leftovers = [];
-        for (const m of meshesIn(root)) {
-          const ud = m.userData?.destructionPart;
-          if (typeof ud === "string" && partIds.has(ud)) add(ud, m);
-          else if (partIds.has(m.name)) add(m.name, m);
-          else leftovers.push(m);
-        }
-        if (leftovers.length) this.matchByBox(objectId, root, leftovers, add);
-      }
-      const bound = { id: objectId, root, sync: options.syncTransform !== false, parts: /* @__PURE__ */ new Map(), lastPos: null, lastQuat: null, piece: null, isSplit: false };
-      for (const pid of partIds) bound.parts.set(pid, this.makePartVis(objectId, pid, state?.parts.find((p) => p.id === pid)?.material ?? "", byPart.get(pid) ?? []));
-      for (const [pid, meshes] of byPart) {
-        if (!bound.parts.has(pid)) bound.parts.set(pid, this.makePartVis(objectId, pid, this.world.part(objectId, pid)?.material ?? "", meshes));
-      }
-      this.bounds.set(objectId, bound);
-    }
-    makePartVis(home, id, material, meshes) {
-      return { id, home, material, meshes: meshes.map((m) => this.visuals.makeMeshVis(m, home)), charApplied: 0, glowApplied: 0, meltApplied: 0, gone: "none" };
-    }
-    /** Match unlabelled meshes to the part whose shape contains the centre of the mesh's bounding box. */
-    matchByBox(objectId, root, meshes, add) {
-      let specParts;
-      try {
-        specParts = this.world.serialize?.().objects.find((o) => o.id === objectId)?.spec.parts;
-      } catch {
-        specParts = void 0;
-      }
-      if (!specParts) return;
-      root.updateMatrixWorld(true);
-      const e = new this.THREE.Euler();
-      const q = new this.THREE.Quaternion();
-      for (const m of meshes) {
-        this.box.setFromObject(m);
-        if (this.box.isEmpty()) continue;
-        const c = root.worldToLocal(this.box.getCenter(this.v1));
-        let best = null;
-        let bestVol = Infinity;
-        for (const p of specParts) {
-          const l = this.v2.set(c.x - p.position[0], c.y - p.position[1], c.z - p.position[2]);
-          if (p.rotation) l.applyQuaternion(q.setFromEuler(e.set(p.rotation[0], p.rotation[1], p.rotation[2], "XYZ")).invert());
-          let inside = false;
-          let vol = 0;
-          const s = p.shape;
-          if (s.kind === "box") {
-            inside = Math.abs(l.x) <= s.size[0] / 2 && Math.abs(l.y) <= s.size[1] / 2 && Math.abs(l.z) <= s.size[2] / 2;
-            vol = s.size[0] * s.size[1] * s.size[2];
-          } else if (s.kind === "cylinder") {
-            inside = Math.hypot(l.x, l.z) <= s.radius && Math.abs(l.y) <= s.height / 2;
-            vol = Math.PI * s.radius * s.radius * s.height;
-          } else {
-            inside = l.length() <= s.radius;
-            vol = 4 / 3 * Math.PI * s.radius ** 3;
-          }
-          if (inside && vol < bestVol) {
-            best = p;
-            bestVol = vol;
-          }
-        }
-        if (best) add(best.id, m);
-      }
-    }
-    unbind(objectId) {
-      const b = this.bounds.get(objectId);
-      if (!b) return;
-      this.restore(objectId);
-      this.pieceSys.remove(objectId);
-      this.bounds.delete(objectId);
-    }
-    // ----------------------------------------------------------------------------------------------------------------------------------
-    // Pieces
-    // ----------------------------------------------------------------------------------------------------------------------------------
-    /** Half extents and centre of the box around some meshes, in the local space of `root`. */
-    measure(root, meshes) {
-      root.updateMatrixWorld(true);
-      const inv = root.matrixWorld.clone().invert();
-      const total = new this.THREE.Box3();
-      const m4 = new this.THREE.Matrix4();
-      for (const m of meshes) {
-        const g = m.geometry;
-        if (!g.boundingBox) g.computeBoundingBox();
-        if (!g.boundingBox || g.boundingBox.isEmpty()) continue;
-        total.union(g.boundingBox.clone().applyMatrix4(m4.multiplyMatrices(inv, m.matrixWorld)));
-      }
-      if (total.isEmpty()) return { half: [0.25, 0.25, 0.25], center: new this.THREE.Vector3() };
-      const size = total.getSize(new this.THREE.Vector3());
-      return { half: [Math.max(0.02, size.x / 2), Math.max(0.02, size.y / 2), Math.max(0.02, size.z / 2)], center: total.getCenter(new this.THREE.Vector3()) };
-    }
-    meshesOf(b) {
-      const out = [];
-      for (const pv of b.parts.values()) if (pv.gone === "none") for (const mv of pv.meshes) out.push(mv.mesh);
-      return out;
-    }
-    massOf(objectId) {
-      const st = this.world.state(objectId);
-      if (!st) return 5;
-      let m = 0;
-      for (const p of st.parts) if (p.status !== "broken" && p.status !== "melted" && p.status !== "ashes") m += p.mass;
-      return m > 0 ? m : 5;
-    }
-    makePiece(objectId, options = {}) {
-      const b = this.bounds.get(objectId);
-      if (!b) throw new Error(`game-destruction-three: object "${objectId}" is not bound`);
-      if (b.root.parent && b.root.parent !== this.scene) this.scene.attach(b.root);
-      const { half, center } = this.measure(b.root, this.meshesOf(b));
-      const piece = this.pieceSys.create(objectId, b.root, half, center, options.mass ?? this.massOf(objectId), options.velocity);
-      b.piece = piece;
-      return piece;
-    }
-    pieces() {
-      return [...this.pieceSys.list];
-    }
-    piece(objectId) {
-      return this.pieceSys.get(objectId);
-    }
-    impulse(objectId, impulse, point) {
-      const p = this.pieceSys.get(objectId);
-      if (p) this.pieceSys.impulse(p, impulse, point);
-    }
-    hardLanding(p, point, speed) {
-      const key = this.impactSoundOf(p.objectId);
-      this.sound(key, point, clamp(speed / 10, 0.2, 1));
-      this.syncBound(p.objectId);
-      try {
-        this.world.hit(p.objectId, { type: "blunt", point, energy: 0.5 * p.mass * speed * speed, radius: 0.08, direction: [0, -1, 0], source: "fall" });
-      } catch {
-      }
-    }
-    impactSoundOf(objectId) {
-      const st = this.world.state(objectId);
-      let best;
-      let mass = -1;
-      for (const p of st?.parts ?? []) {
-        if (p.mass > mass) {
-          mass = p.mass;
-          best = this.world.materials.get(p.material);
-        }
-      }
-      return impactKey(best);
-    }
-    // ----------------------------------------------------------------------------------------------------------------------------------
-    // Update
-    // ----------------------------------------------------------------------------------------------------------------------------------
-    update(dt) {
-      if (this.disposed) return;
-      dt = clamp(dt, 0, 0.1);
-      this.time += dt;
-      this.drainQueue();
-      this.updateActive(dt);
-      this.updateLeaks(dt);
-      this.pieceSys.update(dt);
-      this.fragments.update(dt);
-      this.ground.update(dt);
-      this.updateLight(dt);
-      this.particles.update(dt);
-      this.syncTransforms();
-    }
-    drainQueue() {
-      const batch = this.queue.splice(0, this.queue.length);
-      for (const ev of batch) {
-        try {
-          this.apply(ev);
-        } catch (err) {
-          if (typeof console !== "undefined") console.error("game-destruction-three: failed to apply", ev.type, err);
-        }
-      }
-    }
-    syncTransforms() {
-      for (const b of this.bounds.values()) this.syncOne(b);
-    }
-    /** Push the current transform of one bound object to the world right now (used before a landing hit). */
-    syncBound(objectId) {
-      const b = this.bounds.get(objectId);
-      if (b) this.syncOne(b);
-    }
-    syncOne(b) {
-      if (!b.sync) return;
-      const p = this.v1;
-      const q = this.tmpQ;
-      b.root.updateWorldMatrix(true, false);
-      b.root.matrixWorld.decompose(p, q, this.v2);
-      const last = b.lastPos;
-      const lq = b.lastQuat;
-      const moved = !last || !lq || Math.abs(p.x - last[0]) + Math.abs(p.y - last[1]) + Math.abs(p.z - last[2]) > 1e-5 || Math.abs(q.x - lq[0]) + Math.abs(q.y - lq[1]) + Math.abs(q.z - lq[2]) + Math.abs(q.w - lq[3]) > 1e-6;
-      if (!moved) return;
-      b.lastPos = [p.x, p.y, p.z];
-      b.lastQuat = [q.x, q.y, q.z, q.w];
-      if (this.world.has(b.id)) this.world.setTransform(b.id, [p.x, p.y, p.z], [q.x, q.y, q.z, q.w]);
-    }
-    // ----------------------------------------------------------------------------------------------------------------------------------
-    // Events
-    // ----------------------------------------------------------------------------------------------------------------------------------
-    apply(ev) {
-      switch (ev.type) {
-        case "damage":
-          if (ev.damageType === "heat" || ev.damageType === "fire" || ev.damageType === "explosive") this.activate(ev.object, ev.part);
-          break;
-        case "dent":
-          this.onDent(ev);
-          break;
-        case "hole":
-          this.onHole(ev);
-          break;
-        case "crack":
-          this.onCrack(ev);
-          break;
-        case "ricochet": {
-          const d = ev.direction;
-          this.particles.burst("sparks", ev.point, d, 4 + Math.min(10, ev.energy / 150), 4);
-          this.sound("ricochet", ev.point, 0.7);
-          break;
-        }
-        case "debris":
-          this.particles.burst(ev.kind, ev.point, ev.normal, ev.count, ev.speed > 0 ? ev.speed : DEFAULT_SPEED[ev.kind] ?? 1, this.debrisOptions(ev.kind, ev.object, ev.part));
-          break;
-        case "fracture":
-          this.onFracture(ev);
-          break;
-        case "detach":
-          this.onDetach(ev);
-          break;
-        case "disassemble_progress": {
-          const k = `unscrew:${ev.joint}`;
-          if (this.time - (this.throttles.get(k) ?? -1) > 0.25) {
-            this.throttles.set(k, this.time);
-            this.sound("unscrew", this.rootPoint(ev.object), clamp(0.3 + ev.progress * 0.5, 0, 1));
-          }
-          break;
-        }
-        case "ignite":
-          this.fires.set(`${ev.object}|${ev.part}`, { object: ev.object, part: ev.part, point: ev.point, accFire: 0, accSmoke: 0 });
-          this.activate(ev.object, ev.part);
-          this.particles.burst("fire", ev.point, [0, 1, 0], 6, 1);
-          this.sound("ignite", ev.point, 0.7);
-          this.sound("burn_loop", ev.point, 0.5);
-          break;
-        case "extinguish": {
-          const f = this.fires.get(`${ev.object}|${ev.part}`);
-          if (f) {
-            this.fires.delete(`${ev.object}|${ev.part}`);
-            this.particles.burst("steam", f.point, [0, 1, 0], 14, 1.2);
-          }
-          this.activate(ev.object, ev.part);
-          this.sound("extinguish", f?.point ?? this.rootPoint(ev.object), 0.6);
-          break;
-        }
-        case "burnout": {
-          this.fires.delete(`${ev.object}|${ev.part}`);
-          this.particles.burst("ash", ev.point, [0, 1, 0], 16, 1);
-          this.particles.burst("smoke", ev.point, [0, 1, 0], 6, 0.8, { color: SMOKE_TONES.grey });
-          const pv = this.partVis(ev.object, ev.part);
-          if (pv) {
-            const def = this.world.materials.get(pv.material);
-            this.visuals.setChar(pv, 1, def?.visual?.charColor ?? 1709072);
-          }
-          this.activate(ev.object, ev.part);
-          break;
-        }
-        case "melt":
-          this.activate(ev.object, ev.part);
-          if (this.time - (this.throttles.get(`melt:${ev.object}|${ev.part}`) ?? -9) > 1.5) {
-            this.throttles.set(`melt:${ev.object}|${ev.part}`, this.time);
-            this.sound("melt_sizzle", this.rootPoint(ev.object), 0.4);
-          }
-          break;
-        case "drip": {
-          const b = this.bounds.get(ev.object);
-          const pv = b?.parts.get(ev.part);
-          const def = this.world.materials.get(ev.material);
-          const color = (pv && this.partColor(pv, def)) ?? fallbackColor(ev.material, def);
-          let tag = this.homeTags.indexOf(ev.object) + 1;
-          if (tag === 0) tag = this.homeTags.push(ev.object);
-          this.particles.spawn("drips", ev.point, [(this.rng() - 0.5) * 0.1, -0.1, (this.rng() - 0.5) * 0.1], { color, tag });
-          break;
-        }
-        case "leak": {
-          const key = `${ev.object}|${ev.part}`;
-          const same = this.leaks.find((l) => l.object === ev.object && l.part === ev.part && Math.hypot(l.point[0] - ev.point[0], l.point[1] - ev.point[1], l.point[2] - ev.point[2]) < 0.03);
-          if (same) {
-            same.rate = ev.rate;
-            same.direction = ev.direction;
-          } else {
-            if (this.leaks.length >= 24) this.leaks.shift();
-            this.leaks.push({ object: ev.object, part: ev.part, fluid: ev.fluid, point: ev.point, direction: ev.direction, rate: ev.rate, pressurized: ev.pressurized, acc: 0 });
-          }
-          void key;
-          break;
-        }
-        case "explode":
-          this.onExplode(ev);
-          break;
-        case "destroyed":
-          break;
-      }
-    }
-    rootPoint(objectId) {
-      const b = this.bounds.get(objectId);
-      return b ? [b.root.position.x, b.root.position.y, b.root.position.z] : [0, 0, 0];
-    }
-    sound(key, point, volume) {
-      this.o.onSound?.(key, point, volume);
-    }
-    partVis(objectId, partId) {
-      return this.bounds.get(objectId)?.parts.get(partId) ?? null;
-    }
-    activate(objectId, partId) {
-      this.active.set(`${objectId}|${partId}`, { object: objectId, part: partId });
-    }
-    /** Current colour of the part's first mesh (char included), or null. */
-    partColor(pv, def) {
-      const mv = pv.meshes[0];
-      if (!mv) return null;
-      const mat = materialsOf2(mv.mesh.material)[0];
-      const c = mat?.color;
-      if (c && c.isColor) return c.getHex();
-      return def ? fallbackColor(def.id, def) : null;
-    }
-    debrisOptions(kind, objectId, partId) {
-      const pv = this.partVis(objectId, partId);
-      const def = pv ? this.world.materials.get(pv.material) : void 0;
-      if (kind === "smoke") return { color: SMOKE_TONES[def?.thermal.smoke ?? "grey"] };
-      if (kind === "fibers" || kind === "leaves") {
-        const c = pv ? this.visuals.baseColorHex(pv.meshes[0] ?? {}) : -1;
-        return c >= 0 ? { color: c } : void 0;
-      }
-      if (kind === "dust" || kind === "chips") {
-        const c = pv && pv.meshes[0] ? this.visuals.baseColorHex(pv.meshes[0]) : -1;
-        return c >= 0 && kind === "chips" ? { color: c } : void 0;
-      }
-      return void 0;
-    }
-    /** Mesh of the part closest to a world point. */
-    nearestMesh(pv, p) {
-      let best = null;
-      let bd = Infinity;
-      for (const mv of pv.meshes) {
-        if (!mv.mesh.visible) continue;
-        const d = this.box.setFromObject(mv.mesh).distanceToPoint(p);
-        if (d < bd) {
-          bd = d;
-          best = mv;
-        }
-      }
-      return best;
-    }
-    worldDir(b, v) {
-      b.root.updateWorldMatrix(true, false);
-      return new this.THREE.Vector3(v[0], v[1], v[2]).applyQuaternion(b.root.getWorldQuaternion(this.tmpQ)).normalize();
-    }
-    onDent(ev) {
-      const b = this.bounds.get(ev.object);
-      const pv = b?.parts.get(ev.part);
-      if (!b || !pv) return;
-      const def = this.world.materials.get(pv.material);
-      const wp = new this.THREE.Vector3(ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]);
-      const wn = this.worldDir(b, ev.dent.normal);
-      for (const mv of pv.meshes) {
-        if (!mv.mesh.visible) continue;
-        this.visuals.applyDent(mv, wp, wn, ev.dent);
-      }
-      if (def?.tags?.includes("metal")) this.particles.burst("sparks", ev.worldPoint, [wn.x, wn.y, wn.z], 4 + Math.min(8, ev.dent.depth * 150), 3.2);
-      this.sound(impactKey(def), ev.worldPoint, clamp(0.3 + ev.dent.depth * 12, 0.3, 1));
-    }
-    onHole(ev) {
-      const b = this.bounds.get(ev.object);
-      const pv = b?.parts.get(ev.part);
-      if (!b || !pv) return;
-      const def = this.world.materials.get(pv.material);
-      const n = this.worldDir(b, ev.hole.normal);
-      const draw = (point, normal) => {
-        const wp = new this.THREE.Vector3(point[0], point[1], point[2]);
-        const mv = this.nearestMesh(pv, wp);
-        if (!mv) return;
-        if (def?.visual?.transparent) {
-          const seed = hashNumbers(ev.time, point[0], point[1], point[2]);
-          this.visuals.addCrack(mv, wp, normal, 7, Math.max(0.05, ev.hole.diameter * 5), 15267071, seed);
-        } else {
-          this.visuals.addHole(mv, wp, normal, ev.hole.diameter);
-        }
-      };
-      draw(ev.worldPoint, n);
-      if (ev.hole.through && ev.exitPoint) draw(ev.exitPoint, n.clone().negate());
-      if (def?.tags?.includes("metal")) this.particles.burst("sparks", ev.worldPoint, [n.x, n.y, n.z], 6, 3.5);
-      this.sound(impactKey(def), ev.worldPoint, 0.6);
-    }
-    onCrack(ev) {
-      const b = this.bounds.get(ev.object);
-      const pv = b?.parts.get(ev.part);
-      if (!b || !pv) return;
-      const def = this.world.materials.get(pv.material);
-      const wp = new this.THREE.Vector3(ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]);
-      const mv = this.nearestMesh(pv, wp);
-      if (mv) {
-        const color = def?.visual?.transparent ? 15267071 : 2762532;
-        this.visuals.addCrack(mv, wp, this.worldDir(b, ev.crack.normal), ev.crack.rays, ev.crack.length, color, hashNumbers(ev.time, ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]));
-      }
-      this.sound(impactKey(def), ev.worldPoint, 0.5);
-    }
-    onFracture(ev) {
-      const b = this.bounds.get(ev.object);
-      const pv = b?.parts.get(ev.part);
-      const matId = pv?.material || (ev.fragments[0]?.material ?? "");
-      const def = this.world.materials.get(matId);
-      let color = fallbackColor(matId, def);
-      let opacity = 0.5;
-      const transparent = def?.visual?.transparent === true;
-      if (pv) {
-        const c = this.partColor(pv, def);
-        if (c !== null) color = c;
-        const m = pv.meshes[0] ? materialsOf2(pv.meshes[0].origMaterial)[0] : void 0;
-        if (m && m.transparent) opacity = clamp(m.opacity, 0.2, 0.8);
-        this.visuals.hide(pv, "broken");
-      }
-      const maxAlive = this.low ? Math.floor(this.maxFragments / 2) : this.maxFragments;
-      const step = this.low ? 2 : 1;
-      for (let i = 0; i < ev.fragments.length; i += step) {
-        const fr = ev.fragments[i];
-        const fdef = this.world.materials.get(fr.material);
-        const mat = this.fragments.materialFor(fr.material, fdef === def || !fdef ? color : fallbackColor(fr.material, fdef), transparent || fdef?.visual?.transparent === true, opacity);
-        this.fragments.spawn(fr, mat, ev.object, maxAlive);
-      }
-      const up = [0, 1, 0];
-      const sizeK = clamp(ev.fragments.length / 10, 0.5, 2);
-      switch (ev.style) {
-        case "shatter":
-          this.particles.burst("shards", ev.point, up, 18 * sizeK, 3);
-          break;
-        case "crumble":
-          this.particles.burst("dust", ev.point, up, 16 * sizeK, 1.2, { color: pv ? this.partColor(pv, def) ?? void 0 : void 0 });
-          this.particles.burst("chips", ev.point, up, 6, 3);
-          break;
-        case "splinter":
-          this.particles.burst("splinters", ev.point, up, 14 * sizeK, 3);
-          this.particles.burst("dust", ev.point, up, 5, 0.8, { color: 11901556 });
-          break;
-        case "tear":
-          this.particles.burst("fibers", ev.point, up, 12 * sizeK, 1.6, { color });
-          break;
-        case "snap":
-          this.particles.burst("chips", ev.point, up, 8 * sizeK, 3);
-          break;
-        default:
-          this.particles.burst("sparks", ev.point, up, 10, 4);
-      }
-      this.sound(fractureKey(def, ev.style), ev.point, clamp(0.4 + ev.fragments.length * 0.03, 0.4, 1));
-    }
-    onDetach(ev) {
-      this.sound("detach", this.rootPoint(ev.object), 0.5);
-      if (!this.autoSplit) return;
-      const b = this.bounds.get(ev.object);
-      if (!b) return;
-      const st = this.world.state(ev.object);
-      if (!st || st.groups.length < 2) return;
-      const loose = st.groups.length - 1;
-      for (let i = 0; i < loose; i++) {
-        let newId;
-        try {
-          newId = this.world.splitGroup(ev.object, 1);
-        } catch {
-          break;
-        }
-        this.adoptSplit(b, newId);
-      }
-      const old = b.piece;
-      if (old) {
-        const { half, center } = this.measure(b.root, this.meshesOf(b));
-        old.halfExtents = half;
-        this.pieceSys.setCenter(old, center);
-        old.mass = Math.max(0.05, this.massOf(ev.object));
-        old.sleeping = false;
-      }
-    }
-    /** The renderer side of `splitGroup`: a new group holding the meshes of the new object, made a piece. */
-    adoptSplit(from, newId) {
-      const state = this.world.state(newId);
-      const root = from.root;
-      root.updateWorldMatrix(true, false);
-      const group = new this.THREE.Group();
-      group.name = `destruction-piece-${newId}`;
-      root.getWorldPosition(group.position);
-      root.getWorldQuaternion(group.quaternion);
-      this.scene.add(group);
-      group.updateMatrixWorld(true);
-      const nb = { id: newId, root: group, sync: true, parts: /* @__PURE__ */ new Map(), lastPos: null, lastQuat: null, piece: null, isSplit: true };
-      for (const p of state?.parts ?? []) {
-        const pv = from.parts.get(p.id);
-        if (!pv) continue;
-        from.parts.delete(p.id);
-        nb.parts.set(p.id, pv);
-        for (const mv of pv.meshes) {
-          group.attach(mv.mesh);
-          mv.moved = true;
-        }
-      }
-      this.bounds.set(newId, nb);
-      const meshes = this.meshesOf(nb);
-      if (meshes.length === 0) return;
-      const { half, center } = this.measure(group, meshes);
-      let vel = [0, 0, 0];
-      let ang = [0, 0, 0];
-      const op = from.piece;
-      if (op) {
-        vel = [...op.velocity];
-        ang = [...op.angularVelocity];
-        const c = this.pieceSys.centerOf(op, new this.THREE.Vector3());
-        const nc = center.clone().applyQuaternion(group.quaternion).add(group.position);
-        vel[0] += ang[1] * (nc.z - c.z) - ang[2] * (nc.y - c.y);
-        vel[1] += ang[2] * (nc.x - c.x) - ang[0] * (nc.z - c.z);
-        vel[2] += ang[0] * (nc.y - c.y) - ang[1] * (nc.x - c.x);
-      }
-      const piece = this.pieceSys.create(newId, group, half, center, this.massOf(newId), vel, ang);
-      nb.piece = piece;
-      this.o.onPiece?.(piece);
-    }
-    onExplode(ev) {
-      const p = ev.point;
-      const k = clamp(ev.radius / 3, 0.4, 2.5);
-      this.particles.burst("flash", p, [0, 1, 0], 1, 0, { size: k });
-      this.particles.burst("fire", p, [0, 1, 0], 34 * k, 4 * k, { size: 1 + k * 0.5 });
-      this.particles.burst("smoke", p, [0, 1, 0], 24 * k, 2.2, { color: SMOKE_TONES.black, size: 1 + k * 0.6 });
-      this.particles.burst("dust", p, [0, 1, 0], 22 * k, 3.5 * k);
-      this.particles.burst("sparks", p, [0, 1, 0], 16 * k, 8);
-      this.particles.push(p, ev.radius, 4);
-      if (this.o.explosionLight !== false) {
-        if (!this.light) {
-          this.light = new this.THREE.PointLight(16754784, 0, 10, 2);
-          this.light.name = "destruction-explosion-light";
-        }
-        if (!this.light.parent) this.scene.add(this.light);
-        this.light.position.set(p[0], p[1] + 0.5, p[2]);
-        this.light.distance = Math.max(6, ev.radius * 3);
-        this.lightPeak = clamp(Math.sqrt(Math.max(1, ev.energy)) * 0.6, 10, 400);
-        this.lightDur = 0.35;
-        this.lightT = this.lightDur;
-      }
-      const c = this.v1;
-      for (const pc of this.pieceSys.list) {
-        this.pieceSys.centerOf(pc, c);
-        const dx = c.x - p[0];
-        const dy = c.y - p[1];
-        const dz = c.z - p[2];
-        const d = Math.hypot(dx, dy, dz);
-        if (d > ev.radius) continue;
-        const fall = (1 - d / ev.radius) ** 2;
-        const speed = Math.min(30, Math.sqrt(2 * ev.energy * 0.02 / pc.mass)) * fall;
-        const inv = d > 1e-4 ? 1 / d : 0;
-        const dir = d > 1e-4 ? [dx * inv, dy * inv + 0.3, dz * inv] : [0, 1, 0];
-        const spread = pc.halfExtents[0];
-        this.pieceSys.impulse(pc, [dir[0] * speed * pc.mass, dir[1] * speed * pc.mass, dir[2] * speed * pc.mass], [c.x + (this.rng() - 0.5) * spread, c.y + spread * 0.5, c.z + (this.rng() - 0.5) * spread]);
-      }
-      this.fragments.blast(p, ev.radius, Math.min(20, Math.sqrt(ev.energy) * 0.08));
-      this.sound("explode", p, clamp(0.5 + ev.radius / 10, 0.5, 1));
-    }
-    updateLight(dt) {
-      if (!this.light || this.lightT <= 0) return;
-      this.lightT = Math.max(0, this.lightT - dt);
-      const t = this.lightT / this.lightDur;
-      this.light.intensity = this.lightPeak * t * t;
-    }
-    // ----------------------------------------------------------------------------------------------------------------------------------
-    // Fire, heat, char, melt, leaks
-    // ----------------------------------------------------------------------------------------------------------------------------------
-    updateActive(dt) {
-      this.scanTimer += dt;
-      if (this.scanTimer >= 0.4) {
-        this.scanTimer = 0;
-        for (const b of this.bounds.values()) {
-          for (const pv of b.parts.values()) {
-            if (pv.gone !== "none" && pv.gone !== "broken") continue;
-            const ps = this.world.part(b.id, pv.id);
-            if (!ps) continue;
-            const def = this.world.materials.get(pv.material);
-            if (ps.burning || def?.visual?.glows && ps.temperature > GLOW_FROM_C || Math.abs(ps.char - pv.charApplied) > 0.01 || Math.abs(ps.melt - pv.meltApplied) > 0.01 || pv.gone === "none" && (ps.status === "melted" || ps.status === "ashes")) {
-              this.activate(b.id, pv.id);
-            }
-          }
-        }
-      }
-      for (const [key, a] of this.active) {
-        const pv = this.partVis(a.object, a.part);
-        const ps = pv ? this.world.part(a.object, a.part) : null;
-        if (!pv || !ps) {
-          this.active.delete(key);
-          continue;
-        }
-        const def = this.world.materials.get(pv.material);
-        if (pv.gone === "none") {
-          this.visuals.setChar(pv, ps.char, def?.visual?.charColor ?? 1709072);
-          if (def?.visual?.glows) this.visuals.setGlow(pv, ps.temperature);
-          this.visuals.setMelt(pv, ps.melt);
-          if (ps.status === "melted") this.onGone(a.object, pv, "melted", def);
-          else if (ps.status === "ashes") this.onGone(a.object, pv, "ashes", def);
-        }
-        const fire = this.fires.get(key);
-        if (fire) {
-          if (ps.burning && ps.status !== "broken" && ps.status !== "ashes" && ps.status !== "melted") this.emitFire(fire, pv, def, dt);
-          else this.fires.delete(key);
-        }
-        const hot = def?.visual?.glows === true && ps.temperature > GLOW_FROM_C;
-        if (!ps.burning && !hot && Math.abs(ps.char - pv.charApplied) < 0.01 && Math.abs(ps.melt - pv.meltApplied) < 0.01) {
-          if (def?.visual?.glows && pv.gone === "none") this.visuals.setGlow(pv, 0);
-          this.active.delete(key);
-        }
-      }
-    }
-    onGone(objectId, pv, reason, def) {
-      const bb = new this.THREE.Box3();
-      for (const mv of pv.meshes) bb.union(this.box.setFromObject(mv.mesh));
-      this.visuals.hide(pv, reason);
-      if (bb.isEmpty()) return;
-      const c = bb.getCenter(new this.THREE.Vector3());
-      const s = bb.getSize(new this.THREE.Vector3());
-      const footprint = Math.sqrt(Math.max(s.x * s.z, 1e-4));
-      if (reason === "melted") {
-        this.ground.add("puddle", c.x, c.z, clamp(footprint * 0.55, 0.05, 1), this.partColor(pv, def) ?? fallbackColor(pv.material, def), objectId);
-      } else {
-        this.ground.add("ash", c.x, c.z, clamp(footprint * 0.35, 0.04, 0.5), 1907224, objectId);
-        this.particles.burst("ash", [c.x, bb.max.y, c.z], [0, 1, 0], 10, 0.8);
-      }
-    }
-    emitFire(f, pv, def, dt) {
-      const bb = this.box;
-      bb.makeEmpty();
-      const tmp = new this.THREE.Box3();
-      for (const mv of pv.meshes) if (mv.mesh.visible) bb.union(tmp.setFromObject(mv.mesh));
-      let cx = f.point[0];
-      let cy = f.point[1];
-      let cz = f.point[2];
-      let sx = 0.2;
-      let sy = 0.2;
-      let sz = 0.2;
-      if (!bb.isEmpty()) {
-        const c = bb.getCenter(this.v1);
-        const s = bb.getSize(this.v2);
-        cx = c.x;
-        cy = bb.min.y;
-        cz = c.z;
-        sx = s.x;
-        sy = s.y;
-        sz = s.z;
-      }
-      const vol = clamp(Math.cbrt(Math.max(sx * sy * sz, 1e-5)), 0.05, 1.5);
-      f.accFire += (18 + 70 * vol) * dt;
-      f.accSmoke += (6 + 24 * vol) * dt;
-      const tone = SMOKE_TONES[def?.thermal.smoke ?? "grey"];
-      const rnd = this.rng;
-      while (f.accFire >= 1) {
-        f.accFire -= 1;
-        this.particles.spawn("fire", [cx + (rnd() - 0.5) * sx, cy + sy * (0.3 + 0.7 * rnd()), cz + (rnd() - 0.5) * sz], [(rnd() - 0.5) * 0.4, 0.5 + rnd() * 0.9, (rnd() - 0.5) * 0.4], { size: 0.6 + vol * 0.8 });
-      }
-      while (f.accSmoke >= 1) {
-        f.accSmoke -= 1;
-        this.particles.spawn("smoke", [cx + (rnd() - 0.5) * sx, cy + sy * (0.8 + 0.4 * rnd()), cz + (rnd() - 0.5) * sz], [(rnd() - 0.5) * 0.3 + 0.1, 0.4 + rnd() * 0.5, (rnd() - 0.5) * 0.3], { color: tone, size: 0.6 + vol });
-      }
-    }
-    updateLeaks(dt) {
-      for (let i = this.leaks.length - 1; i >= 0; i--) {
-        const l = this.leaks[i];
-        const ps = this.world.part(l.object, l.part);
-        if (!ps || ps.liters === void 0 || ps.liters <= 0) {
-          this.leaks.splice(i, 1);
-          continue;
-        }
-        l.acc += clamp(20 + l.rate * 400, 15, 120) * dt;
-        const color = FLUID_COLORS[l.fluid] ?? 11184810;
-        const d = l.direction;
-        const dl = Math.hypot(d[0], d[1], d[2]) || 1;
-        const sp = l.pressurized ? 2.5 + this.rng() * 1.5 : 0.3 + this.rng() * 0.3;
-        while (l.acc >= 1) {
-          l.acc -= 1;
-          const vel = [d[0] / dl * sp + (this.rng() - 0.5) * 0.25, d[1] / dl * sp + (this.rng() - 0.5) * 0.25, d[2] / dl * sp + (this.rng() - 0.5) * 0.25];
-          if (l.fluid === "gas") this.particles.spawn("steam", l.point, vel, { color, size: 0.5, alpha: 0.5 });
-          else this.particles.spawn("drips", l.point, vel, { color, tag: this.rng() < 0.03 ? this.tagOf(l.object) : 0 });
-        }
-      }
-    }
-    tagOf(object) {
-      let tag = this.homeTags.indexOf(object) + 1;
-      if (tag === 0) tag = this.homeTags.push(object);
-      return tag;
-    }
-    // ----------------------------------------------------------------------------------------------------------------------------------
-    // Emit, clear, restore, stats, dispose
-    // ----------------------------------------------------------------------------------------------------------------------------------
-    emit(kind, point, normal, count, speed) {
-      this.particles.burst(kind, point, normal, count, speed ?? DEFAULT_SPEED[kind] ?? 1, kind === "smoke" ? { color: SMOKE_TONES.grey } : void 0);
-    }
-    restore(objectId) {
-      const homes = /* @__PURE__ */ new Set([objectId]);
-      const self = this.bounds.get(objectId);
-      if (self?.isSplit) for (const pv of self.parts.values()) homes.add(pv.home);
-      for (const home of homes) this.restoreHome(home);
-      for (const [key, a] of [...this.active]) if (homes.has(a.object)) this.active.delete(key);
-      for (const [key, f] of [...this.fires]) if (homes.has(f.object)) this.fires.delete(key);
-      for (let i = this.leaks.length - 1; i >= 0; i--) if (homes.has(this.leaks[i].object)) this.leaks.splice(i, 1);
-      for (const home of homes) {
-        this.fragments.removeHome(home);
-        this.ground.removeHome(home);
-      }
-    }
-    restoreHome(home) {
-      const homeBound = this.bounds.get(home);
-      for (const b of [...this.bounds.values()]) {
-        for (const [pid, pv] of [...b.parts]) {
-          if (pv.home !== home) continue;
-          this.visuals.restorePart(pv);
-          if (b !== homeBound && homeBound) {
-            b.parts.delete(pid);
-            homeBound.parts.set(pid, pv);
-          }
-        }
-        if (b.isSplit && b.parts.size === 0) {
-          this.scene.remove(b.root);
-          this.pieceSys.remove(b.id);
-          this.bounds.delete(b.id);
-        }
-      }
-    }
-    clear() {
-      this.queue.length = 0;
-      this.active.clear();
-      this.fires.clear();
-      this.leaks.length = 0;
-      for (const id of [...this.bounds.keys()]) if (this.bounds.has(id)) this.restore(id);
-      for (const b of [...this.bounds.values()]) {
-        if (b.isSplit) {
-          for (const pv of b.parts.values()) this.visuals.restorePart(pv);
-          this.scene.remove(b.root);
-          this.pieceSys.remove(b.id);
-          this.bounds.delete(b.id);
-        }
-      }
-      this.fragments.clear();
-      this.ground.clear();
-      this.particles.clear();
-      if (this.light) {
-        this.light.intensity = 0;
-        this.lightT = 0;
-        this.scene.remove(this.light);
-      }
-    }
-    stats() {
-      return { fragments: this.fragments.count, particles: this.particles.live, pieces: this.pieceSys.list.length, decals: this.visuals.decalCount + this.ground.count };
-    }
-    dispose() {
-      if (this.disposed) return;
-      this.unsubscribe();
-      this.clear();
-      for (const id of [...this.bounds.keys()]) this.unbind(id);
-      this.fragments.dispose();
-      this.ground.dispose();
-      this.particles.dispose();
-      this.visuals.dispose();
-      this.light?.dispose?.();
-      this.light = null;
-      this.disposed = true;
-    }
-  };
-
-  // ../game-destruction/dist/index.js
-  var EPS = 1e-9;
-  var IDENTITY = [0, 0, 0, 1];
-  var quat = {
-    identity: () => [IDENTITY[0], IDENTITY[1], IDENTITY[2], IDENTITY[3]],
-    /** Hamilton product `a * b` (apply `b` first, then `a`). */
-    mul: (a, b) => [
-      a[3] * b[0] + a[0] * b[3] + a[1] * b[2] - a[2] * b[1],
-      a[3] * b[1] - a[0] * b[2] + a[1] * b[3] + a[2] * b[0],
-      a[3] * b[2] + a[0] * b[1] - a[1] * b[0] + a[2] * b[3],
-      a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2]
-    ],
-    conjugate: (q) => [-q[0], -q[1], -q[2], q[3]],
-    normalize: (q) => {
-      const l = Math.hypot(q[0], q[1], q[2], q[3]);
-      return l < EPS ? [0, 0, 0, 1] : [q[0] / l, q[1] / l, q[2] / l, q[3] / l];
-    },
-    /** Rotation of `angle` radians around a unit `axis`. */
-    fromAxisAngle: (axis, angle) => {
-      const s = Math.sin(angle / 2);
-      return [axis[0] * s, axis[1] * s, axis[2] * s, Math.cos(angle / 2)];
-    },
-    /** Rotation matrix, row-major 3x3. */
-    toMatrix: (q) => {
-      const [x, y, z, w] = q;
-      const xx = x * x, yy = y * y, zz = z * z, xy = x * y, xz = x * z, yz = y * z, wx = w * x, wy = w * y, wz = w * z;
-      return [1 - 2 * (yy + zz), 2 * (xy - wz), 2 * (xz + wy), 2 * (xy + wz), 1 - 2 * (xx + zz), 2 * (yz - wx), 2 * (xz - wy), 2 * (yz + wx), 1 - 2 * (xx + yy)];
-    },
-    /** Quaternion from three orthonormal columns (the images of the x, y and z axes). */
-    fromColumns: (cx, cy, cz) => {
-      const m00 = cx[0], m10 = cx[1], m20 = cx[2];
-      const m01 = cy[0], m11 = cy[1], m21 = cy[2];
-      const m02 = cz[0], m12 = cz[1], m22 = cz[2];
-      const tr = m00 + m11 + m22;
-      let q;
-      if (tr > 0) {
-        const s = Math.sqrt(tr + 1) * 2;
-        q = [(m21 - m12) / s, (m02 - m20) / s, (m10 - m01) / s, 0.25 * s];
-      } else if (m00 > m11 && m00 > m22) {
-        const s = Math.sqrt(1 + m00 - m11 - m22) * 2;
-        q = [0.25 * s, (m01 + m10) / s, (m02 + m20) / s, (m21 - m12) / s];
-      } else if (m11 > m22) {
-        const s = Math.sqrt(1 + m11 - m00 - m22) * 2;
-        q = [(m01 + m10) / s, 0.25 * s, (m12 + m21) / s, (m02 - m20) / s];
-      } else {
-        const s = Math.sqrt(1 + m22 - m00 - m11) * 2;
-        q = [(m02 + m20) / s, (m12 + m21) / s, 0.25 * s, (m10 - m01) / s];
-      }
-      return quat.normalize(q);
-    }
-  };
-  var quatFromEuler = (x, y, z) => {
-    const c1 = Math.cos(x / 2), c2 = Math.cos(y / 2), c3 = Math.cos(z / 2);
-    const s1 = Math.sin(x / 2), s2 = Math.sin(y / 2), s3 = Math.sin(z / 2);
-    return [s1 * c2 * c3 + c1 * s2 * s3, c1 * s2 * c3 - s1 * c2 * s3, c1 * c2 * s3 + s1 * s2 * c3, c1 * c2 * c3 - s1 * s2 * s3];
-  };
-  var shapeDims = (s) => {
-    if (s.kind === "box") return [s.size[0], s.size[1], s.size[2]];
-    if (s.kind === "cylinder") return [s.radius * 2, s.height, s.radius * 2];
-    return [s.radius * 2, s.radius * 2, s.radius * 2];
-  };
-  var aabbOf = (s, center, q) => {
-    let hx, hy, hz;
-    if (s.kind === "sphere") {
-      hx = hy = hz = s.radius;
-    } else {
-      const m = quat.toMatrix(q);
-      if (s.kind === "box") {
-        const a = s.size[0] / 2, b = s.size[1] / 2, c = s.size[2] / 2;
-        hx = Math.abs(m[0]) * a + Math.abs(m[1]) * b + Math.abs(m[2]) * c;
-        hy = Math.abs(m[3]) * a + Math.abs(m[4]) * b + Math.abs(m[5]) * c;
-        hz = Math.abs(m[6]) * a + Math.abs(m[7]) * b + Math.abs(m[8]) * c;
-      } else {
-        const ax = [m[1], m[4], m[7]];
-        const hh = s.height / 2;
-        const e = (i) => s.radius * Math.sqrt(Math.max(0, 1 - ax[i] * ax[i])) + hh * Math.abs(ax[i]);
-        hx = e(0);
-        hy = e(1);
-        hz = e(2);
-      }
-    }
-    return { min: [center[0] - hx, center[1] - hy, center[2] - hz], max: [center[0] + hx, center[1] + hy, center[2] + hz] };
+    return { min: [center[0] - hx, center[1] - hy, center[2] - hz], max: [center[0] + hx, center[1] + hy, center[2] + hz] };
   };
   var materials_default = [
     {
@@ -3131,7 +1804,7 @@ void main() {
     {
       id: "green_wood",
       density: 650,
-      hpPerKg: 120,
+      hpPerKg: 5,
       penetration: 10,
       ductility: 0.5,
       fracture: "splinter",
@@ -3140,7 +1813,8 @@ void main() {
         0.2
       ],
       damageScale: {
-        slash: 1.3
+        slash: 1.3,
+        ballistic: 0.1
       },
       hitDebris: "splinters",
       breakDebris: "leaves",
@@ -3278,268 +1952,1671 @@ void main() {
       ],
       compressive: 2e4
     }
-  ];
-  var material_hints_default = {
-    "cast iron": "cast_iron",
-    cast_iron: "cast_iron",
-    castiron: "cast_iron",
-    metal: "steel",
-    steel: "steel",
-    iron: "steel",
-    chrome: "steel",
-    alumin: "aluminium",
-    alu_: "aluminium",
-    "alu-": "aluminium",
-    "alu ": "aluminium",
-    copper: "copper",
-    brass: "copper",
-    bronze: "copper",
-    wood: "wood_soft",
-    timber: "wood_soft",
-    plank: "wood_soft",
-    lumber: "wood_soft",
-    pine: "wood_soft",
-    hardwood: "wood_hard",
-    oak: "wood_hard",
-    plywood: "plywood",
-    mdf: "mdf",
-    chipboard: "mdf",
-    glass: "glass",
-    window: "glass",
-    mirror: "glass",
-    tempered: "tempered_glass",
-    windshield: "tempered_glass",
-    fabric: "fabric",
-    cloth: "fabric",
-    cushion: "fabric",
-    sofa: "fabric",
-    curtain: "fabric",
-    carpet: "fabric",
-    textile: "fabric",
-    canvas: "fabric",
-    foam: "foam",
-    sponge: "foam",
-    mattress: "foam",
-    leather: "leather",
-    paper: "paper",
-    cardboard: "paper",
-    leaf: "foliage",
-    leaves: "foliage",
-    foliage: "foliage",
-    bush: "foliage",
-    grass: "foliage",
-    trunk: "green_wood",
-    branch: "green_wood",
-    twig: "green_wood",
-    cactus: "cactus",
-    fruit: "flesh_fruit",
-    apple: "flesh_fruit",
-    melon: "flesh_fruit",
-    wax: "wax",
-    candle: "wax",
-    concrete: "concrete",
-    cement: "concrete",
-    brick: "brick",
-    tile: "ceramic",
-    ceramic: "ceramic",
-    porcelain: "ceramic",
-    stone: "stone",
-    rock: "stone",
-    marble: "stone",
-    plaster: "plaster",
-    drywall: "plaster",
-    gypsum: "plaster",
-    plastic: "plastic",
-    pvc: "plastic",
-    acrylic: "plastic",
-    rubber: "rubber",
-    tire: "rubber",
-    tyre: "rubber",
-    soil: "soil",
-    dirt: "soil",
-    potting: "soil",
-    mud: "soil"
-  };
-  var MATERIALS = materials_default;
-  var has = (m, tag) => !!m.tags && m.tags.includes(tag);
-  var JOINT_BY_MATERIALS = (a, b) => {
-    const any = (tag) => has(a, tag) || has(b, tag);
-    const both = (tag) => has(a, tag) && has(b, tag);
-    if (any("glass")) return any("plastic") ? "clip" : "glue";
-    if (any("fabric")) return "tie";
-    if (both("plant")) return "stem";
-    if (any("plant")) return "tie";
-    if (both("masonry")) return "mortar";
-    if (any("masonry") && any("metal")) return "bolt";
-    if (both("metal")) return "weld";
-    if (any("plastic")) return "clip";
-    if (any("rubber") || any("wax")) return "glue";
-    return "screw";
-  };
-  var MATERIAL_MAP = new Map(MATERIALS.map((m) => [m.id, m]));
-  var HINTS = Object.entries(material_hints_default).sort((x, y) => y[0].length - x[0].length);
-  var guessMaterial = (name) => {
-    const n = name.toLowerCase();
-    for (const [key, id] of HINTS) if (n.includes(key)) return id;
-    return void 0;
-  };
-  var partThickness = (part) => {
-    const dims = shapeDims(part.shape);
-    const min = Math.min(dims[0], dims[1], dims[2]);
-    return Math.max(1e-4, Math.min(part.thickness ?? min * (part.fill ?? 1), min));
-  };
-  var inferJoints = (parts, tolerance = 0.01, materials = MATERIAL_MAP) => {
-    const boxes = parts.map((p) => aabbOf(p.shape, p.position, quatFromEuler(...p.rotation ?? [0, 0, 0])));
-    const out = [];
-    for (let i = 0; i < parts.length; i++) {
-      for (let j = i + 1; j < parts.length; j++) {
-        const a = boxes[i], b = boxes[j];
-        let touch = true;
-        for (let k = 0; k < 3 && touch; k++) if (a.min[k] - tolerance > b.max[k] || b.min[k] - tolerance > a.max[k]) touch = false;
-        if (!touch) continue;
-        const ma = materials.get(parts[i].material);
-        const mb = materials.get(parts[j].material);
-        let kind = ma && mb ? JOINT_BY_MATERIALS(ma, mb) : "screw";
-        const thin = Math.min(partThickness(parts[i]), partThickness(parts[j]));
-        if (kind === "weld" && thin >= 0.02) kind = "bolt";
-        if (kind === "screw" && ma && mb && has(ma, "wood") && has(mb, "wood") && thin < 0.02) kind = "nail";
-        out.push({ id: `${parts[i].id}~${parts[j].id}`, a: parts[i].id, b: parts[j].id, kind });
+  ];
+  var material_hints_default = {
+    "cast iron": "cast_iron",
+    cast_iron: "cast_iron",
+    castiron: "cast_iron",
+    metal: "steel",
+    steel: "steel",
+    iron: "steel",
+    chrome: "steel",
+    alumin: "aluminium",
+    alu_: "aluminium",
+    "alu-": "aluminium",
+    "alu ": "aluminium",
+    copper: "copper",
+    brass: "copper",
+    bronze: "copper",
+    wood: "wood_soft",
+    timber: "wood_soft",
+    plank: "wood_soft",
+    lumber: "wood_soft",
+    pine: "wood_soft",
+    hardwood: "wood_hard",
+    oak: "wood_hard",
+    plywood: "plywood",
+    mdf: "mdf",
+    chipboard: "mdf",
+    glass: "glass",
+    window: "glass",
+    mirror: "glass",
+    tempered: "tempered_glass",
+    windshield: "tempered_glass",
+    fabric: "fabric",
+    cloth: "fabric",
+    cushion: "fabric",
+    sofa: "fabric",
+    curtain: "fabric",
+    carpet: "fabric",
+    textile: "fabric",
+    canvas: "fabric",
+    foam: "foam",
+    sponge: "foam",
+    mattress: "foam",
+    leather: "leather",
+    paper: "paper",
+    cardboard: "paper",
+    leaf: "foliage",
+    leaves: "foliage",
+    foliage: "foliage",
+    bush: "foliage",
+    grass: "foliage",
+    trunk: "green_wood",
+    branch: "green_wood",
+    twig: "green_wood",
+    cactus: "cactus",
+    fruit: "flesh_fruit",
+    apple: "flesh_fruit",
+    melon: "flesh_fruit",
+    wax: "wax",
+    candle: "wax",
+    concrete: "concrete",
+    cement: "concrete",
+    brick: "brick",
+    tile: "ceramic",
+    ceramic: "ceramic",
+    porcelain: "ceramic",
+    stone: "stone",
+    rock: "stone",
+    marble: "stone",
+    plaster: "plaster",
+    drywall: "plaster",
+    gypsum: "plaster",
+    plastic: "plastic",
+    pvc: "plastic",
+    acrylic: "plastic",
+    rubber: "rubber",
+    tire: "rubber",
+    tyre: "rubber",
+    soil: "soil",
+    dirt: "soil",
+    potting: "soil",
+    mud: "soil"
+  };
+  var MATERIALS = materials_default;
+  var has = (m, tag) => !!m.tags && m.tags.includes(tag);
+  var JOINT_BY_MATERIALS = (a, b) => {
+    const any = (tag) => has(a, tag) || has(b, tag);
+    const both = (tag) => has(a, tag) && has(b, tag);
+    if (any("glass")) return any("plastic") ? "clip" : "glue";
+    if (any("fabric")) return "tie";
+    if (both("plant")) return "stem";
+    if (any("plant")) return "tie";
+    if (both("masonry")) return "mortar";
+    if (any("masonry") && any("metal")) return "bolt";
+    if (both("metal")) return "weld";
+    if (any("plastic")) return "clip";
+    if (any("rubber") || any("wax")) return "glue";
+    return "screw";
+  };
+  var MATERIAL_MAP = new Map(MATERIALS.map((m) => [m.id, m]));
+  var HINTS = Object.entries(material_hints_default).sort((x, y) => y[0].length - x[0].length);
+  var guessMaterial = (name) => {
+    const n = name.toLowerCase();
+    for (const [key, id] of HINTS) if (n.includes(key)) return id;
+    return void 0;
+  };
+  var partThickness = (part) => {
+    const dims = shapeDims(part.shape);
+    const min = Math.min(dims[0], dims[1], dims[2]);
+    return Math.max(1e-4, Math.min(part.thickness ?? min * (part.fill ?? 1), min));
+  };
+  var inferJoints = (parts, tolerance = 0.01, materials = MATERIAL_MAP) => {
+    const boxes = parts.map((p) => aabbOf(p.shape, p.position, quatFromEuler(...p.rotation ?? [0, 0, 0])));
+    const out = [];
+    for (let i = 0; i < parts.length; i++) {
+      for (let j = i + 1; j < parts.length; j++) {
+        const a = boxes[i], b = boxes[j];
+        let touch = true;
+        for (let k = 0; k < 3 && touch; k++) if (a.min[k] - tolerance > b.max[k] || b.min[k] - tolerance > a.max[k]) touch = false;
+        if (!touch) continue;
+        const ma = materials.get(parts[i].material);
+        const mb = materials.get(parts[j].material);
+        let kind = ma && mb ? JOINT_BY_MATERIALS(ma, mb) : "screw";
+        const thin = Math.min(partThickness(parts[i]), partThickness(parts[j]));
+        if (kind === "weld" && thin >= 0.02) kind = "bolt";
+        if (kind === "screw" && ma && mb && has(ma, "wood") && has(mb, "wood") && thin < 0.02) kind = "nail";
+        out.push({ id: `${parts[i].id}~${parts[j].id}`, a: parts[i].id, b: parts[j].id, kind });
+      }
+    }
+    return out;
+  };
+
+  // src/spec.ts
+  function partHintOf(value) {
+    if (typeof value === "string") return value ? { id: value } : null;
+    if (!value || typeof value !== "object") return null;
+    const v = value;
+    if (typeof v.id !== "string" || !v.id) return null;
+    const str = (x) => typeof x === "string" && x ? x : void 0;
+    return { id: v.id, material: str(v.material), parent: str(v.parent), kind: str(v.kind) };
+  }
+  var METAL = /steel|iron|metal|alumin|copper|brass|bronze|tin|titan|chrome|zinc|lead/i;
+  function sanitizeId(name) {
+    let id = name.trim().replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    if (id && /^[0-9]/.test(id)) id = `p_${id}`;
+    return id;
+  }
+  function isMesh(o) {
+    return o.isMesh === true;
+  }
+  function sizeOf(box) {
+    return [box.max.x - box.min.x, box.max.y - box.min.y, box.max.z - box.min.z];
+  }
+  function specFromObject3D(THREE, root, options = {}) {
+    const fallback = options.fallback ?? "plastic";
+    const minSize = options.minSize ?? 0.015;
+    root.updateMatrixWorld(true);
+    const inv = root.matrixWorld.clone().invert();
+    const entries = [];
+    const byKey = /* @__PURE__ */ new Map();
+    const visit = (o) => {
+      if (!o.visible || o.userData?.destructionIgnore) return;
+      if (isMesh(o) && o.geometry) {
+        const geom = o.geometry;
+        if (!geom.boundingBox) geom.computeBoundingBox();
+        if (geom.boundingBox && !geom.boundingBox.isEmpty()) {
+          const box = geom.boundingBox.clone().applyMatrix4(new THREE.Matrix4().multiplyMatrices(inv, o.matrixWorld));
+          const mats = Array.isArray(o.material) ? o.material : [o.material];
+          const matName = mats[0]?.name ?? "";
+          const ud = o.userData ?? {};
+          const hint = partHintOf(ud.destructionPart);
+          const material = options.materialOf?.(o) ?? (typeof ud.destructionMaterial === "string" ? ud.destructionMaterial : void 0) ?? hint?.material ?? guessMaterial(`${o.name} ${matName} ${typeof ud.material === "string" ? ud.material : ""}`) ?? fallback;
+          const explicit = hint?.id ?? null;
+          const hollow = ud.hollow === true || /hollow/i.test(o.name);
+          const fill = options.fillOf?.(o, material);
+          const tags = Array.isArray(ud.destructionTags) ? ud.destructionTags : void 0;
+          const existing = explicit ? byKey.get(explicit) : void 0;
+          if (existing) {
+            const before = sizeOf(existing.box);
+            const bv = before[0] * before[1] * before[2];
+            const ns = sizeOf(box);
+            existing.box.union(box);
+            existing.meshes.push(o);
+            if (ns[0] * ns[1] * ns[2] > bv) existing.material = material;
+            existing.hollow = existing.hollow || hollow;
+            if (fill !== void 0) existing.fill = fill;
+          } else {
+            const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box, material, explicitId: explicit, fill, hollow, tags, fixedId: !!explicit, name: o.name, parent: hint?.parent, jointKind: hint?.kind };
+            entries.push(e);
+            if (explicit) byKey.set(explicit, e);
+          }
+        }
+      }
+      for (const c of o.children) visit(c);
+    };
+    visit(root);
+    const eps = 5e-3;
+    const overlapVolume = (a, b) => {
+      const x = Math.min(a.max.x, b.max.x) - Math.max(a.min.x, b.min.x) + eps;
+      const y = Math.min(a.max.y, b.max.y) - Math.max(a.min.y, b.min.y) + eps;
+      const z = Math.min(a.max.z, b.max.z) - Math.max(a.min.z, b.min.z) + eps;
+      return x > 0 && y > 0 && z > 0 ? x * y * z : 0;
+    };
+    const largest = (e) => Math.max(...sizeOf(e.box));
+    const kept = [];
+    const tiny = [];
+    for (const e of entries) (!e.fixedId && largest(e) < minSize ? tiny : kept).push(e);
+    for (const t of tiny) {
+      let best = null;
+      let bestV = 0;
+      for (const k of kept) {
+        const v = overlapVolume(t.box, k.box);
+        if (v > bestV) {
+          bestV = v;
+          best = k;
+        }
+      }
+      if (!best) {
+        let bd = 0.05;
+        for (const k of kept) {
+          const d = k.box.distanceToPoint(t.box.getCenter(new THREE.Vector3()));
+          if (d < bd) {
+            bd = d;
+            best = k;
+          }
+        }
+      }
+      if (best) {
+        best.meshes.push(...t.meshes);
+      } else {
+        kept.push(t);
+      }
+    }
+    const used = /* @__PURE__ */ new Set();
+    const parts = [];
+    const meshesOf = {};
+    let counter = 0;
+    for (const e of kept) {
+      counter++;
+      let base = (e.explicitId ? sanitizeId(e.explicitId) : "") || sanitizeId(e.name) || `part_${counter}`;
+      let id = base;
+      for (let n = 2; used.has(id); n++) id = `${base}_${n}`;
+      used.add(id);
+      base = id;
+      const size = sizeOf(e.box);
+      const center = e.box.getCenter(new THREE.Vector3());
+      const part = {
+        id,
+        material: e.material,
+        shape: { kind: "box", size: [Math.max(size[0], 2e-3), Math.max(size[1], 2e-3), Math.max(size[2], 2e-3)] },
+        position: [center.x, center.y, center.z]
+      };
+      const minSide = Math.min(...size);
+      if (e.fill !== void 0) part.fill = e.fill;
+      else if (e.hollow) part.fill = 0.05;
+      if (minSide < 0.01 && METAL.test(e.material)) {
+        part.fill = e.fill ?? 1;
+        part.thickness = Math.max(minSide, 5e-4);
+      }
+      if (e.tags) part.tags = [...e.tags];
+      const ao = options.anchorBelow ?? -1;
+      if (ao >= 0 && e.box.min.y <= ao) part.anchored = true;
+      parts.push(part);
+      meshesOf[id] = e.meshes;
+    }
+    const spec = { parts };
+    if (options.name !== void 0) spec.name = options.name;
+    else if (root.name) spec.name = root.name;
+    if (options.tags) spec.tags = [...options.tags];
+    spec.joints = options.joints === false ? [] : inferJoints(parts);
+    if (options.joints !== false) {
+      const finalId = /* @__PURE__ */ new Map();
+      kept.forEach((e, i) => finalId.set(e, parts[i].id));
+      const idOf = /* @__PURE__ */ new Map();
+      for (const e of kept) if (e.explicitId) idOf.set(e.explicitId, finalId.get(e));
+      const joints = spec.joints;
+      for (const e of kept) {
+        if (!e.parent) continue;
+        const id = finalId.get(e);
+        const parent = idOf.get(e.parent) ?? (used.has(sanitizeId(e.parent)) ? sanitizeId(e.parent) : null);
+        if (!parent || parent === id) continue;
+        const at = joints.findIndex((j) => j.a === parent && j.b === id || j.a === id && j.b === parent);
+        const kind = e.jointKind ?? (at >= 0 ? joints[at].kind : "resting");
+        const joint = { id: `${parent}~${id}`, a: parent, b: id, kind };
+        if (at >= 0) joints[at] = joint;
+        else joints.push(joint);
+      }
+    }
+    return { spec, parts: meshesOf };
+  }
+
+  // src/heat.ts
+  var STOPS = [
+    [450, 0],
+    [500, 2753536],
+    [650, 9049344],
+    [800, 14174728],
+    [950, 16747540],
+    [1100, 16761402],
+    [1250, 16771232],
+    [1400, 16777215]
+  ];
+  function heatColor(temperatureC) {
+    if (!(temperatureC > STOPS[0][0])) return 0;
+    const last = STOPS[STOPS.length - 1];
+    if (temperatureC >= last[0]) return last[1];
+    for (let i = 1; i < STOPS.length; i++) {
+      const [t1, c1] = STOPS[i];
+      if (temperatureC <= t1) {
+        const [t0, c0] = STOPS[i - 1];
+        return mixHex(c0, c1, (temperatureC - t0) / (t1 - t0));
+      }
+    }
+    return last[1];
+  }
+
+  // src/visual.ts
+  var POS_ATTR = "position";
+  function positionAttr(geo) {
+    const a = geo.getAttribute(POS_ATTR);
+    return a && !a.isInterleavedBufferAttribute ? a : null;
+  }
+  function materialsOf(m) {
+    return Array.isArray(m) ? m : [m];
+  }
+  function colorOf(m) {
+    const c = m.color;
+    return c && c.isColor ? c : null;
+  }
+  var DecalKit = class {
+    constructor(THREE) {
+      __publicField(this, "THREE", THREE);
+      __publicField(this, "disc", null);
+      __publicField(this, "discMat", null);
+      __publicField(this, "lineMats", /* @__PURE__ */ new Map());
+    }
+    discGeometry() {
+      return this.disc ?? (this.disc = new this.THREE.CircleGeometry(1, 14));
+    }
+    discMaterial() {
+      return this.discMat ?? (this.discMat = new this.THREE.MeshBasicMaterial({
+        color: 328965,
+        transparent: true,
+        opacity: 0.92,
+        depthWrite: false,
+        polygonOffset: true,
+        polygonOffsetFactor: -4,
+        polygonOffsetUnits: -4
+      }));
+    }
+    lineMaterial(color) {
+      let m = this.lineMats.get(color);
+      if (!m) {
+        m = new this.THREE.LineBasicMaterial({ color, transparent: true, opacity: 0.9, depthWrite: false });
+        this.lineMats.set(color, m);
+      }
+      return m;
+    }
+    dispose() {
+      this.disc?.dispose();
+      this.discMat?.dispose();
+      for (const m of this.lineMats.values()) m.dispose();
+      this.disc = null;
+      this.discMat = null;
+      this.lineMats.clear();
+    }
+  };
+  var tmpV = (THREE) => new THREE.Vector3();
+  var Visuals = class {
+    constructor(THREE, lowQuality, decalCap) {
+      __publicField(this, "THREE", THREE);
+      __publicField(this, "lowQuality", lowQuality);
+      __publicField(this, "decalCap", decalCap);
+      __publicField(this, "kit");
+      __publicField(this, "a");
+      __publicField(this, "b");
+      __publicField(this, "m4");
+      __publicField(this, "box");
+      /** Total live decals across meshes (kept in sync by add/remove). */
+      __publicField(this, "decalCount", 0);
+      __publicField(this, "tints", /* @__PURE__ */ new WeakMap());
+      this.kit = new DecalKit(THREE);
+      this.a = tmpV(THREE);
+      this.b = tmpV(THREE);
+      this.m4 = new THREE.Matrix4();
+      this.box = new THREE.Box3();
+    }
+    makeMeshVis(mesh, home) {
+      return {
+        mesh,
+        home,
+        origGeometry: mesh.geometry,
+        origMaterial: mesh.material,
+        origVisible: mesh.visible,
+        origParent: mesh.parent,
+        origPosition: mesh.position.clone(),
+        origQuaternion: mesh.quaternion.clone(),
+        origScale: mesh.scale.clone(),
+        ownMat: false,
+        ownGeo: false,
+        work: null,
+        baseColors: null,
+        decals: [],
+        meltApplied: 0,
+        bottomY: 0,
+        moved: false
+      };
+    }
+    vertexCount(mv) {
+      return mv.mesh.geometry.getAttribute(POS_ATTR)?.count ?? 0;
+    }
+    /**
+     * Average vertex colour of a mesh whose material uses `vertexColors` (computed once per mesh, from its original geometry), else null. Fragments
+     * and debris of such a mesh multiply it by `material.color`; without it they come out white.
+     */
+    vertexTint(mv) {
+      if (this.tints.has(mv.mesh)) return this.tints.get(mv.mesh) ?? null;
+      let tint = null;
+      const used = materialsOf(mv.origMaterial).some((m) => m.vertexColors === true);
+      const attr = used ? mv.origGeometry.getAttribute("color") : void 0;
+      if (attr && attr.count > 0 && attr.itemSize >= 3) {
+        let r = 0, g = 0, b = 0;
+        for (let i = 0; i < attr.count; i++) {
+          r += attr.getX(i);
+          g += attr.getY(i);
+          b += attr.getZ(i);
+        }
+        tint = new this.THREE.Color(r / attr.count, g / attr.count, b / attr.count);
+      }
+      this.tints.set(mv.mesh, tint);
+      return tint;
+    }
+    /** Colour of the original material (before any char) times the vertex tint, `0xRRGGBB`, or -1. */
+    baseColorHex(mv) {
+      const c = mv.baseColors?.[0] ?? colorOf(materialsOf(mv.origMaterial)[0]);
+      if (!c) return -1;
+      const tint = this.vertexTint(mv);
+      return tint ? c.clone().multiply(tint).getHex() : c.getHex();
+    }
+    /** Is the original material transparent? */
+    isTransparent(mv) {
+      return materialsOf(mv.origMaterial).some((m) => m.transparent && m.opacity < 1);
+    }
+    ownMaterial(mv) {
+      if (mv.ownMat) return;
+      mv.ownMat = true;
+      const src = materialsOf(mv.origMaterial);
+      const cloned = src.map((m) => m.clone());
+      mv.baseColors = src.map((m) => colorOf(m)?.clone() ?? new this.THREE.Color(8947848));
+      mv.mesh.material = Array.isArray(mv.origMaterial) ? cloned : cloned[0];
+    }
+    /** Clone the geometry (vertex edits); false when its positions cannot be edited. */
+    ownGeometry(mv) {
+      if (mv.ownGeo) return true;
+      const pos = positionAttr(mv.mesh.geometry);
+      if (!pos) return false;
+      mv.ownGeo = true;
+      const g = mv.mesh.geometry.clone();
+      mv.mesh.geometry = g;
+      mv.work = new Float32Array(positionAttr(g).array);
+      return true;
+    }
+    // ------------------------------------------------------------------------------------------------------------------------------------
+    // Dents
+    // ------------------------------------------------------------------------------------------------------------------------------------
+    /**
+     * Push the vertices of the mesh within `dent.radius` of `worldPoint` inwards along `worldNormal` by `depth * (1 - (d/r)^2)^2`.
+     * Returns false when nothing was changed (too far, low quality on a heavy mesh, or no editable positions).
+     */
+    applyDent(mv, worldPoint, worldNormal, dent) {
+      const mesh = mv.mesh;
+      if (this.lowQuality && this.vertexCount(mv) > 2e4) return false;
+      mesh.updateWorldMatrix(true, false);
+      const s = mesh.matrixWorld.getMaxScaleOnAxis() || 1;
+      const lp = mesh.worldToLocal(this.a.copy(worldPoint));
+      const ln = this.b.copy(worldNormal).transformDirection(this.m4.copy(mesh.matrixWorld).invert()).normalize();
+      const r = dent.radius / s;
+      const depth = dent.depth / s;
+      const geo = mesh.geometry;
+      if (!geo.boundingBox) geo.computeBoundingBox();
+      if (geo.boundingBox && geo.boundingBox.distanceToPoint(lp) > r) return false;
+      if (!this.ownGeometry(mv)) return false;
+      const work = mv.work;
+      const pos = positionAttr(mesh.geometry);
+      const r2 = r * r;
+      let touched = false;
+      const px = lp.x;
+      const py = lp.y;
+      const pz = lp.z;
+      const nx = ln.x;
+      const ny = ln.y;
+      const nz = ln.z;
+      for (let i = 0; i < work.length; i += 3) {
+        const dx = work[i] - px;
+        const dy = work[i + 1] - py;
+        const dz = work[i + 2] - pz;
+        const d2 = dx * dx + dy * dy + dz * dz;
+        if (d2 >= r2) continue;
+        const f = 1 - d2 / r2;
+        const k = depth * f * f;
+        work[i] -= nx * k;
+        work[i + 1] -= ny * k;
+        work[i + 2] -= nz * k;
+        touched = true;
+      }
+      if (!touched) return false;
+      this.writePositions(mv, pos);
+      return true;
+    }
+    /** Copy `work` (dents) into the geometry, adding the melt sag when the mesh is melting. */
+    writePositions(mv, pos) {
+      const work = mv.work;
+      const arr = pos.array;
+      const melt = mv.meltApplied;
+      if (melt <= 0 || this.lowQuality && work.length / 3 > 2e4) {
+        arr.set(work);
+      } else {
+        const geo2 = mv.mesh.geometry;
+        if (!geo2.boundingBox) geo2.computeBoundingBox();
+        const bb = geo2.boundingBox;
+        const h = Math.max(1e-4, bb.max.y - bb.min.y);
+        const minY = bb.min.y;
+        for (let i = 0, v = 0; i < work.length; i += 3, v++) {
+          const n = (Math.imul(v + 1, 2654435761) >>> 0) % 1e3 / 1e3;
+          const n2 = (Math.imul(v + 7, 40503) >>> 0) % 1e3 / 1e3;
+          const lowness = 1 - (work[i + 1] - minY) / h;
+          const spread = 1 + 0.12 * melt * (0.4 + n2) * (0.3 + lowness);
+          arr[i] = work[i] * spread;
+          arr[i + 2] = work[i + 2] * spread;
+          arr[i + 1] = Math.max(minY, work[i + 1] - n * melt * h * 0.08);
+        }
+      }
+      pos.needsUpdate = true;
+      const geo = mv.mesh.geometry;
+      geo.computeVertexNormals();
+      geo.boundingBox = null;
+      geo.boundingSphere = null;
+    }
+    // ------------------------------------------------------------------------------------------------------------------------------------
+    // Decals
+    // ------------------------------------------------------------------------------------------------------------------------------------
+    /** Decal pose in mesh space: position and a rotation taking +Z to the surface normal. */
+    decalPose(mesh, worldPoint, worldNormal, lift) {
+      mesh.updateWorldMatrix(true, false);
+      const s = mesh.matrixWorld.getMaxScaleOnAxis() || 1;
+      const ln = worldNormal.clone().transformDirection(this.m4.copy(mesh.matrixWorld).invert()).normalize();
+      const pos = mesh.worldToLocal(worldPoint.clone()).addScaledVector(ln, lift / s);
+      const quat2 = new this.THREE.Quaternion().setFromUnitVectors(new this.THREE.Vector3(0, 0, 1), ln);
+      return { s, pos, quat: quat2 };
+    }
+    addDecal(mv, decal) {
+      mv.mesh.add(decal.obj);
+      mv.decals.push(decal);
+      this.decalCount++;
+      while (mv.decals.length > 48 || this.decalCount > this.decalCap) {
+        const old = mv.decals.shift();
+        if (!old) break;
+        this.disposeDecal(old);
+      }
+    }
+    disposeDecal(d) {
+      d.obj.parent?.remove(d.obj);
+      d.geometry?.dispose();
+      this.decalCount = Math.max(0, this.decalCount - 1);
+    }
+    addHole(mv, worldPoint, worldNormal, diameter) {
+      const { s, pos, quat: quat2 } = this.decalPose(mv.mesh, worldPoint, worldNormal, 25e-4);
+      const disc = new this.THREE.Mesh(this.kit.discGeometry(), this.kit.discMaterial());
+      disc.position.copy(pos);
+      disc.quaternion.copy(quat2);
+      disc.scale.setScalar(Math.max(4e-3, diameter) * 0.5 * 1.25 / s);
+      disc.renderOrder = 2;
+      this.addDecal(mv, { obj: disc });
+    }
+    /** A star of jagged lines: `rays` rays up to `length` metres, seeded so the same event always draws the same star. */
+    addCrack(mv, worldPoint, worldNormal, rays, length, color, seed) {
+      const { s, pos, quat: quat2 } = this.decalPose(mv.mesh, worldPoint, worldNormal, 2e-3);
+      const rnd = createRng(seed);
+      const verts = [];
+      const n = clamp(Math.round(rays), 3, 16);
+      const L = Math.max(0.02, length) / s;
+      for (let r = 0; r < n; r++) {
+        let ang = r / n * Math.PI * 2 + (rnd() - 0.5) * 0.5;
+        let x = 0;
+        let y = 0;
+        const segs = 3;
+        const total = L * (0.6 + 0.4 * rnd());
+        for (let k = 0; k < segs; k++) {
+          const step = total / segs * (0.7 + 0.6 * rnd());
+          ang += (rnd() - 0.5) * 0.45;
+          const nx = x + Math.cos(ang) * step;
+          const ny = y + Math.sin(ang) * step;
+          verts.push(x, y, 0, nx, ny, 0);
+          if (k > 0 && rnd() < 0.5) {
+            const ba = ang + (rnd() < 0.5 ? -1 : 1) * (0.5 + rnd() * 0.5);
+            const bl = step * (0.6 + 0.6 * rnd());
+            verts.push(nx, ny, 0, nx + Math.cos(ba) * bl, ny + Math.sin(ba) * bl, 0);
+          }
+          x = nx;
+          y = ny;
+        }
+      }
+      const ringR = L * 0.12;
+      for (let k = 0; k < 8; k++) {
+        const a0 = k / 8 * Math.PI * 2;
+        const a1 = (k + 1) / 8 * Math.PI * 2;
+        if (rnd() < 0.75) verts.push(Math.cos(a0) * ringR, Math.sin(a0) * ringR, 0, Math.cos(a1) * ringR, Math.sin(a1) * ringR, 0);
+      }
+      const geo = new this.THREE.BufferGeometry();
+      geo.setAttribute("position", new this.THREE.Float32BufferAttribute(verts, 3));
+      const lines = new this.THREE.LineSegments(geo, this.kit.lineMaterial(color));
+      lines.position.copy(pos);
+      lines.quaternion.copy(quat2);
+      lines.renderOrder = 2;
+      this.addDecal(mv, { obj: lines, geometry: geo });
+    }
+    // ------------------------------------------------------------------------------------------------------------------------------------
+    // Char and heat glow
+    // ------------------------------------------------------------------------------------------------------------------------------------
+    setChar(pv, char, charColor) {
+      if (Math.abs(char - pv.charApplied) < 4e-3) return;
+      pv.charApplied = char;
+      const target = new this.THREE.Color(charColor);
+      for (const mv of pv.meshes) {
+        this.ownMaterial(mv);
+        const mats = materialsOf(mv.mesh.material);
+        mats.forEach((m, i) => {
+          const c = colorOf(m);
+          const base = mv.baseColors?.[i];
+          if (c && base) c.copy(base).lerp(target, clamp(char, 0, 1));
+        });
+      }
+    }
+    /** Emissive glow of a hot part. `temperature` below the glow threshold switches it off. */
+    setGlow(pv, temperatureC) {
+      const hex = heatColor(temperatureC);
+      const key = hex === 0 ? 0 : Math.round(temperatureC / 5) * 5;
+      if (key === pv.glowApplied) return;
+      pv.glowApplied = key;
+      const intensity = hex === 0 ? 0 : clamp(0.35 + (temperatureC - 450) / 900, 0, 1.4);
+      for (const mv of pv.meshes) {
+        this.ownMaterial(mv);
+        for (const m of materialsOf(mv.mesh.material)) {
+          const e = m.emissive;
+          if (e && e.isColor) {
+            e.setHex(hex);
+            m.emissiveIntensity = intensity;
+          }
+        }
+      }
+    }
+    // ------------------------------------------------------------------------------------------------------------------------------------
+    // Melt
+    // ------------------------------------------------------------------------------------------------------------------------------------
+    /** Sag the part: shorter in Y (down to 25 %), a bit wider, vertices pushed down with noise, the bottom stays put. */
+    setMelt(pv, melt) {
+      const m = clamp(melt, 0, 1);
+      if (Math.abs(m - pv.meltApplied) < 0.01) return;
+      pv.meltApplied = m;
+      for (const mv of pv.meshes) {
+        const mesh = mv.mesh;
+        if (mv.meltApplied === 0 && m > 0) {
+          mesh.updateWorldMatrix(true, false);
+          mv.bottomY = this.box.setFromObject(mesh).min.y;
+        }
+        mv.meltApplied = m;
+        mv.moved = true;
+        const sy = lerp(1, 0.25, m);
+        const sxz = 1 + 0.18 * m;
+        mesh.scale.set(mv.origScale.x * sxz, mv.origScale.y * sy, mv.origScale.z * sxz);
+        mesh.position.copy(mv.origPosition);
+        mesh.updateWorldMatrix(true, false);
+        const bottom = this.box.setFromObject(mesh).min.y;
+        const dy = mv.bottomY - bottom;
+        if (Math.abs(dy) > 1e-6 && mesh.parent) {
+          mesh.parent.updateWorldMatrix(true, false);
+          const inv = this.m4.copy(mesh.parent.matrixWorld).invert();
+          this.a.set(0, dy, 0).applyMatrix4(inv);
+          this.b.set(0, 0, 0).applyMatrix4(inv);
+          mesh.position.copy(mv.origPosition).add(this.a.sub(this.b));
+        }
+        if (!(this.lowQuality && this.vertexCount(mv) > 2e4) && this.ownGeometry(mv)) {
+          this.writePositions(mv, positionAttr(mesh.geometry));
+        }
+      }
+    }
+    // ------------------------------------------------------------------------------------------------------------------------------------
+    // Visibility and restore
+    // ------------------------------------------------------------------------------------------------------------------------------------
+    hide(pv, reason) {
+      pv.gone = reason;
+      for (const mv of pv.meshes) mv.mesh.visible = false;
+    }
+    /** Bring one mesh back to how it was when it was bound. */
+    restoreMesh(mv) {
+      const mesh = mv.mesh;
+      for (const d of mv.decals) this.disposeDecal(d);
+      mv.decals.length = 0;
+      if (mv.ownGeo) {
+        mesh.geometry.dispose();
+        mesh.geometry = mv.origGeometry;
+        mv.ownGeo = false;
+        mv.work = null;
+      }
+      if (mv.ownMat) {
+        for (const m of materialsOf(mesh.material)) m.dispose();
+        mesh.material = mv.origMaterial;
+        mv.ownMat = false;
+        mv.baseColors = null;
+      }
+      mesh.visible = mv.origVisible;
+      if (mv.origParent && mesh.parent !== mv.origParent) {
+        mv.origParent.add(mesh);
+        mv.moved = true;
+      }
+      if (mv.moved) {
+        mesh.position.copy(mv.origPosition);
+        mesh.quaternion.copy(mv.origQuaternion);
+        mesh.scale.copy(mv.origScale);
+        mv.moved = false;
+      }
+      mv.meltApplied = 0;
+    }
+    restorePart(pv) {
+      for (const mv of pv.meshes) this.restoreMesh(mv);
+      pv.charApplied = 0;
+      pv.glowApplied = 0;
+      pv.meltApplied = 0;
+      pv.gone = "none";
+    }
+    dispose() {
+      this.kit.dispose();
+    }
+  };
+
+  // src/renderer.ts
+  var GLOW_FROM_C = 430;
+  var QUEUE_CAP = 4e3;
+  var FLUID_COLORS = {
+    water: 9226495,
+    fuel: 14262322,
+    oil: 2760728,
+    gas: 15921906,
+    sap: 12098362,
+    acid: 10211900,
+    blood: 9046538
+  };
+  var SMOKE_TONES = { white: 15132390, grey: 9079434, black: 2763306 };
+  var DEFAULT_SPEED = {
+    sparks: 3,
+    splinters: 2.5,
+    dust: 1,
+    shards: 2.5,
+    fibers: 1.2,
+    leaves: 1.2,
+    drips: 0.5,
+    ash: 0.8,
+    chips: 2.5,
+    smoke: 0.8,
+    steam: 1,
+    fire: 1.2,
+    flash: 0,
+    foam: 2.5
+  };
+  function impactKey(def) {
+    if (!def) return "impact_wood";
+    const tags = def.tags ?? [];
+    if (tags.includes("metal")) return "impact_metal";
+    if (def.visual?.transparent || def.fracture === "shatter") return "impact_glass";
+    if (def.fracture === "crumble") return "impact_masonry";
+    if (def.fracture === "tear") return "impact_soft";
+    return def.fracture === "none" ? "impact_metal" : "impact_wood";
+  }
+  function fractureKey(def, style) {
+    switch (style) {
+      case "shatter":
+        return "shatter_glass";
+      case "crumble":
+        return "crumble";
+      case "splinter":
+        return "splinter";
+      default:
+        return impactKey(def);
+    }
+  }
+  function fallbackColor(id, def) {
+    if (def?.tags?.includes("metal")) return 9080726;
+    if (def?.visual?.transparent) return 10473696;
+    const h = hashString(id);
+    return mixHex(7035464, 10130568, h % 100 / 100);
+  }
+  function materialsOf2(m) {
+    return Array.isArray(m) ? m : [m];
+  }
+  function createDestructionRenderer(THREE, options) {
+    return new Renderer(THREE, options);
+  }
+  var Renderer = class {
+    constructor(THREE, o) {
+      __publicField(this, "THREE", THREE);
+      __publicField(this, "o", o);
+      __publicField(this, "world");
+      __publicField(this, "scene");
+      __publicField(this, "quality");
+      __publicField(this, "low");
+      __publicField(this, "groundAt");
+      __publicField(this, "gravity");
+      __publicField(this, "autoSplit");
+      __publicField(this, "maxFragments");
+      __publicField(this, "bounds", /* @__PURE__ */ new Map());
+      __publicField(this, "queue", []);
+      __publicField(this, "unsubscribe");
+      __publicField(this, "visuals");
+      __publicField(this, "particles");
+      __publicField(this, "fragments");
+      __publicField(this, "ground");
+      __publicField(this, "pieceSys");
+      __publicField(this, "active", /* @__PURE__ */ new Map());
+      __publicField(this, "fires", /* @__PURE__ */ new Map());
+      __publicField(this, "leaks", []);
+      __publicField(this, "homeTags", []);
+      __publicField(this, "throttles", /* @__PURE__ */ new Map());
+      __publicField(this, "rng", createRng(12648430));
+      __publicField(this, "light", null);
+      __publicField(this, "lightT", 0);
+      __publicField(this, "lightDur", 0.3);
+      __publicField(this, "lightPeak", 0);
+      __publicField(this, "time", 0);
+      __publicField(this, "scanTimer", 0);
+      __publicField(this, "disposed", false);
+      __publicField(this, "box");
+      __publicField(this, "tmpQ");
+      __publicField(this, "v1");
+      __publicField(this, "v2");
+      this.world = o.world;
+      this.scene = o.scene;
+      this.quality = o.quality ?? "medium";
+      this.low = this.quality === "low";
+      this.groundAt = o.groundAt ?? (() => 0);
+      this.gravity = o.gravity ?? 9.81;
+      this.autoSplit = o.autoSplit !== false;
+      this.maxFragments = o.maxFragments ?? 160;
+      this.box = new THREE.Box3();
+      this.tmpQ = new THREE.Quaternion();
+      this.v1 = new THREE.Vector3();
+      this.v2 = new THREE.Vector3();
+      const maxParticles = Math.max(8, Math.floor((o.maxParticles ?? 2500) * (this.low ? 0.5 : 1)));
+      this.visuals = new Visuals(THREE, this.low, 600);
+      this.ground = new GroundSpots(THREE, o.scene, this.groundAt, 48);
+      this.particles = new ParticleSystem(THREE, {
+        capacity: maxParticles,
+        scene: o.scene,
+        density: this.low ? 0.6 : 1,
+        pointScale: o.pointScale ?? 700,
+        groundAt: this.groundAt,
+        gravity: this.gravity,
+        onLand: (x, _y, z, color, tag) => {
+          const home = this.homeTags[tag - 1] ?? "";
+          this.ground.add("puddle", x, z, 0.05 + this.rng() * 0.04, color, home);
+        }
+      });
+      this.fragments = new FragmentSystem(THREE, {
+        scene: o.scene,
+        groundAt: this.groundAt,
+        gravity: this.gravity,
+        max: this.maxFragments,
+        life: o.fragmentLife ?? 12
+      });
+      this.pieceSys = new PieceSystem(THREE, {
+        groundAt: this.groundAt,
+        gravity: this.gravity,
+        scene: o.scene,
+        onHardLanding: (p, point, speed) => this.hardLanding(p, point, speed)
+      });
+      this.unsubscribe = this.world.on("*", (ev) => {
+        if (this.queue.length < QUEUE_CAP) this.queue.push(ev);
+      });
+    }
+    // ----------------------------------------------------------------------------------------------------------------------------------
+    // Binding
+    // ----------------------------------------------------------------------------------------------------------------------------------
+    bind(objectId, root, options = {}) {
+      if (this.bounds.has(objectId)) this.unbind(objectId);
+      const state = this.world.state(objectId);
+      const partIds = new Set((state?.parts ?? []).map((p) => p.id));
+      const byPart = /* @__PURE__ */ new Map();
+      const taken = /* @__PURE__ */ new Set();
+      const add = (pid, m) => {
+        if (taken.has(m)) return;
+        taken.add(m);
+        const l = byPart.get(pid);
+        if (l) l.push(m);
+        else byPart.set(pid, [m]);
+      };
+      const meshesIn = (o) => {
+        const out = [];
+        o.traverse((c) => {
+          if (c.isMesh) out.push(c);
+        });
+        return out;
+      };
+      if (options.parts) {
+        for (const [pid, v] of Object.entries(options.parts)) {
+          for (const o of Array.isArray(v) ? v : [v]) for (const m of meshesIn(o)) add(pid, m);
+        }
+      } else {
+        const leftovers = [];
+        for (const m of meshesIn(root)) {
+          const ud = partHintOf(m.userData?.destructionPart)?.id;
+          if (ud !== void 0 && partIds.has(ud)) add(ud, m);
+          else if (partIds.has(m.name)) add(m.name, m);
+          else leftovers.push(m);
+        }
+        if (leftovers.length) this.matchByBox(objectId, root, leftovers, add);
+      }
+      const bound = { id: objectId, root, sync: options.syncTransform !== false, parts: /* @__PURE__ */ new Map(), lastPos: null, lastQuat: null, piece: null, isSplit: false };
+      for (const pid of partIds) bound.parts.set(pid, this.makePartVis(objectId, pid, state?.parts.find((p) => p.id === pid)?.material ?? "", byPart.get(pid) ?? []));
+      for (const [pid, meshes] of byPart) {
+        if (!bound.parts.has(pid)) bound.parts.set(pid, this.makePartVis(objectId, pid, this.world.part(objectId, pid)?.material ?? "", meshes));
+      }
+      this.bounds.set(objectId, bound);
+    }
+    makePartVis(home, id, material, meshes) {
+      return { id, home, material, meshes: meshes.map((m) => this.visuals.makeMeshVis(m, home)), charApplied: 0, glowApplied: 0, meltApplied: 0, gone: "none" };
+    }
+    /** Match unlabelled meshes to the part whose shape contains the centre of the mesh's bounding box. */
+    matchByBox(objectId, root, meshes, add) {
+      let specParts;
+      try {
+        specParts = this.world.serialize?.().objects.find((o) => o.id === objectId)?.spec.parts;
+      } catch {
+        specParts = void 0;
+      }
+      if (!specParts) return;
+      root.updateMatrixWorld(true);
+      const e = new this.THREE.Euler();
+      const q = new this.THREE.Quaternion();
+      for (const m of meshes) {
+        this.box.setFromObject(m);
+        if (this.box.isEmpty()) continue;
+        const c = root.worldToLocal(this.box.getCenter(this.v1));
+        let best = null;
+        let bestVol = Infinity;
+        for (const p of specParts) {
+          const l = this.v2.set(c.x - p.position[0], c.y - p.position[1], c.z - p.position[2]);
+          if (p.rotation) l.applyQuaternion(q.setFromEuler(e.set(p.rotation[0], p.rotation[1], p.rotation[2], "XYZ")).invert());
+          let inside = false;
+          let vol = 0;
+          const s = p.shape;
+          if (s.kind === "box") {
+            inside = Math.abs(l.x) <= s.size[0] / 2 && Math.abs(l.y) <= s.size[1] / 2 && Math.abs(l.z) <= s.size[2] / 2;
+            vol = s.size[0] * s.size[1] * s.size[2];
+          } else if (s.kind === "cylinder") {
+            inside = Math.hypot(l.x, l.z) <= s.radius && Math.abs(l.y) <= s.height / 2;
+            vol = Math.PI * s.radius * s.radius * s.height;
+          } else {
+            inside = l.length() <= s.radius;
+            vol = 4 / 3 * Math.PI * s.radius ** 3;
+          }
+          if (inside && vol < bestVol) {
+            best = p;
+            bestVol = vol;
+          }
+        }
+        if (best) add(best.id, m);
+      }
+    }
+    unbind(objectId) {
+      const b = this.bounds.get(objectId);
+      if (!b) return;
+      this.restore(objectId);
+      this.pieceSys.remove(objectId);
+      this.bounds.delete(objectId);
+    }
+    // ----------------------------------------------------------------------------------------------------------------------------------
+    // Pieces
+    // ----------------------------------------------------------------------------------------------------------------------------------
+    /** Half extents and centre of the box around some meshes, in the local space of `root`. */
+    measure(root, meshes) {
+      root.updateMatrixWorld(true);
+      const inv = root.matrixWorld.clone().invert();
+      const total = new this.THREE.Box3();
+      const m4 = new this.THREE.Matrix4();
+      for (const m of meshes) {
+        const g = m.geometry;
+        if (!g.boundingBox) g.computeBoundingBox();
+        if (!g.boundingBox || g.boundingBox.isEmpty()) continue;
+        total.union(g.boundingBox.clone().applyMatrix4(m4.multiplyMatrices(inv, m.matrixWorld)));
+      }
+      if (total.isEmpty()) return { half: [0.25, 0.25, 0.25], center: new this.THREE.Vector3() };
+      const size = total.getSize(new this.THREE.Vector3());
+      return { half: [Math.max(0.02, size.x / 2), Math.max(0.02, size.y / 2), Math.max(0.02, size.z / 2)], center: total.getCenter(new this.THREE.Vector3()) };
+    }
+    meshesOf(b) {
+      const out = [];
+      for (const pv of b.parts.values()) if (pv.gone === "none") for (const mv of pv.meshes) out.push(mv.mesh);
+      return out;
+    }
+    massOf(objectId) {
+      const st = this.world.state(objectId);
+      if (!st) return 5;
+      let m = 0;
+      for (const p of st.parts) if (p.status !== "broken" && p.status !== "melted" && p.status !== "ashes") m += p.mass;
+      return m > 0 ? m : 5;
+    }
+    makePiece(objectId, options = {}) {
+      const b = this.bounds.get(objectId);
+      if (!b) throw new Error(`game-destruction-three: object "${objectId}" is not bound`);
+      if (b.root.parent && b.root.parent !== this.scene) this.scene.attach(b.root);
+      const { half, center } = this.measure(b.root, this.meshesOf(b));
+      const piece = this.pieceSys.create(objectId, b.root, half, center, options.mass ?? this.massOf(objectId), options.velocity);
+      b.piece = piece;
+      return piece;
+    }
+    pieces() {
+      return [...this.pieceSys.list];
+    }
+    piece(objectId) {
+      return this.pieceSys.get(objectId);
+    }
+    impulse(objectId, impulse, point) {
+      const p = this.pieceSys.get(objectId);
+      if (p) this.pieceSys.impulse(p, impulse, point);
+    }
+    hardLanding(p, point, speed) {
+      const key = this.impactSoundOf(p.objectId);
+      this.sound(key, point, clamp(speed / 10, 0.2, 1));
+      this.syncBound(p.objectId);
+      try {
+        this.world.hit(p.objectId, { type: "blunt", point, energy: 0.5 * p.mass * speed * speed, radius: 0.08, direction: [0, -1, 0], source: "fall" });
+      } catch {
+      }
+    }
+    impactSoundOf(objectId) {
+      const st = this.world.state(objectId);
+      let best;
+      let mass = -1;
+      for (const p of st?.parts ?? []) {
+        if (p.mass > mass) {
+          mass = p.mass;
+          best = this.world.materials.get(p.material);
+        }
+      }
+      return impactKey(best);
+    }
+    // ----------------------------------------------------------------------------------------------------------------------------------
+    // Update
+    // ----------------------------------------------------------------------------------------------------------------------------------
+    update(dt) {
+      if (this.disposed) return;
+      dt = clamp(dt, 0, 0.1);
+      this.time += dt;
+      this.drainQueue();
+      this.updateActive(dt);
+      this.updateLeaks(dt);
+      this.pieceSys.update(dt);
+      this.fragments.update(dt);
+      this.ground.update(dt);
+      this.updateLight(dt);
+      this.particles.update(dt);
+      this.syncTransforms();
+    }
+    drainQueue() {
+      const batch = this.queue.splice(0, this.queue.length);
+      for (const ev of batch) {
+        try {
+          this.apply(ev);
+        } catch (err) {
+          if (typeof console !== "undefined") console.error("game-destruction-three: failed to apply", ev.type, err);
+        }
+      }
+    }
+    syncTransforms() {
+      for (const b of this.bounds.values()) this.syncOne(b);
+    }
+    /** Push the current transform of one bound object to the world right now (used before a landing hit). */
+    syncBound(objectId) {
+      const b = this.bounds.get(objectId);
+      if (b) this.syncOne(b);
+    }
+    syncOne(b) {
+      if (!b.sync) return;
+      const p = this.v1;
+      const q = this.tmpQ;
+      b.root.updateWorldMatrix(true, false);
+      b.root.matrixWorld.decompose(p, q, this.v2);
+      const last = b.lastPos;
+      const lq = b.lastQuat;
+      const moved = !last || !lq || Math.abs(p.x - last[0]) + Math.abs(p.y - last[1]) + Math.abs(p.z - last[2]) > 1e-5 || Math.abs(q.x - lq[0]) + Math.abs(q.y - lq[1]) + Math.abs(q.z - lq[2]) + Math.abs(q.w - lq[3]) > 1e-6;
+      if (!moved) return;
+      b.lastPos = [p.x, p.y, p.z];
+      b.lastQuat = [q.x, q.y, q.z, q.w];
+      if (this.world.has(b.id)) this.world.setTransform(b.id, [p.x, p.y, p.z], [q.x, q.y, q.z, q.w]);
+    }
+    // ----------------------------------------------------------------------------------------------------------------------------------
+    // Events
+    // ----------------------------------------------------------------------------------------------------------------------------------
+    apply(ev) {
+      switch (ev.type) {
+        case "damage":
+          if (ev.damageType === "heat" || ev.damageType === "fire" || ev.damageType === "explosive") this.activate(ev.object, ev.part);
+          break;
+        case "dent":
+          this.onDent(ev);
+          break;
+        case "hole":
+          this.onHole(ev);
+          break;
+        case "crack":
+          this.onCrack(ev);
+          break;
+        case "ricochet": {
+          const d = ev.direction;
+          this.particles.burst("sparks", ev.point, d, 4 + Math.min(10, ev.energy / 150), 4);
+          this.sound("ricochet", ev.point, 0.7);
+          break;
+        }
+        case "debris":
+          this.particles.burst(ev.kind, ev.point, ev.normal, ev.count, ev.speed > 0 ? ev.speed : DEFAULT_SPEED[ev.kind] ?? 1, this.debrisOptions(ev.kind, ev.object, ev.part));
+          break;
+        case "fracture":
+          this.onFracture(ev);
+          break;
+        case "detach":
+          this.onDetach(ev);
+          break;
+        case "disassemble_progress": {
+          const k = `unscrew:${ev.joint}`;
+          if (this.time - (this.throttles.get(k) ?? -1) > 0.25) {
+            this.throttles.set(k, this.time);
+            this.sound("unscrew", this.rootPoint(ev.object), clamp(0.3 + ev.progress * 0.5, 0, 1));
+          }
+          break;
+        }
+        case "ignite":
+          this.fires.set(`${ev.object}|${ev.part}`, { object: ev.object, part: ev.part, point: ev.point, accFire: 0, accSmoke: 0 });
+          this.activate(ev.object, ev.part);
+          this.particles.burst("fire", ev.point, [0, 1, 0], 6, 1);
+          this.sound("ignite", ev.point, 0.7);
+          this.sound("burn_loop", ev.point, 0.5);
+          break;
+        case "extinguish": {
+          const f = this.fires.get(`${ev.object}|${ev.part}`);
+          if (f) {
+            this.fires.delete(`${ev.object}|${ev.part}`);
+            this.particles.burst("steam", f.point, [0, 1, 0], 14, 1.2);
+          }
+          this.activate(ev.object, ev.part);
+          this.sound("extinguish", f?.point ?? this.rootPoint(ev.object), 0.6);
+          break;
+        }
+        case "burnout": {
+          this.fires.delete(`${ev.object}|${ev.part}`);
+          this.particles.burst("ash", ev.point, [0, 1, 0], 16, 1);
+          this.particles.burst("smoke", ev.point, [0, 1, 0], 6, 0.8, { color: SMOKE_TONES.grey });
+          const pv = this.partVis(ev.object, ev.part);
+          if (pv) {
+            const def = this.world.materials.get(pv.material);
+            this.visuals.setChar(pv, 1, def?.visual?.charColor ?? 1709072);
+          }
+          this.activate(ev.object, ev.part);
+          break;
+        }
+        case "melt":
+          this.activate(ev.object, ev.part);
+          if (this.time - (this.throttles.get(`melt:${ev.object}|${ev.part}`) ?? -9) > 1.5) {
+            this.throttles.set(`melt:${ev.object}|${ev.part}`, this.time);
+            this.sound("melt_sizzle", this.rootPoint(ev.object), 0.4);
+          }
+          break;
+        case "drip": {
+          const b = this.bounds.get(ev.object);
+          const pv = b?.parts.get(ev.part);
+          const def = this.world.materials.get(ev.material);
+          const color = (pv && this.partColor(pv, def)) ?? fallbackColor(ev.material, def);
+          let tag = this.homeTags.indexOf(ev.object) + 1;
+          if (tag === 0) tag = this.homeTags.push(ev.object);
+          this.particles.spawn("drips", ev.point, [(this.rng() - 0.5) * 0.1, -0.1, (this.rng() - 0.5) * 0.1], { color, tag });
+          break;
+        }
+        case "leak": {
+          const key = `${ev.object}|${ev.part}`;
+          const same = this.leaks.find((l) => l.object === ev.object && l.part === ev.part && Math.hypot(l.point[0] - ev.point[0], l.point[1] - ev.point[1], l.point[2] - ev.point[2]) < 0.03);
+          if (same) {
+            same.rate = ev.rate;
+            same.direction = ev.direction;
+          } else {
+            if (this.leaks.length >= 24) this.leaks.shift();
+            this.leaks.push({ object: ev.object, part: ev.part, fluid: ev.fluid, point: ev.point, direction: ev.direction, rate: ev.rate, pressurized: ev.pressurized, acc: 0 });
+          }
+          void key;
+          break;
+        }
+        case "explode":
+          this.onExplode(ev);
+          break;
+        case "destroyed":
+          break;
+      }
+    }
+    rootPoint(objectId) {
+      const b = this.bounds.get(objectId);
+      return b ? [b.root.position.x, b.root.position.y, b.root.position.z] : [0, 0, 0];
+    }
+    sound(key, point, volume) {
+      this.o.onSound?.(key, point, volume);
+    }
+    partVis(objectId, partId) {
+      return this.bounds.get(objectId)?.parts.get(partId) ?? null;
+    }
+    activate(objectId, partId) {
+      this.active.set(`${objectId}|${partId}`, { object: objectId, part: partId });
+    }
+    /** Current colour of the part's first mesh (char included), or null. */
+    partColor(pv, def) {
+      const mv = pv.meshes[0];
+      if (!mv) return null;
+      const mat = materialsOf2(mv.mesh.material)[0];
+      const c = mat?.color;
+      if (c && c.isColor) {
+        const tint = this.visuals.vertexTint(mv);
+        return tint ? c.clone().multiply(tint).getHex() : c.getHex();
+      }
+      return def ? fallbackColor(def.id, def) : null;
+    }
+    debrisOptions(kind, objectId, partId) {
+      const pv = this.partVis(objectId, partId);
+      const def = pv ? this.world.materials.get(pv.material) : void 0;
+      if (kind === "smoke") return { color: SMOKE_TONES[def?.thermal.smoke ?? "grey"] };
+      if (kind === "fibers" || kind === "leaves") {
+        const c = pv ? this.visuals.baseColorHex(pv.meshes[0] ?? {}) : -1;
+        return c >= 0 ? { color: c } : void 0;
+      }
+      if (kind === "dust" || kind === "chips") {
+        const c = pv && pv.meshes[0] ? this.visuals.baseColorHex(pv.meshes[0]) : -1;
+        return c >= 0 && kind === "chips" ? { color: c } : void 0;
+      }
+      return void 0;
+    }
+    /** Mesh of the part closest to a world point. */
+    nearestMesh(pv, p) {
+      let best = null;
+      let bd = Infinity;
+      for (const mv of pv.meshes) {
+        if (!mv.mesh.visible) continue;
+        const d = this.box.setFromObject(mv.mesh).distanceToPoint(p);
+        if (d < bd) {
+          bd = d;
+          best = mv;
+        }
+      }
+      return best;
+    }
+    worldDir(b, v) {
+      b.root.updateWorldMatrix(true, false);
+      return new this.THREE.Vector3(v[0], v[1], v[2]).applyQuaternion(b.root.getWorldQuaternion(this.tmpQ)).normalize();
+    }
+    onDent(ev) {
+      const b = this.bounds.get(ev.object);
+      const pv = b?.parts.get(ev.part);
+      if (!b || !pv) return;
+      const def = this.world.materials.get(pv.material);
+      const wp = new this.THREE.Vector3(ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]);
+      const wn = this.worldDir(b, ev.dent.normal);
+      for (const mv of pv.meshes) {
+        if (!mv.mesh.visible) continue;
+        this.visuals.applyDent(mv, wp, wn, ev.dent);
+      }
+      if (def?.tags?.includes("metal")) this.particles.burst("sparks", ev.worldPoint, [wn.x, wn.y, wn.z], 4 + Math.min(8, ev.dent.depth * 150), 3.2);
+      this.sound(impactKey(def), ev.worldPoint, clamp(0.3 + ev.dent.depth * 12, 0.3, 1));
+    }
+    onHole(ev) {
+      const b = this.bounds.get(ev.object);
+      const pv = b?.parts.get(ev.part);
+      if (!b || !pv) return;
+      const def = this.world.materials.get(pv.material);
+      const n = this.worldDir(b, ev.hole.normal);
+      const draw = (point, normal) => {
+        const wp = new this.THREE.Vector3(point[0], point[1], point[2]);
+        const mv = this.nearestMesh(pv, wp);
+        if (!mv) return;
+        if (def?.visual?.transparent) {
+          const seed = hashNumbers(ev.time, point[0], point[1], point[2]);
+          this.visuals.addCrack(mv, wp, normal, 7, Math.max(0.05, ev.hole.diameter * 5), 15267071, seed);
+        } else {
+          this.visuals.addHole(mv, wp, normal, ev.hole.diameter);
+        }
+      };
+      draw(ev.worldPoint, n);
+      if (ev.hole.through && ev.exitPoint) draw(ev.exitPoint, n.clone().negate());
+      if (def?.tags?.includes("metal")) this.particles.burst("sparks", ev.worldPoint, [n.x, n.y, n.z], 6, 3.5);
+      this.sound(impactKey(def), ev.worldPoint, 0.6);
+    }
+    onCrack(ev) {
+      const b = this.bounds.get(ev.object);
+      const pv = b?.parts.get(ev.part);
+      if (!b || !pv) return;
+      const def = this.world.materials.get(pv.material);
+      const wp = new this.THREE.Vector3(ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]);
+      const mv = this.nearestMesh(pv, wp);
+      if (mv) {
+        const color = def?.visual?.transparent ? 15267071 : 2762532;
+        this.visuals.addCrack(mv, wp, this.worldDir(b, ev.crack.normal), ev.crack.rays, ev.crack.length, color, hashNumbers(ev.time, ev.worldPoint[0], ev.worldPoint[1], ev.worldPoint[2]));
+      }
+      this.sound(impactKey(def), ev.worldPoint, 0.5);
+    }
+    onFracture(ev) {
+      const b = this.bounds.get(ev.object);
+      const pv = b?.parts.get(ev.part);
+      const matId = pv?.material || (ev.fragments[0]?.material ?? "");
+      const def = this.world.materials.get(matId);
+      let color = fallbackColor(matId, def);
+      let opacity = 0.5;
+      const transparent = def?.visual?.transparent === true;
+      if (pv) {
+        const c = this.partColor(pv, def);
+        if (c !== null) color = c;
+        const m = pv.meshes[0] ? materialsOf2(pv.meshes[0].origMaterial)[0] : void 0;
+        if (m && m.transparent) opacity = clamp(m.opacity, 0.2, 0.8);
+        this.visuals.hide(pv, "broken");
+      }
+      const maxAlive = this.low ? Math.floor(this.maxFragments / 2) : this.maxFragments;
+      const step = this.low ? 2 : 1;
+      for (let i = 0; i < ev.fragments.length; i += step) {
+        const fr = ev.fragments[i];
+        const fdef = this.world.materials.get(fr.material);
+        const mat = this.fragments.materialFor(fr.material, fdef === def || !fdef ? color : fallbackColor(fr.material, fdef), transparent || fdef?.visual?.transparent === true, opacity);
+        this.fragments.spawn(fr, mat, ev.object, maxAlive);
+      }
+      const up = [0, 1, 0];
+      const sizeK = clamp(ev.fragments.length / 10, 0.5, 2);
+      switch (ev.style) {
+        case "shatter":
+          this.particles.burst("shards", ev.point, up, 18 * sizeK, 3);
+          break;
+        case "crumble":
+          this.particles.burst("dust", ev.point, up, 16 * sizeK, 1.2, { color: pv ? this.partColor(pv, def) ?? void 0 : void 0 });
+          this.particles.burst("chips", ev.point, up, 6, 3);
+          break;
+        case "splinter":
+          this.particles.burst("splinters", ev.point, up, 14 * sizeK, 3);
+          this.particles.burst("dust", ev.point, up, 5, 0.8, { color: 11901556 });
+          break;
+        case "tear":
+          this.particles.burst("fibers", ev.point, up, 12 * sizeK, 1.6, { color });
+          break;
+        case "snap":
+          this.particles.burst("chips", ev.point, up, 8 * sizeK, 3);
+          break;
+        default:
+          this.particles.burst("sparks", ev.point, up, 10, 4);
+      }
+      this.sound(fractureKey(def, ev.style), ev.point, clamp(0.4 + ev.fragments.length * 0.03, 0.4, 1));
+    }
+    onDetach(ev) {
+      this.sound("detach", this.rootPoint(ev.object), 0.5);
+      if (!this.autoSplit) return;
+      const b = this.bounds.get(ev.object);
+      if (!b) return;
+      const st = this.world.state(ev.object);
+      if (!st || st.groups.length < 2) return;
+      const loose = st.groups.length - 1;
+      for (let i = 0; i < loose; i++) {
+        let newId;
+        try {
+          newId = this.world.splitGroup(ev.object, 1);
+        } catch {
+          break;
+        }
+        this.adoptSplit(b, newId);
+      }
+      const old = b.piece;
+      if (old) {
+        const { half, center } = this.measure(b.root, this.meshesOf(b));
+        old.halfExtents = half;
+        this.pieceSys.setCenter(old, center);
+        old.mass = Math.max(0.05, this.massOf(ev.object));
+        old.sleeping = false;
+      }
+    }
+    /** The renderer side of `splitGroup`: a new group holding the meshes of the new object, made a piece. */
+    adoptSplit(from, newId) {
+      const state = this.world.state(newId);
+      const root = from.root;
+      root.updateWorldMatrix(true, false);
+      const group = new this.THREE.Group();
+      group.name = `destruction-piece-${newId}`;
+      root.getWorldPosition(group.position);
+      root.getWorldQuaternion(group.quaternion);
+      this.scene.add(group);
+      group.updateMatrixWorld(true);
+      const nb = { id: newId, root: group, sync: true, parts: /* @__PURE__ */ new Map(), lastPos: null, lastQuat: null, piece: null, isSplit: true };
+      for (const p of state?.parts ?? []) {
+        const pv = from.parts.get(p.id);
+        if (!pv) continue;
+        from.parts.delete(p.id);
+        nb.parts.set(p.id, pv);
+        for (const mv of pv.meshes) {
+          group.attach(mv.mesh);
+          mv.moved = true;
+        }
+      }
+      this.bounds.set(newId, nb);
+      const meshes = this.meshesOf(nb);
+      if (meshes.length === 0) return;
+      const { half, center } = this.measure(group, meshes);
+      let vel = [0, 0, 0];
+      let ang = [0, 0, 0];
+      const op = from.piece;
+      if (op) {
+        vel = [...op.velocity];
+        ang = [...op.angularVelocity];
+        const c = this.pieceSys.centerOf(op, new this.THREE.Vector3());
+        const nc = center.clone().applyQuaternion(group.quaternion).add(group.position);
+        vel[0] += ang[1] * (nc.z - c.z) - ang[2] * (nc.y - c.y);
+        vel[1] += ang[2] * (nc.x - c.x) - ang[0] * (nc.z - c.z);
+        vel[2] += ang[0] * (nc.y - c.y) - ang[1] * (nc.x - c.x);
+      }
+      const piece = this.pieceSys.create(newId, group, half, center, this.massOf(newId), vel, ang);
+      nb.piece = piece;
+      this.o.onPiece?.(piece);
+    }
+    onExplode(ev) {
+      const p = ev.point;
+      const k = clamp(ev.radius / 3, 0.4, 2.5);
+      this.particles.burst("flash", p, [0, 1, 0], 1, 0, { size: k });
+      this.particles.burst("fire", p, [0, 1, 0], 34 * k, 4 * k, { size: 1 + k * 0.5 });
+      this.particles.burst("smoke", p, [0, 1, 0], 24 * k, 2.2, { color: SMOKE_TONES.black, size: 1 + k * 0.6 });
+      this.particles.burst("dust", p, [0, 1, 0], 22 * k, 3.5 * k);
+      this.particles.burst("sparks", p, [0, 1, 0], 16 * k, 8);
+      this.particles.push(p, ev.radius, 4);
+      if (this.o.explosionLight !== false) {
+        if (!this.light) {
+          this.light = new this.THREE.PointLight(16754784, 0, 10, 2);
+          this.light.name = "destruction-explosion-light";
+        }
+        if (!this.light.parent) this.scene.add(this.light);
+        this.light.position.set(p[0], p[1] + 0.5, p[2]);
+        this.light.distance = Math.max(6, ev.radius * 3);
+        this.lightPeak = clamp(Math.sqrt(Math.max(1, ev.energy)) * 0.6, 10, 400);
+        this.lightDur = 0.35;
+        this.lightT = this.lightDur;
+      }
+      const c = this.v1;
+      for (const pc of this.pieceSys.list) {
+        this.pieceSys.centerOf(pc, c);
+        const dx = c.x - p[0];
+        const dy = c.y - p[1];
+        const dz = c.z - p[2];
+        const d = Math.hypot(dx, dy, dz);
+        if (d > ev.radius) continue;
+        const fall = (1 - d / ev.radius) ** 2;
+        const speed = Math.min(30, Math.sqrt(2 * ev.energy * 0.02 / pc.mass)) * fall;
+        const inv = d > 1e-4 ? 1 / d : 0;
+        const dir = d > 1e-4 ? [dx * inv, dy * inv + 0.3, dz * inv] : [0, 1, 0];
+        const spread = pc.halfExtents[0];
+        this.pieceSys.impulse(pc, [dir[0] * speed * pc.mass, dir[1] * speed * pc.mass, dir[2] * speed * pc.mass], [c.x + (this.rng() - 0.5) * spread, c.y + spread * 0.5, c.z + (this.rng() - 0.5) * spread]);
       }
+      this.fragments.blast(p, ev.radius, Math.min(20, Math.sqrt(ev.energy) * 0.08));
+      this.sound("explode", p, clamp(0.5 + ev.radius / 10, 0.5, 1));
     }
-    return out;
-  };
-
-  // src/spec.ts
-  var METAL = /steel|iron|metal|alumin|copper|brass|bronze|tin|titan|chrome|zinc|lead/i;
-  function sanitizeId(name) {
-    let id = name.trim().replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-    if (id && /^[0-9]/.test(id)) id = `p_${id}`;
-    return id;
-  }
-  function isMesh(o) {
-    return o.isMesh === true;
-  }
-  function sizeOf(box) {
-    return [box.max.x - box.min.x, box.max.y - box.min.y, box.max.z - box.min.z];
-  }
-  function specFromObject3D(THREE, root, options = {}) {
-    const fallback = options.fallback ?? "plastic";
-    const minSize = options.minSize ?? 0.015;
-    root.updateMatrixWorld(true);
-    const inv = root.matrixWorld.clone().invert();
-    const entries = [];
-    const byKey = /* @__PURE__ */ new Map();
-    const visit = (o) => {
-      if (!o.visible || o.userData?.destructionIgnore) return;
-      if (isMesh(o) && o.geometry) {
-        const geom = o.geometry;
-        if (!geom.boundingBox) geom.computeBoundingBox();
-        if (geom.boundingBox && !geom.boundingBox.isEmpty()) {
-          const box = geom.boundingBox.clone().applyMatrix4(new THREE.Matrix4().multiplyMatrices(inv, o.matrixWorld));
-          const mats = Array.isArray(o.material) ? o.material : [o.material];
-          const matName = mats[0]?.name ?? "";
-          const ud = o.userData ?? {};
-          const material = options.materialOf?.(o) ?? (typeof ud.destructionMaterial === "string" ? ud.destructionMaterial : void 0) ?? guessMaterial(`${o.name} ${matName} ${typeof ud.material === "string" ? ud.material : ""}`) ?? fallback;
-          const explicit = typeof ud.destructionPart === "string" && ud.destructionPart ? ud.destructionPart : null;
-          const hollow = ud.hollow === true || /hollow/i.test(o.name);
-          const fill = options.fillOf?.(o, material);
-          const tags = Array.isArray(ud.destructionTags) ? ud.destructionTags : void 0;
-          const existing = explicit ? byKey.get(explicit) : void 0;
-          if (existing) {
-            const before = sizeOf(existing.box);
-            const bv = before[0] * before[1] * before[2];
-            const ns = sizeOf(box);
-            existing.box.union(box);
-            existing.meshes.push(o);
-            if (ns[0] * ns[1] * ns[2] > bv) existing.material = material;
-            existing.hollow = existing.hollow || hollow;
-            if (fill !== void 0) existing.fill = fill;
-          } else {
-            const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box, material, explicitId: explicit, fill, hollow, tags, fixedId: !!explicit, name: o.name };
-            entries.push(e);
-            if (explicit) byKey.set(explicit, e);
+    updateLight(dt) {
+      if (!this.light || this.lightT <= 0) return;
+      this.lightT = Math.max(0, this.lightT - dt);
+      const t = this.lightT / this.lightDur;
+      this.light.intensity = this.lightPeak * t * t;
+    }
+    // ----------------------------------------------------------------------------------------------------------------------------------
+    // Fire, heat, char, melt, leaks
+    // ----------------------------------------------------------------------------------------------------------------------------------
+    updateActive(dt) {
+      this.scanTimer += dt;
+      if (this.scanTimer >= 0.4) {
+        this.scanTimer = 0;
+        for (const b of this.bounds.values()) {
+          for (const pv of b.parts.values()) {
+            if (pv.gone !== "none" && pv.gone !== "broken") continue;
+            const ps = this.world.part(b.id, pv.id);
+            if (!ps) continue;
+            const def = this.world.materials.get(pv.material);
+            if (ps.burning || def?.visual?.glows && ps.temperature > GLOW_FROM_C || Math.abs(ps.char - pv.charApplied) > 0.01 || Math.abs(ps.melt - pv.meltApplied) > 0.01 || pv.gone === "none" && (ps.status === "melted" || ps.status === "ashes")) {
+              this.activate(b.id, pv.id);
+            }
           }
         }
       }
-      for (const c of o.children) visit(c);
-    };
-    visit(root);
-    const eps = 5e-3;
-    const overlapVolume = (a, b) => {
-      const x = Math.min(a.max.x, b.max.x) - Math.max(a.min.x, b.min.x) + eps;
-      const y = Math.min(a.max.y, b.max.y) - Math.max(a.min.y, b.min.y) + eps;
-      const z = Math.min(a.max.z, b.max.z) - Math.max(a.min.z, b.min.z) + eps;
-      return x > 0 && y > 0 && z > 0 ? x * y * z : 0;
-    };
-    const largest = (e) => Math.max(...sizeOf(e.box));
-    const kept = [];
-    const tiny = [];
-    for (const e of entries) (!e.fixedId && largest(e) < minSize ? tiny : kept).push(e);
-    for (const t of tiny) {
-      let best = null;
-      let bestV = 0;
-      for (const k of kept) {
-        const v = overlapVolume(t.box, k.box);
-        if (v > bestV) {
-          bestV = v;
-          best = k;
+      for (const [key, a] of this.active) {
+        const pv = this.partVis(a.object, a.part);
+        const ps = pv ? this.world.part(a.object, a.part) : null;
+        if (!pv || !ps) {
+          this.active.delete(key);
+          continue;
         }
-      }
-      if (!best) {
-        let bd = 0.05;
-        for (const k of kept) {
-          const d = k.box.distanceToPoint(t.box.getCenter(new THREE.Vector3()));
-          if (d < bd) {
-            bd = d;
-            best = k;
-          }
+        const def = this.world.materials.get(pv.material);
+        if (pv.gone === "none") {
+          this.visuals.setChar(pv, ps.char, def?.visual?.charColor ?? 1709072);
+          if (def?.visual?.glows) this.visuals.setGlow(pv, ps.temperature);
+          this.visuals.setMelt(pv, ps.melt);
+          if (ps.status === "melted") this.onGone(a.object, pv, "melted", def);
+          else if (ps.status === "ashes") this.onGone(a.object, pv, "ashes", def);
+        }
+        const fire = this.fires.get(key);
+        if (fire) {
+          if (ps.burning && ps.status !== "broken" && ps.status !== "ashes" && ps.status !== "melted") this.emitFire(fire, pv, def, dt);
+          else this.fires.delete(key);
+        }
+        const hot = def?.visual?.glows === true && ps.temperature > GLOW_FROM_C;
+        if (!ps.burning && !hot && Math.abs(ps.char - pv.charApplied) < 0.01 && Math.abs(ps.melt - pv.meltApplied) < 0.01) {
+          if (def?.visual?.glows && pv.gone === "none") this.visuals.setGlow(pv, 0);
+          this.active.delete(key);
         }
       }
-      if (best) {
-        best.meshes.push(...t.meshes);
+    }
+    onGone(objectId, pv, reason, def) {
+      const bb = new this.THREE.Box3();
+      for (const mv of pv.meshes) bb.union(this.box.setFromObject(mv.mesh));
+      this.visuals.hide(pv, reason);
+      if (bb.isEmpty()) return;
+      const c = bb.getCenter(new this.THREE.Vector3());
+      const s = bb.getSize(new this.THREE.Vector3());
+      const footprint = Math.sqrt(Math.max(s.x * s.z, 1e-4));
+      if (reason === "melted") {
+        this.ground.add("puddle", c.x, c.z, clamp(footprint * 0.55, 0.05, 1), this.partColor(pv, def) ?? fallbackColor(pv.material, def), objectId);
       } else {
-        kept.push(t);
+        this.ground.add("ash", c.x, c.z, clamp(footprint * 0.35, 0.04, 0.5), 1907224, objectId);
+        this.particles.burst("ash", [c.x, bb.max.y, c.z], [0, 1, 0], 10, 0.8);
       }
     }
-    const used = /* @__PURE__ */ new Set();
-    const parts = [];
-    const meshesOf = {};
-    let counter = 0;
-    for (const e of kept) {
-      counter++;
-      let base = (e.explicitId ? sanitizeId(e.explicitId) : "") || sanitizeId(e.name) || `part_${counter}`;
-      let id = base;
-      for (let n = 2; used.has(id); n++) id = `${base}_${n}`;
-      used.add(id);
-      base = id;
-      const size = sizeOf(e.box);
-      const center = e.box.getCenter(new THREE.Vector3());
-      const part = {
-        id,
-        material: e.material,
-        shape: { kind: "box", size: [Math.max(size[0], 2e-3), Math.max(size[1], 2e-3), Math.max(size[2], 2e-3)] },
-        position: [center.x, center.y, center.z]
-      };
-      const minSide = Math.min(...size);
-      if (e.fill !== void 0) part.fill = e.fill;
-      else if (e.hollow) part.fill = 0.05;
-      if (minSide < 0.01 && METAL.test(e.material)) {
-        part.fill = e.fill ?? 1;
-        part.thickness = Math.max(minSide, 5e-4);
+    emitFire(f, pv, def, dt) {
+      const bb = this.box;
+      bb.makeEmpty();
+      const tmp = new this.THREE.Box3();
+      for (const mv of pv.meshes) if (mv.mesh.visible) bb.union(tmp.setFromObject(mv.mesh));
+      let cx = f.point[0];
+      let cy = f.point[1];
+      let cz = f.point[2];
+      let sx = 0.2;
+      let sy = 0.2;
+      let sz = 0.2;
+      if (!bb.isEmpty()) {
+        const c = bb.getCenter(this.v1);
+        const s = bb.getSize(this.v2);
+        cx = c.x;
+        cy = bb.min.y;
+        cz = c.z;
+        sx = s.x;
+        sy = s.y;
+        sz = s.z;
+      }
+      const vol = clamp(Math.cbrt(Math.max(sx * sy * sz, 1e-5)), 0.05, 1.5);
+      f.accFire += (18 + 70 * vol) * dt;
+      f.accSmoke += (6 + 24 * vol) * dt;
+      const tone = SMOKE_TONES[def?.thermal.smoke ?? "grey"];
+      const rnd = this.rng;
+      while (f.accFire >= 1) {
+        f.accFire -= 1;
+        this.particles.spawn("fire", [cx + (rnd() - 0.5) * sx, cy + sy * (0.3 + 0.7 * rnd()), cz + (rnd() - 0.5) * sz], [(rnd() - 0.5) * 0.4, 0.5 + rnd() * 0.9, (rnd() - 0.5) * 0.4], { size: 0.6 + vol * 0.8 });
+      }
+      while (f.accSmoke >= 1) {
+        f.accSmoke -= 1;
+        this.particles.spawn("smoke", [cx + (rnd() - 0.5) * sx, cy + sy * (0.8 + 0.4 * rnd()), cz + (rnd() - 0.5) * sz], [(rnd() - 0.5) * 0.3 + 0.1, 0.4 + rnd() * 0.5, (rnd() - 0.5) * 0.3], { color: tone, size: 0.6 + vol });
       }
-      if (e.tags) part.tags = [...e.tags];
-      const ao = options.anchorBelow ?? -1;
-      if (ao >= 0 && e.box.min.y <= ao) part.anchored = true;
-      parts.push(part);
-      meshesOf[id] = e.meshes;
     }
-    const spec = { parts };
-    if (options.name !== void 0) spec.name = options.name;
-    else if (root.name) spec.name = root.name;
-    if (options.tags) spec.tags = [...options.tags];
-    spec.joints = options.joints === false ? [] : inferJoints(parts);
-    return { spec, parts: meshesOf };
-  }
+    updateLeaks(dt) {
+      for (let i = this.leaks.length - 1; i >= 0; i--) {
+        const l = this.leaks[i];
+        const ps = this.world.part(l.object, l.part);
+        if (!ps || ps.liters === void 0 || ps.liters <= 0) {
+          this.leaks.splice(i, 1);
+          continue;
+        }
+        l.acc += clamp(20 + l.rate * 400, 15, 120) * dt;
+        const color = FLUID_COLORS[l.fluid] ?? 11184810;
+        const d = l.direction;
+        const dl = Math.hypot(d[0], d[1], d[2]) || 1;
+        const sp = l.pressurized ? 2.5 + this.rng() * 1.5 : 0.3 + this.rng() * 0.3;
+        while (l.acc >= 1) {
+          l.acc -= 1;
+          const vel = [d[0] / dl * sp + (this.rng() - 0.5) * 0.25, d[1] / dl * sp + (this.rng() - 0.5) * 0.25, d[2] / dl * sp + (this.rng() - 0.5) * 0.25];
+          if (l.fluid === "gas") this.particles.spawn("steam", l.point, vel, { color, size: 0.5, alpha: 0.5 });
+          else this.particles.spawn("drips", l.point, vel, { color, tag: this.rng() < 0.03 ? this.tagOf(l.object) : 0 });
+        }
+      }
+    }
+    tagOf(object) {
+      let tag = this.homeTags.indexOf(object) + 1;
+      if (tag === 0) tag = this.homeTags.push(object);
+      return tag;
+    }
+    // ----------------------------------------------------------------------------------------------------------------------------------
+    // Emit, clear, restore, stats, dispose
+    // ----------------------------------------------------------------------------------------------------------------------------------
+    emit(kind, point, normal, count, speed) {
+      this.particles.burst(kind, point, normal, count, speed ?? DEFAULT_SPEED[kind] ?? 1, kind === "smoke" ? { color: SMOKE_TONES.grey } : void 0);
+    }
+    restore(objectId) {
+      const homes = /* @__PURE__ */ new Set([objectId]);
+      const self = this.bounds.get(objectId);
+      if (self?.isSplit) for (const pv of self.parts.values()) homes.add(pv.home);
+      for (const home of homes) this.restoreHome(home);
+      for (const [key, a] of [...this.active]) if (homes.has(a.object)) this.active.delete(key);
+      for (const [key, f] of [...this.fires]) if (homes.has(f.object)) this.fires.delete(key);
+      for (let i = this.leaks.length - 1; i >= 0; i--) if (homes.has(this.leaks[i].object)) this.leaks.splice(i, 1);
+      for (const home of homes) {
+        this.fragments.removeHome(home);
+        this.ground.removeHome(home);
+      }
+    }
+    restoreHome(home) {
+      const homeBound = this.bounds.get(home);
+      for (const b of [...this.bounds.values()]) {
+        for (const [pid, pv] of [...b.parts]) {
+          if (pv.home !== home) continue;
+          this.visuals.restorePart(pv);
+          if (b !== homeBound && homeBound) {
+            b.parts.delete(pid);
+            homeBound.parts.set(pid, pv);
+          }
+        }
+        if (b.isSplit && b.parts.size === 0) {
+          this.scene.remove(b.root);
+          this.pieceSys.remove(b.id);
+          this.bounds.delete(b.id);
+        }
+      }
+    }
+    clear() {
+      this.queue.length = 0;
+      this.active.clear();
+      this.fires.clear();
+      this.leaks.length = 0;
+      for (const id of [...this.bounds.keys()]) if (this.bounds.has(id)) this.restore(id);
+      for (const b of [...this.bounds.values()]) {
+        if (b.isSplit) {
+          for (const pv of b.parts.values()) this.visuals.restorePart(pv);
+          this.scene.remove(b.root);
+          this.pieceSys.remove(b.id);
+          this.bounds.delete(b.id);
+        }
+      }
+      this.fragments.clear();
+      this.ground.clear();
+      this.particles.clear();
+      if (this.light) {
+        this.light.intensity = 0;
+        this.lightT = 0;
+        this.scene.remove(this.light);
+      }
+    }
+    stats() {
+      return { fragments: this.fragments.count, particles: this.particles.live, pieces: this.pieceSys.list.length, decals: this.visuals.decalCount + this.ground.count };
+    }
+    dispose() {
+      if (this.disposed) return;
+      this.unsubscribe();
+      this.clear();
+      for (const id of [...this.bounds.keys()]) this.unbind(id);
+      this.fragments.dispose();
+      this.ground.dispose();
+      this.particles.dispose();
+      this.visuals.dispose();
+      this.light?.dispose?.();
+      this.light = null;
+      this.disposed = true;
+    }
+  };
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=index.global.js.map