@adatechnology/game-destruction-three 0.0.0-stage → 0.1.0

package/dist/index.global.js

@@ -0,0 +1,3545 @@
+"use strict";
+var GameDestructionThree = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    createDestructionRenderer: () => createDestructionRenderer,
+    heatColor: () => heatColor,
+    specFromObject3D: () => specFromObject3D
+  });
+
+  // src/math.ts
+  function createRng(seed) {
+    let a = seed >>> 0;
+    return () => {
+      a = a + 1831565813 >>> 0;
+      let t = a;
+      t = Math.imul(t ^ t >>> 15, t | 1);
+      t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+      return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    };
+  }
+  function hashNumbers(...values) {
+    let h = 2166136261;
+    for (const v of values) {
+      const n = Math.round(v * 1e3) | 0;
+      h = Math.imul(h ^ n, 16777619);
+      h ^= h >>> 13;
+    }
+    return h >>> 0;
+  }
+  function hashString(s) {
+    let h = 2166136261;
+    for (let i = 0; i < s.length; i++) h = Math.imul(h ^ s.charCodeAt(i), 16777619);
+    return h >>> 0;
+  }
+  var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+  var lerp = (a, b, t) => a + (b - a) * t;
+  function hexToRgb(hex) {
+    return [(hex >> 16 & 255) / 255, (hex >> 8 & 255) / 255, (hex & 255) / 255];
+  }
+  function mixHex(a, b, t) {
+    const ar = a >> 16 & 255;
+    const ag = a >> 8 & 255;
+    const ab = a & 255;
+    const r = Math.round(ar + ((b >> 16 & 255) - ar) * t);
+    const g = Math.round(ag + ((b >> 8 & 255) - ag) * t);
+    const bl = Math.round(ab + ((b & 255) - ab) * t);
+    return r << 16 | g << 8 | bl;
+  }
+
+  // src/fragments.ts
+  var FragmentSystem = class {
+    constructor(THREE, o) {
+      __publicField(this, "THREE", THREE);
+      __publicField(this, "o", o);
+      __publicField(this, "list", []);
+      __publicField(this, "box");
+      __publicField(this, "shardGeos", []);
+      __publicField(this, "materials", /* @__PURE__ */ new Map());
+      __publicField(this, "q");
+      __publicField(this, "dq");
+      __publicField(this, "m");
+      __publicField(this, "v");
+      __publicField(this, "w");
+      __publicField(this, "rng", createRng(1374496523));
+      this.box = new THREE.BoxGeometry(1, 1, 1);
+      this.q = new THREE.Quaternion();
+      this.dq = new THREE.Quaternion();
+      this.m = new THREE.Matrix4();
+      this.v = new THREE.Vector3();
+      this.w = new THREE.Vector3();
+    }
+    get count() {
+      return this.list.length;
+    }
+    /** Meshes of every live fragment (tests and picking). */
+    meshes() {
+      return this.list.map((f) => f.mesh);
+    }
+    /** One shared material per source material id + colour (+ transparency). */
+    materialFor(materialId, color, transparent, opacity = 0.5) {
+      const key = `${materialId}:${color}:${transparent ? 1 : 0}`;
+      let m = this.materials.get(key);
+      if (!m) {
+        m = transparent ? new this.THREE.MeshStandardMaterial({ color, roughness: 0.15, metalness: 0.1, transparent: true, opacity, side: this.THREE.DoubleSide, depthWrite: false }) : new this.THREE.MeshLambertMaterial({ color });
+        this.materials.set(key, m);
+      }
+      return m;
+    }
+    shardGeometry(seed) {
+      const idx = seed % 6;
+      let g = this.shardGeos[idx];
+      if (!g) {
+        const r = createRng(1e3 + idx);
+        const n = 3 + Math.floor(r() * 3);
+        const shape = new this.THREE.Shape();
+        const pts = [];
+        for (let i = 0; i < n; i++) {
+          const a = i / n * Math.PI * 2 + (r() - 0.5) * 0.7;
+          const rad = 0.35 + r() * 0.15;
+          pts.push([Math.cos(a) * rad, Math.sin(a) * rad]);
+        }
+        shape.moveTo(pts[0][0], pts[0][1]);
+        for (let i = 1; i < n; i++) shape.lineTo(pts[i][0], pts[i][1]);
+        shape.closePath();
+        g = new this.THREE.ExtrudeGeometry(shape, { depth: 1, bevelEnabled: false });
+        g.translate(0, 0, -0.5);
+        this.shardGeos[idx] = g;
+      }
+      return g;
+    }
+    /** Create the mesh of a fragment and start its motion. `maxAllowed` is the live budget. */
+    spawn(f, material, home, maxAllowed) {
+      const geo = f.shape === "shard" ? this.shardGeometry(hashString(f.id)) : this.box;
+      const mesh = new this.THREE.Mesh(geo, material);
+      mesh.position.set(f.center[0], f.center[1], f.center[2]);
+      mesh.quaternion.set(f.rotation[0], f.rotation[1], f.rotation[2], f.rotation[3]).normalize();
+      const sz = f.size;
+      const sc = new this.THREE.Vector3(Math.max(5e-3, sz[0]), Math.max(5e-3, sz[1]), Math.max(3e-3, sz[2]));
+      mesh.scale.copy(sc);
+      mesh.castShadow = true;
+      this.o.scene.add(mesh);
+      const live = {
+        mesh,
+        home,
+        vel: new this.THREE.Vector3(f.velocity[0], f.velocity[1], f.velocity[2]),
+        ang: new this.THREE.Vector3(f.angularVelocity[0], f.angularVelocity[1], f.angularVelocity[2]),
+        // shards are thin: the contact extent uses the real (small) thickness, the chunk uses half of each side
+        half: sc.clone().multiplyScalar(0.5),
+        baseScale: sc,
+        still: 0,
+        asleep: false,
+        rest: 0,
+        fade: 1,
+        dying: false
+      };
+      this.list.push(live);
+      let alive = this.list.reduce((n, l) => n + (l.dying ? 0 : 1), 0);
+      for (let i = 0; i < this.list.length && alive > maxAllowed; i++) {
+        if (!this.list[i].dying) {
+          this.list[i].dying = true;
+          alive--;
+        }
+      }
+    }
+    /** Add velocity to every fragment within `radius` of a point (blasts). */
+    blast(point, radius, speed) {
+      for (const f of this.list) {
+        const d = this.v.copy(f.mesh.position).sub(this.w.set(point[0], point[1], point[2]));
+        const dist = d.length();
+        if (dist > radius || f.dying) continue;
+        const k = (1 - dist / radius) ** 2 * speed;
+        d.normalize().multiplyScalar(k);
+        d.y += k * 0.4;
+        f.vel.add(d);
+        f.ang.add(this.w.set(this.rng() - 0.5, this.rng() - 0.5, this.rng() - 0.5).multiplyScalar(k));
+        f.asleep = false;
+        f.rest = 0;
+      }
+    }
+    update(dt) {
+      const g = this.o.gravity;
+      for (let i = this.list.length - 1; i >= 0; i--) {
+        const f = this.list[i];
+        if (f.dying) {
+          f.fade -= dt / 0.6;
+          if (f.fade <= 0) {
+            this.o.scene.remove(f.mesh);
+            this.list.splice(i, 1);
+            continue;
+          }
+          f.mesh.scale.copy(f.baseScale).multiplyScalar(f.fade);
+        }
+        if (f.asleep) {
+          f.rest += dt;
+          if (this.o.life > 0 && f.rest > this.o.life) f.dying = true;
+          continue;
+        }
+        this.step(f, dt, g);
+      }
+    }
+    step(f, dt, g) {
+      const mesh = f.mesh;
+      f.vel.y -= g * dt;
+      mesh.position.addScaledVector(f.vel, dt);
+      const w = f.ang.length();
+      if (w > 1e-5) {
+        this.dq.setFromAxisAngle(this.v.copy(f.ang).multiplyScalar(1 / w), w * dt);
+        mesh.quaternion.premultiply(this.dq).normalize();
+      }
+      this.m.makeRotationFromQuaternion(mesh.quaternion);
+      const e = this.m.elements;
+      const h = f.half;
+      const sc = f.dying ? f.fade : 1;
+      const ext = (Math.abs(e[1]) * h.x + Math.abs(e[5]) * h.y + Math.abs(e[9]) * h.z) * sc;
+      const gy = this.o.groundAt(mesh.position.x, mesh.position.z);
+      let contact = false;
+      if (mesh.position.y - ext < gy) {
+        contact = true;
+        mesh.position.y = gy + ext;
+        if (f.vel.y < -0.6) {
+          f.vel.y = -f.vel.y * 0.25;
+          f.vel.x *= 0.7;
+          f.vel.z *= 0.7;
+          f.ang.multiplyScalar(0.55);
+          f.ang.x += (this.rng() - 0.5) * 2;
+          f.ang.z += (this.rng() - 0.5) * 2;
+        } else {
+          f.vel.y = 0;
+          const fr = Math.exp(-7 * dt);
+          f.vel.x *= fr;
+          f.vel.z *= fr;
+          f.ang.multiplyScalar(Math.exp(-6 * dt));
+        }
+      } else {
+        f.ang.multiplyScalar(Math.exp(-0.15 * dt));
+      }
+      if (contact && f.vel.lengthSq() < 4) this.settle(f, dt);
+      const slow = f.vel.lengthSq() < 0.012 && f.ang.lengthSq() < 0.2;
+      if (contact && slow) {
+        f.still += dt;
+        if (f.still > 0.4) {
+          f.asleep = true;
+          f.vel.set(0, 0, 0);
+          f.ang.set(0, 0, 0);
+        }
+      } else {
+        f.still = 0;
+      }
+    }
+    /** Tip the fragment towards lying on its flattest face. */
+    settle(f, dt) {
+      const mesh = f.mesh;
+      this.m.makeRotationFromQuaternion(mesh.quaternion);
+      const e = this.m.elements;
+      const up = [e[1], e[5], e[9]];
+      const half = [f.half.x, f.half.y, f.half.z];
+      let small = 0;
+      for (let i = 1; i < 3; i++) if (half[i] < half[small]) small = i;
+      let axis = small;
+      if (Math.abs(up[small]) < 0.35) {
+        axis = 0;
+        for (let i = 1; i < 3; i++) if (Math.abs(up[i]) > Math.abs(up[axis])) axis = i;
+      }
+      const sign = up[axis] >= 0 ? 1 : -1;
+      this.v.set(e[axis * 4], e[axis * 4 + 1], e[axis * 4 + 2]).multiplyScalar(sign);
+      this.w.set(0, 1, 0);
+      this.dq.setFromUnitVectors(this.v, this.w);
+      this.q.copy(this.dq).multiply(mesh.quaternion);
+      mesh.quaternion.slerp(this.q, clamp(dt * 7, 0, 1));
+    }
+    /** Remove the fragments of one object (after `restore`). */
+    removeHome(home) {
+      for (let i = this.list.length - 1; i >= 0; i--) {
+        if (this.list[i].home === home) {
+          this.o.scene.remove(this.list[i].mesh);
+          this.list.splice(i, 1);
+        }
+      }
+    }
+    clear() {
+      for (const f of this.list) this.o.scene.remove(f.mesh);
+      this.list.length = 0;
+    }
+    dispose() {
+      this.clear();
+      this.box.dispose();
+      for (const g of this.shardGeos) g?.dispose();
+      this.shardGeos = [];
+      for (const m of this.materials.values()) m.dispose();
+      this.materials.clear();
+    }
+  };
+
+  // src/ground.ts
+  var MAX_RADIUS = 1.2;
+  var GroundSpots = class {
+    constructor(THREE, scene, groundAt, cap) {
+      __publicField(this, "THREE", THREE);
+      __publicField(this, "scene", scene);
+      __publicField(this, "groundAt", groundAt);
+      __publicField(this, "cap", cap);
+      __publicField(this, "spots", []);
+      __publicField(this, "geometry");
+      __publicField(this, "materials", /* @__PURE__ */ new Map());
+      this.geometry = new THREE.CircleGeometry(1, 20);
+      this.geometry.rotateX(-Math.PI / 2);
+    }
+    get count() {
+      return this.spots.length;
+    }
+    material(kind, color) {
+      const key = `${kind}:${color}`;
+      let m = this.materials.get(key);
+      if (!m) {
+        m = new this.THREE.MeshBasicMaterial({
+          color,
+          transparent: true,
+          opacity: kind === "puddle" ? 0.88 : 0.95,
+          depthWrite: false,
+          polygonOffset: true,
+          polygonOffsetFactor: -2,
+          polygonOffsetUnits: -2
+        });
+        this.materials.set(key, m);
+      }
+      return m;
+    }
+    /** Add (or grow) a spot at (x, z). `radius` is the radius this addition contributes. */
+    add(kind, x, z, radius, color, home) {
+      for (const s of this.spots) {
+        if (s.kind !== kind) continue;
+        const d = Math.hypot(s.x - x, s.z - z);
+        if (d < Math.max(s.target, radius) * 0.9) {
+          s.target = Math.min(MAX_RADIUS, Math.sqrt(s.target * s.target + radius * radius * 0.5));
+          return;
+        }
+      }
+      while (this.spots.length >= this.cap) this.remove(this.spots[0]);
+      const mesh = new this.THREE.Mesh(this.geometry, this.material(kind, color));
+      const y = this.groundAt(x, z) + 4e-3 + this.spots.length % 8 * 4e-4;
+      mesh.position.set(x, y, z);
+      mesh.scale.setScalar(1e-3);
+      mesh.renderOrder = 1;
+      this.scene.add(mesh);
+      this.spots.push({ mesh, kind, home, x, z, radius: 1e-3, target: Math.min(MAX_RADIUS, radius) });
+    }
+    remove(s) {
+      const i = this.spots.indexOf(s);
+      if (i >= 0) this.spots.splice(i, 1);
+      this.scene.remove(s.mesh);
+    }
+    update(dt) {
+      const k = Math.min(1, dt * 3);
+      for (const s of this.spots) {
+        if (Math.abs(s.radius - s.target) < 1e-4) continue;
+        s.radius = lerp(s.radius, s.target, k);
+        s.mesh.scale.setScalar(s.radius);
+      }
+    }
+    /** Remove the spots made for one object (after its `restore`). */
+    removeHome(home) {
+      for (const s of [...this.spots]) if (s.home === home) this.remove(s);
+    }
+    clear() {
+      for (const s of [...this.spots]) this.remove(s);
+    }
+    dispose() {
+      this.clear();
+      this.geometry.dispose();
+      for (const m of this.materials.values()) m.dispose();
+      this.materials.clear();
+    }
+  };
+
+  // src/particles.ts
+  var KINDS = {
+    fire: { additive: true, life: [0.45, 0.9], size: [0.1, 0.2], grow: 0.3, gravity: 0, rise: 2.4, drag: 1.2, c0: 16760896, c1: 12591104, alpha: 0.9, fadeIn: 0.12, cone: 0.7, ground: "none", flicker: 0.35 },
+    smoke: { additive: false, life: [1.8, 3.2], size: [0.14, 0.24], grow: 3.2, gravity: 0, rise: 0.7, drag: 0.8, c0: 6710886, c1: 10132122, alpha: 0.35, fadeIn: 0.15, cone: 0.6, ground: "none" },
+    sparks: { additive: true, life: [0.25, 0.6], size: [0.018, 0.03], grow: 0.5, gravity: 1, rise: 0, drag: 0.3, c0: 16773792, c1: 16738832, alpha: 1, fadeIn: 0.02, cone: 0.55, ground: "bounce" },
+    dust: { additive: false, life: [1, 2], size: [0.08, 0.14], grow: 2.5, gravity: 0.05, rise: 0, drag: 2.5, c0: 9274745, c1: 9274745, alpha: 0.4, fadeIn: 0.1, cone: 0.4, ground: "none" },
+    shards: { additive: true, life: [0.8, 1.4], size: [0.02, 0.035], grow: 0.8, gravity: 1, rise: 0, drag: 0.2, c0: 14677247, c1: 10473727, alpha: 0.9, fadeIn: 0.03, cone: 0.5, ground: "bounce", flicker: 0.5 },
+    splinters: { additive: false, life: [0.8, 1.5], size: [0.02, 0.035], grow: 1, gravity: 1, rise: 0, drag: 0.3, c0: 10516042, c1: 8017200, alpha: 1, fadeIn: 0.02, cone: 0.5, ground: "bounce" },
+    chips: { additive: false, life: [0.8, 1.5], size: [0.025, 0.04], grow: 1, gravity: 1, rise: 0, drag: 0.3, c0: 9077624, c1: 7235679, alpha: 1, fadeIn: 0.02, cone: 0.5, ground: "bounce" },
+    fibers: { additive: false, life: [1.5, 2.5], size: [0.02, 0.03], grow: 1, gravity: 0.15, rise: 0, drag: 2, c0: 12101768, c1: 12101768, alpha: 0.9, fadeIn: 0.05, cone: 0.4, ground: "stop", flutter: 2.5 },
+    leaves: { additive: false, life: [1.5, 2.8], size: [0.03, 0.05], grow: 1, gravity: 0.15, rise: 0, drag: 2, c0: 6003260, c1: 4882224, alpha: 0.95, fadeIn: 0.05, cone: 0.4, ground: "stop", flutter: 2.8 },
+    drips: { additive: false, life: [2, 3], size: [0.025, 0.035], grow: 1, gravity: 1, rise: 0, drag: 0, c0: 6974058, c1: 6974058, alpha: 1, fadeIn: 0.01, cone: 0.2, ground: "land" },
+    ash: { additive: false, life: [2, 4], size: [0.02, 0.04], grow: 1.2, gravity: 0.08, rise: 0, drag: 1.5, c0: 2762275, c1: 1710102, alpha: 0.8, fadeIn: 0.1, cone: 0.5, ground: "stop", flutter: 0.6 },
+    steam: { additive: false, life: [1, 2], size: [0.12, 0.2], grow: 3, gravity: 0, rise: 0.9, drag: 1, c0: 16777215, c1: 14739694, alpha: 0.35, fadeIn: 0.15, cone: 0.6, ground: "none" },
+    flash: { additive: true, life: [0.12, 0.2], size: [1.2, 1.8], grow: 1.6, gravity: 0, rise: 0, drag: 0, c0: 16774080, c1: 16748592, alpha: 1, fadeIn: 0.1, cone: 0, ground: "none" },
+    foam: { additive: false, life: [1, 1.8], size: [0.06, 0.1], grow: 1.5, gravity: 0.6, rise: 0, drag: 1.5, c0: 16054527, c1: 14542576, alpha: 0.8, fadeIn: 0.05, cone: 0.5, ground: "stop" }
+  };
+  var KIND_IDS = Object.keys(KINDS);
+  var KIND_INDEX = {};
+  KIND_IDS.forEach((k, i) => KIND_INDEX[k] = i);
+  var KIND_LIST = KIND_IDS.map((k) => KINDS[k]);
+  var VERT = `
+uniform float uScale;
+attribute float size;
+attribute float alpha;
+attribute vec3 pcolor;
+varying float vAlpha;
+varying vec3 vColor;
+void main() {
+  vAlpha = alpha;
+  vColor = pcolor;
+  vec4 mv = modelViewMatrix * vec4(position, 1.0);
+  gl_PointSize = min(size * uScale / max(0.1, -mv.z), 256.0);
+  gl_Position = projectionMatrix * mv;
+}`;
+  var FRAG = `
+varying float vAlpha;
+varying vec3 vColor;
+void main() {
+  float d = length(gl_PointCoord - vec2(0.5)) * 2.0;
+  float a = (1.0 - smoothstep(0.35, 1.0, d)) * vAlpha;
+  if (a < 0.004) discard;
+  gl_FragColor = vec4(vColor, a);
+}`;
+  var Pool = class {
+    constructor(THREE, capacity, additive, pointScale) {
+      __publicField(this, "capacity", capacity);
+      __publicField(this, "points");
+      __publicField(this, "geometry");
+      __publicField(this, "material");
+      __publicField(this, "live", 0);
+      __publicField(this, "next", 0);
+      __publicField(this, "high", 0);
+      __publicField(this, "pos");
+      __publicField(this, "col");
+      __publicField(this, "alp");
+      __publicField(this, "siz");
+      __publicField(this, "vel");
+      __publicField(this, "age");
+      __publicField(this, "life");
+      __publicField(this, "size0");
+      __publicField(this, "alive");
+      __publicField(this, "kind");
+      __publicField(this, "seed");
+      __publicField(this, "alphaMul");
+      __publicField(this, "tag");
+      __publicField(this, "colorHex");
+      __publicField(this, "bounced");
+      const n = Math.max(1, capacity);
+      this.pos = new Float32Array(n * 3);
+      this.col = new Float32Array(n * 3);
+      this.alp = new Float32Array(n);
+      this.siz = new Float32Array(n);
+      this.vel = new Float32Array(n * 3);
+      this.age = new Float32Array(n);
+      this.life = new Float32Array(n);
+      this.size0 = new Float32Array(n);
+      this.alive = new Uint8Array(n);
+      this.kind = new Uint8Array(n);
+      this.seed = new Float32Array(n);
+      this.alphaMul = new Float32Array(n);
+      this.tag = new Int32Array(n);
+      this.colorHex = new Int32Array(n);
+      this.bounced = new Uint8Array(n);
+      this.geometry = new THREE.BufferGeometry();
+      const attr = (a, size) => {
+        const at = new THREE.BufferAttribute(a, size);
+        at.setUsage(THREE.DynamicDrawUsage);
+        return at;
+      };
+      this.geometry.setAttribute("position", attr(this.pos, 3));
+      this.geometry.setAttribute("pcolor", attr(this.col, 3));
+      this.geometry.setAttribute("alpha", attr(this.alp, 1));
+      this.geometry.setAttribute("size", attr(this.siz, 1));
+      this.geometry.setDrawRange(0, 0);
+      this.material = new THREE.ShaderMaterial({
+        uniforms: { uScale: { value: pointScale } },
+        vertexShader: VERT,
+        fragmentShader: FRAG,
+        transparent: true,
+        depthWrite: false,
+        blending: additive ? THREE.AdditiveBlending : THREE.NormalBlending
+      });
+      this.points = new THREE.Points(this.geometry, this.material);
+      this.points.frustumCulled = false;
+      this.points.name = additive ? "destruction-particles-additive" : "destruction-particles";
+      this.points.renderOrder = additive ? 11 : 10;
+    }
+    spawn(kind, x, y, z, vx, vy, vz, def, rnd, o) {
+      if (this.capacity <= 0) return;
+      const i = this.next;
+      this.next = (this.next + 1) % this.capacity;
+      if (this.alive[i]) this.live--;
+      this.alive[i] = 1;
+      this.live++;
+      if (i + 1 > this.high) this.high = i + 1;
+      this.kind[i] = kind;
+      this.pos[i * 3] = x;
+      this.pos[i * 3 + 1] = y;
+      this.pos[i * 3 + 2] = z;
+      this.vel[i * 3] = vx;
+      this.vel[i * 3 + 1] = vy;
+      this.vel[i * 3 + 2] = vz;
+      this.age[i] = 0;
+      this.life[i] = lerp(def.life[0], def.life[1], rnd()) * (o?.life ?? 1);
+      this.size0[i] = lerp(def.size[0], def.size[1], rnd()) * (o?.size ?? 1);
+      this.seed[i] = rnd();
+      this.alphaMul[i] = o?.alpha ?? 1;
+      this.tag[i] = o?.tag ?? 0;
+      this.colorHex[i] = o?.color ?? -1;
+      this.bounced[i] = 0;
+      this.siz[i] = this.size0[i];
+      this.alp[i] = 0;
+    }
+    kill(i) {
+      if (!this.alive[i]) return;
+      this.alive[i] = 0;
+      this.live--;
+      this.alp[i] = 0;
+      this.siz[i] = 0;
+    }
+    clear() {
+      this.alive.fill(0);
+      this.alp.fill(0);
+      this.siz.fill(0);
+      this.live = 0;
+      this.high = 0;
+      this.next = 0;
+      this.geometry.setDrawRange(0, 0);
+    }
+    /** Move a live particle (used by external pushes such as blasts). */
+    push(cx, cy, cz, radius, speed) {
+      for (let i = 0; i < this.high; i++) {
+        if (!this.alive[i]) continue;
+        const dx = this.pos[i * 3] - cx;
+        const dy = this.pos[i * 3 + 1] - cy;
+        const dz = this.pos[i * 3 + 2] - cz;
+        const d = Math.hypot(dx, dy, dz);
+        if (d > radius || d < 1e-4) continue;
+        const f = (1 - d / radius) * speed;
+        this.vel[i * 3] += dx / d * f;
+        this.vel[i * 3 + 1] += dy / d * f;
+        this.vel[i * 3 + 2] += dz / d * f;
+      }
+    }
+    update(dt, host) {
+      let top = 0;
+      for (let i = 0; i < this.high; i++) {
+        if (!this.alive[i]) continue;
+        const def = KIND_LIST[this.kind[i]];
+        const age = this.age[i] += dt;
+        const life = this.life[i];
+        if (age >= life) {
+          this.kill(i);
+          continue;
+        }
+        const t = age / life;
+        const i3 = i * 3;
+        let vx = this.vel[i3];
+        let vy = this.vel[i3 + 1];
+        let vz = this.vel[i3 + 2];
+        vy += (def.rise - def.gravity * host.gravity) * dt;
+        if (def.flutter) {
+          const ph = age * 7 + this.seed[i] * 40;
+          vx += Math.sin(ph) * def.flutter * dt;
+          vz += Math.cos(ph * 1.3) * def.flutter * dt;
+        }
+        if (def.drag > 0) {
+          const k = Math.exp(-def.drag * dt);
+          vx *= k;
+          vy *= k;
+          vz *= k;
+        }
+        const x = this.pos[i3] + vx * dt;
+        let y = this.pos[i3 + 1] + vy * dt;
+        const z = this.pos[i3 + 2] + vz * dt;
+        if (def.ground !== "none") {
+          const gy = host.groundAt(x, z) + 5e-3;
+          if (y < gy) {
+            if (def.ground === "land") {
+              const tag = this.tag[i];
+              if (tag !== 0) host.onLand(x, gy, z, this.colorHex[i] >= 0 ? this.colorHex[i] : def.c0, tag);
+              this.kill(i);
+              continue;
+            }
+            y = gy;
+            if (def.ground === "bounce" && !this.bounced[i]) {
+              this.bounced[i] = 1;
+              vy = Math.abs(vy) * 0.35;
+              vx *= 0.6;
+              vz *= 0.6;
+            } else {
+              vx = vy = vz = 0;
+            }
+          }
+        }
+        this.vel[i3] = vx;
+        this.vel[i3 + 1] = vy;
+        this.vel[i3 + 2] = vz;
+        this.pos[i3] = x;
+        this.pos[i3 + 1] = y;
+        this.pos[i3 + 2] = z;
+        this.siz[i] = this.size0[i] * lerp(1, def.grow, t);
+        const c0 = this.colorHex[i] >= 0 ? this.colorHex[i] : def.c0;
+        const c1 = this.colorHex[i] >= 0 ? this.colorHex[i] : def.c1;
+        const a = hexToRgb(c0);
+        const b = hexToRgb(c1);
+        this.col[i3] = lerp(a[0], b[0], t);
+        this.col[i3 + 1] = lerp(a[1], b[1], t);
+        this.col[i3 + 2] = lerp(a[2], b[2], t);
+        let env = t < def.fadeIn ? t / def.fadeIn : 1 - (t - def.fadeIn) / (1 - def.fadeIn);
+        if (def.flicker) env *= 1 - def.flicker * (0.5 + 0.5 * Math.sin(age * 38 + this.seed[i] * 50));
+        this.alp[i] = clamp(env, 0, 1) * def.alpha * this.alphaMul[i];
+        top = i + 1;
+      }
+      this.high = top;
+      this.geometry.setDrawRange(0, top);
+      for (const name of ["position", "pcolor", "alpha", "size"]) {
+        ;
+        this.geometry.getAttribute(name).needsUpdate = true;
+      }
+    }
+    dispose() {
+      this.geometry.dispose();
+      this.material.dispose();
+    }
+  };
+  var ParticleSystem = class {
+    constructor(THREE, o) {
+      __publicField(this, "o", o);
+      __publicField(this, "add");
+      __publicField(this, "normal");
+      __publicField(this, "rng", createRng(2654435761));
+      __publicField(this, "attached", false);
+      __publicField(this, "host");
+      const addCap = Math.floor(o.capacity * 0.4);
+      this.add = new Pool(THREE, addCap, true, o.pointScale);
+      this.normal = new Pool(THREE, o.capacity - addCap, false, o.pointScale);
+      this.host = { groundAt: o.groundAt, gravity: o.gravity, onLand: o.onLand };
+    }
+    get capacity() {
+      return this.add.capacity + this.normal.capacity;
+    }
+    get live() {
+      return this.add.live + this.normal.live;
+    }
+    ensureAttached() {
+      if (this.attached) return;
+      this.attached = true;
+      this.o.scene.add(this.add.points, this.normal.points);
+    }
+    /** Remove the Points from the scene (they come back on the next emit). */
+    detach() {
+      if (!this.attached) return;
+      this.attached = false;
+      this.o.scene.remove(this.add.points, this.normal.points);
+    }
+    /** Spawn one particle with an explicit velocity. */
+    spawn(kind, p, v, opts) {
+      const def = KINDS[kind];
+      this.ensureAttached();
+      (def.additive ? this.add : this.normal).spawn(KIND_INDEX[kind], p[0], p[1], p[2], v[0], v[1], v[2], def, this.rng, opts);
+    }
+    /** Spawn `count` particles leaving `point` around `normal` at about `speed` m/s. */
+    burst(kind, point, normal, count, speed = 1, opts) {
+      const def = KINDS[kind];
+      const n = Math.max(0, Math.round(count * this.o.density));
+      const rnd = this.rng;
+      const nl = Math.hypot(normal[0], normal[1], normal[2]) || 1;
+      const nx = normal[0] / nl;
+      const ny = normal[1] / nl;
+      const nz = normal[2] / nl;
+      for (let k = 0; k < n; k++) {
+        const u = rnd() * 2 - 1;
+        const ph = rnd() * Math.PI * 2;
+        const s = Math.sqrt(1 - u * u);
+        const rx = s * Math.cos(ph);
+        const ry = u;
+        const rz = s * Math.sin(ph);
+        let dx = nx * def.cone + rx * (1 - def.cone);
+        let dy = ny * def.cone + ry * (1 - def.cone);
+        let dz = nz * def.cone + rz * (1 - def.cone);
+        dx += rx * 0.35;
+        dy += ry * 0.35;
+        dz += rz * 0.35;
+        const l = Math.hypot(dx, dy, dz) || 1;
+        const sp = speed * (0.35 + 0.65 * rnd());
+        const jitter = 0.01 + (def.size[1] > 0.5 ? 0.15 : 0.02);
+        this.spawn(
+          kind,
+          [point[0] + (rnd() - 0.5) * jitter, point[1] + (rnd() - 0.5) * jitter, point[2] + (rnd() - 0.5) * jitter],
+          [dx / l * sp, dy / l * sp, dz / l * sp],
+          opts
+        );
+      }
+    }
+    /** Blast wave: shove live particles away from a point. */
+    push(point, radius, speed) {
+      this.add.push(point[0], point[1], point[2], radius, speed);
+      this.normal.push(point[0], point[1], point[2], radius, speed);
+    }
+    update(dt) {
+      if (this.add.live > 0 || this.add.points.geometry.drawRange.count > 0) this.add.update(dt, this.host);
+      if (this.normal.live > 0 || this.normal.points.geometry.drawRange.count > 0) this.normal.update(dt, this.host);
+    }
+    clear() {
+      this.add.clear();
+      this.normal.clear();
+      this.detach();
+    }
+    dispose() {
+      this.detach();
+      this.add.dispose();
+      this.normal.dispose();
+    }
+  };
+
+  // src/pieces.ts
+  var SUB_DT = 1 / 120;
+  var MU = 0.7;
+  var SLEEP_AFTER = 0.5;
+  var HARD_LANDING = 3;
+  var SLOP = 2e-3;
+  var PieceSystem = class {
+    constructor(THREE, o) {
+      __publicField(this, "THREE", THREE);
+      __publicField(this, "o", o);
+      __publicField(this, "list", []);
+      __publicField(this, "time", 0);
+      __publicField(this, "p");
+      __publicField(this, "q");
+      __publicField(this, "dq");
+      __publicField(this, "m");
+      __publicField(this, "ax");
+      this.p = new THREE.Vector3();
+      this.q = new THREE.Quaternion();
+      this.dq = new THREE.Quaternion();
+      this.m = new THREE.Matrix4();
+      this.ax = new THREE.Vector3();
+    }
+    get(objectId) {
+      return this.list.find((b) => b.objectId === objectId) ?? null;
+    }
+    create(objectId, root, halfExtents, localCenter, mass, velocity, angular) {
+      const existing = this.get(objectId);
+      if (existing) {
+        existing.root = root;
+        existing.halfExtents = halfExtents;
+        existing.mass = mass;
+        this.setCenter(existing, localCenter);
+        if (velocity) existing.velocity = [...velocity];
+        existing.sleeping = false;
+        return existing;
+      }
+      const body = {
+        objectId,
+        root,
+        velocity: velocity ? [...velocity] : [0, 0, 0],
+        angularVelocity: angular ? [...angular] : [0, 0, 0],
+        halfExtents: [Math.max(0.01, halfExtents[0]), Math.max(0.01, halfExtents[1]), Math.max(0.01, halfExtents[2])],
+        mass: Math.max(0.05, mass),
+        sleeping: false,
+        held: false,
+        localCenter: [localCenter.x, localCenter.y, localCenter.z],
+        centerV: localCenter.clone(),
+        still: 0,
+        lastHit: -1,
+        onGround: false
+      };
+      this.list.push(body);
+      return body;
+    }
+    /** Move the centre of mass (after a part broke off). */
+    setCenter(b, c) {
+      b.centerV.copy(c);
+      b.localCenter = [c.x, c.y, c.z];
+    }
+    remove(objectId) {
+      const i = this.list.findIndex((b) => b.objectId === objectId);
+      if (i >= 0) this.list.splice(i, 1);
+    }
+    clear() {
+      this.list.length = 0;
+    }
+    /** World position of the centre of mass. */
+    centerOf(b, out) {
+      return out.copy(b.centerV).applyQuaternion(b.root.quaternion).add(b.root.position);
+    }
+    impulse(b, impulse, point) {
+      const inv = 1 / b.mass;
+      b.velocity[0] += impulse[0] * inv;
+      b.velocity[1] += impulse[1] * inv;
+      b.velocity[2] += impulse[2] * inv;
+      if (point) {
+        const c = this.centerOf(b, this.p);
+        const rx = point[0] - c.x;
+        const ry = point[1] - c.y;
+        const rz = point[2] - c.z;
+        const tx = ry * impulse[2] - rz * impulse[1];
+        const ty = rz * impulse[0] - rx * impulse[2];
+        const tz = rx * impulse[1] - ry * impulse[0];
+        const w = this.mulInvInertia(b, tx, ty, tz);
+        b.angularVelocity[0] += w[0];
+        b.angularVelocity[1] += w[1];
+        b.angularVelocity[2] += w[2];
+      }
+      b.sleeping = false;
+      b.still = 0;
+    }
+    /** I^-1 * (x, y, z) in world space for a box with the body's half extents and mass (needs `this.m` to hold the body's rotation). */
+    mulInvInertia(b, x, y, z) {
+      this.m.makeRotationFromQuaternion(b.root.quaternion);
+      return this.mulInvInertiaWith(b, this.m.elements, x, y, z);
+    }
+    mulInvInertiaWith(b, e, x, y, z) {
+      const [hx, hy, hz] = b.halfExtents;
+      const k = 3 / b.mass;
+      const ix = k / (hy * hy + hz * hz);
+      const iy = k / (hx * hx + hz * hz);
+      const iz = k / (hx * hx + hy * hy);
+      const lx = (e[0] * x + e[1] * y + e[2] * z) * ix;
+      const ly = (e[4] * x + e[5] * y + e[6] * z) * iy;
+      const lz = (e[8] * x + e[9] * y + e[10] * z) * iz;
+      return [e[0] * lx + e[4] * ly + e[8] * lz, e[1] * lx + e[5] * ly + e[9] * lz, e[2] * lx + e[6] * ly + e[10] * lz];
+    }
+    update(dt) {
+      this.time += dt;
+      for (const b of this.list) {
+        if (b.held) {
+          b.velocity = [0, 0, 0];
+          b.angularVelocity = [0, 0, 0];
+          b.sleeping = false;
+          b.still = 0;
+          continue;
+        }
+        if (b.sleeping) continue;
+        this.integrate(b, dt);
+      }
+      this.separate(dt);
+    }
+    integrate(b, dt) {
+      const c = this.centerOf(b, this.p);
+      const pos = [c.x, c.y, c.z];
+      const q = this.q.copy(b.root.quaternion);
+      const v = b.velocity;
+      const w = b.angularVelocity;
+      const [hx, hy, hz] = b.halfExtents;
+      const invM = 1 / b.mass;
+      const steps = clamp(Math.ceil(dt / SUB_DT), 1, 8);
+      const h = dt / steps;
+      let landing = 0;
+      let landPoint = [pos[0], pos[1], pos[2]];
+      let contactedLast = false;
+      let touched = false;
+      for (let s = 0; s < steps; s++) {
+        v[1] -= this.o.gravity * h;
+        pos[0] += v[0] * h;
+        pos[1] += v[1] * h;
+        pos[2] += v[2] * h;
+        const wl = Math.hypot(w[0], w[1], w[2]);
+        if (wl > 1e-6) {
+          this.dq.setFromAxisAngle(this.ax.set(w[0] / wl, w[1] / wl, w[2] / wl), wl * h);
+          q.premultiply(this.dq).normalize();
+        }
+        const damp = Math.exp(-0.15 * h);
+        w[0] *= damp;
+        w[1] *= damp;
+        w[2] *= damp;
+        this.m.makeRotationFromQuaternion(q);
+        const e = this.m.elements;
+        const rs = [];
+        let maxPen = 0;
+        for (let i = 0; i < 8; i++) {
+          const sx = i & 1 ? hx : -hx;
+          const sy = i & 2 ? hy : -hy;
+          const sz = i & 4 ? hz : -hz;
+          const r = [e[0] * sx + e[4] * sy + e[8] * sz, e[1] * sx + e[5] * sy + e[9] * sz, e[2] * sx + e[6] * sy + e[10] * sz];
+          const gy = this.o.groundAt(pos[0] + r[0], pos[2] + r[2]);
+          const pen = gy - (pos[1] + r[1]);
+          if (pen > -SLOP) {
+            rs.push(r);
+            if (pen > maxPen) maxPen = pen;
+          }
+        }
+        contactedLast = rs.length > 0;
+        if (contactedLast) touched = true;
+        if (!contactedLast) continue;
+        pos[1] += Math.max(0, maxPen - SLOP * 0.5);
+        let impact = 0;
+        for (const r of rs) impact = Math.max(impact, -(v[1] + w[2] * r[0] - w[0] * r[2]));
+        const restitution = impact > 2 ? 0.25 : 0;
+        if (impact > landing) {
+          landing = impact;
+          let sx = 0;
+          let sz = 0;
+          for (const r of rs) {
+            sx += r[0];
+            sz += r[2];
+          }
+          const lx = pos[0] + sx / rs.length;
+          const lz = pos[2] + sz / rs.length;
+          landPoint = [lx, this.o.groundAt(lx, lz), lz];
+        }
+        for (let it = 0; it < 4; it++) {
+          for (const r of rs) {
+            let vx = v[0] + (w[1] * r[2] - w[2] * r[1]);
+            let vy = v[1] + (w[2] * r[0] - w[0] * r[2]);
+            let vz = v[2] + (w[0] * r[1] - w[1] * r[0]);
+            const vn = vy;
+            if (vn >= 0) continue;
+            const a = this.mulInvInertiaWith(b, e, -r[2], 0, r[0]);
+            const denom = invM + (a[2] * r[0] - a[0] * r[2]);
+            const j = -(1 + (it === 0 ? restitution : 0)) * vn / denom;
+            v[1] += j * invM;
+            const dw = this.mulInvInertiaWith(b, e, -r[2] * j, 0, r[0] * j);
+            w[0] += dw[0];
+            w[1] += dw[1];
+            w[2] += dw[2];
+            vx = v[0] + (w[1] * r[2] - w[2] * r[1]);
+            vy = v[1] + (w[2] * r[0] - w[0] * r[2]);
+            vz = v[2] + (w[0] * r[1] - w[1] * r[0]);
+            const vt = Math.hypot(vx, vz);
+            if (vt > 1e-5) {
+              const tx = vx / vt;
+              const tz = vz / vt;
+              const rx = r[1] * tz;
+              const ry = r[2] * tx - r[0] * tz;
+              const rz = -r[1] * tx;
+              const at = this.mulInvInertiaWith(b, e, rx, ry, rz);
+              const cx = at[1] * r[2] - at[2] * r[1];
+              const cz = at[0] * r[1] - at[1] * r[0];
+              const denomT = invM + cx * tx + cz * tz;
+              const jt = Math.min(vt / denomT, MU * j);
+              v[0] -= tx * jt * invM;
+              v[2] -= tz * jt * invM;
+              const dwt = this.mulInvInertiaWith(b, e, rx * jt, ry * jt, rz * jt);
+              w[0] -= dwt[0];
+              w[1] -= dwt[1];
+              w[2] -= dwt[2];
+            }
+          }
+        }
+        const rd = Math.exp((rs.length >= 3 ? -3 : -1.5) * h);
+        w[0] *= rd;
+        w[1] *= rd;
+        w[2] *= rd;
+        const fd = Math.exp(-0.3 * h);
+        v[0] *= fd;
+        v[2] *= fd;
+      }
+      b.root.quaternion.copy(q);
+      const off = this.ax.copy(b.centerV).applyQuaternion(q);
+      b.root.position.set(pos[0] - off.x, pos[1] - off.y, pos[2] - off.z);
+      b.root.updateMatrixWorld(true);
+      b.onGround = contactedLast;
+      if (landing > HARD_LANDING && this.time - b.lastHit > 0.15) {
+        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;
+      if (still) {
+        b.still += dt;
+        if (b.still >= SLEEP_AFTER) {
+          b.sleeping = true;
+          v[0] = v[1] = v[2] = 0;
+          w[0] = w[1] = w[2] = 0;
+        }
+      } else {
+        b.still = 0;
+      }
+    }
+    /** Push overlapping pieces apart (horizontal bounding circles), gently, so they do not interpenetrate forever. */
+    separate(dt) {
+      const n = this.list.length;
+      if (n < 2) return;
+      const maxMove = 1.5 * dt;
+      const ca = new this.THREE.Vector3();
+      const cb = new this.THREE.Vector3();
+      for (let i = 0; i < n; i++) {
+        const a = this.list[i];
+        for (let j = i + 1; j < n; j++) {
+          const b = this.list[j];
+          if (a.held && b.held) continue;
+          if (a.sleeping && b.sleeping) continue;
+          const ra = Math.hypot(a.halfExtents[0], a.halfExtents[1], a.halfExtents[2]);
+          const rb = Math.hypot(b.halfExtents[0], b.halfExtents[1], b.halfExtents[2]);
+          this.centerOf(a, ca);
+          this.centerOf(b, cb);
+          if (Math.abs(ca.y - cb.y) > ra + rb) continue;
+          const rh = (Math.max(a.halfExtents[0], a.halfExtents[2]) + Math.max(b.halfExtents[0], b.halfExtents[2])) * 0.8;
+          let dx = cb.x - ca.x;
+          let dz = cb.z - ca.z;
+          let d = Math.hypot(dx, dz);
+          if (d >= rh) continue;
+          if (d < 1e-5) {
+            dx = 1;
+            dz = 0;
+            d = 1;
+          }
+          const push = Math.min(maxMove, (rh - d) * 0.5);
+          const wa = a.held ? 0 : b.held ? 1 : b.mass / (a.mass + b.mass);
+          const wb = b.held ? 0 : a.held ? 1 : a.mass / (a.mass + b.mass);
+          const ux = dx / (d || 1);
+          const uz = dz / (d || 1);
+          if (!a.held) {
+            a.root.position.x -= ux * push * 2 * wa;
+            a.root.position.z -= uz * push * 2 * wa;
+            a.sleeping = false;
+          }
+          if (!b.held) {
+            b.root.position.x += ux * push * 2 * wb;
+            b.root.position.z += uz * push * 2 * wb;
+            b.sleeping = false;
+          }
+        }
+      }
+    }
+  };
+
+  // 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);
+      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] };
+  };
+  var materials_default = [
+    {
+      id: "steel",
+      density: 7850,
+      hpPerKg: 400,
+      penetration: 110,
+      ductility: 0.9,
+      fracture: "none",
+      damageScale: {
+        slash: 0.1,
+        blunt: 0.8
+      },
+      hitDebris: "sparks",
+      breakDebris: "sparks",
+      ricochetDeg: 20,
+      thermal: {
+        meltC: 1450,
+        meltRate: 0.05,
+        conductivity: 0.5,
+        heatCapacity: 3
+      },
+      visual: {
+        glows: true
+      },
+      tags: [
+        "metal",
+        "conductive"
+      ],
+      compressive: 2e6
+    },
+    {
+      id: "cast_iron",
+      density: 7200,
+      hpPerKg: 150,
+      penetration: 160,
+      ductility: 0.2,
+      fracture: "snap",
+      fragmentSize: [
+        0.08,
+        0.3
+      ],
+      damageScale: {
+        slash: 0.1,
+        blunt: 1.2
+      },
+      hitDebris: "sparks",
+      breakDebris: "chips",
+      ricochetDeg: 15,
+      thermal: {
+        meltC: 1200,
+        meltRate: 0.05,
+        conductivity: 0.45,
+        heatCapacity: 3
+      },
+      visual: {
+        glows: true
+      },
+      tags: [
+        "metal",
+        "conductive"
+      ],
+      compressive: 15e5
+    },
+    {
+      id: "aluminium",
+      density: 2700,
+      hpPerKg: 250,
+      penetration: 60,
+      ductility: 0.85,
+      fracture: "none",
+      damageScale: {
+        slash: 0.2
+      },
+      hitDebris: "sparks",
+      breakDebris: "sparks",
+      ricochetDeg: 15,
+      thermal: {
+        meltC: 660,
+        meltRate: 0.06,
+        conductivity: 0.8,
+        heatCapacity: 1.5
+      },
+      visual: {
+        glows: true
+      },
+      tags: [
+        "metal",
+        "conductive"
+      ],
+      compressive: 8e5
+    },
+    {
+      id: "copper",
+      density: 8960,
+      hpPerKg: 300,
+      penetration: 70,
+      ductility: 0.95,
+      fracture: "none",
+      damageScale: {
+        slash: 0.2
+      },
+      hitDebris: "sparks",
+      breakDebris: "sparks",
+      ricochetDeg: 15,
+      thermal: {
+        meltC: 1085,
+        meltRate: 0.05,
+        conductivity: 1,
+        heatCapacity: 2.5
+      },
+      visual: {
+        glows: true
+      },
+      tags: [
+        "metal",
+        "conductive"
+      ],
+      compressive: 1e6
+    },
+    {
+      id: "wood_soft",
+      density: 500,
+      hpPerKg: 90,
+      penetration: 9,
+      ductility: 0.35,
+      fracture: "splinter",
+      fragmentSize: [
+        0.03,
+        0.15
+      ],
+      damageScale: {
+        blunt: 1.2,
+        slash: 1.5
+      },
+      hitDebris: "splinters",
+      breakDebris: "splinters",
+      thermal: {
+        ignitionC: 300,
+        flameC: 800,
+        fuelFraction: 0.9,
+        burnRate: 0.012,
+        conductivity: 0.05,
+        heatCapacity: 1.2,
+        smoke: "grey"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "wood",
+        "organic",
+        "flammable"
+      ],
+      compressive: 1e5
+    },
+    {
+      id: "wood_hard",
+      density: 750,
+      hpPerKg: 140,
+      penetration: 14,
+      ductility: 0.3,
+      fracture: "splinter",
+      fragmentSize: [
+        0.03,
+        0.2
+      ],
+      damageScale: {
+        slash: 1.2
+      },
+      hitDebris: "splinters",
+      breakDebris: "splinters",
+      thermal: {
+        ignitionC: 330,
+        flameC: 800,
+        fuelFraction: 0.9,
+        burnRate: 0.01,
+        conductivity: 0.06,
+        heatCapacity: 1.4,
+        smoke: "grey"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "wood",
+        "organic",
+        "flammable"
+      ],
+      compressive: 15e4
+    },
+    {
+      id: "plywood",
+      density: 600,
+      hpPerKg: 70,
+      penetration: 7,
+      ductility: 0.3,
+      fracture: "snap",
+      fragmentSize: [
+        0.1,
+        0.4
+      ],
+      damageScale: {
+        slash: 1.3
+      },
+      hitDebris: "splinters",
+      breakDebris: "splinters",
+      thermal: {
+        ignitionC: 300,
+        flameC: 800,
+        fuelFraction: 0.85,
+        burnRate: 0.013,
+        conductivity: 0.05,
+        heatCapacity: 1.2,
+        smoke: "grey"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "wood",
+        "organic",
+        "flammable"
+      ],
+      compressive: 6e4
+    },
+    {
+      id: "mdf",
+      density: 750,
+      hpPerKg: 45,
+      penetration: 6,
+      ductility: 0.15,
+      fracture: "snap",
+      fragmentSize: [
+        0.08,
+        0.35
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        ignitionC: 290,
+        flameC: 750,
+        fuelFraction: 0.85,
+        burnRate: 0.014,
+        conductivity: 0.05,
+        heatCapacity: 1.2,
+        smoke: "grey"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "wood",
+        "organic",
+        "flammable"
+      ],
+      compressive: 3e4
+    },
+    {
+      id: "glass",
+      density: 2500,
+      hpPerKg: 12,
+      penetration: 6,
+      ductility: 0.02,
+      fracture: "shatter",
+      fragmentSize: [
+        0.05,
+        0.25
+      ],
+      damageScale: {
+        blunt: 1.5
+      },
+      hitDebris: "shards",
+      breakDebris: "shards",
+      ricochetDeg: 8,
+      thermal: {
+        meltC: 1400,
+        meltRate: 0.03,
+        conductivity: 0.1,
+        heatCapacity: 1.5,
+        thermalShockC: 150
+      },
+      visual: {
+        glows: true,
+        transparent: true
+      },
+      tags: [
+        "glass",
+        "brittle"
+      ],
+      compressive: 1e5
+    },
+    {
+      id: "tempered_glass",
+      density: 2500,
+      hpPerKg: 30,
+      penetration: 9,
+      ductility: 0.02,
+      fracture: "crumble",
+      fragmentSize: [
+        6e-3,
+        0.02
+      ],
+      hitDebris: "shards",
+      breakDebris: "shards",
+      ricochetDeg: 8,
+      thermal: {
+        meltC: 1400,
+        meltRate: 0.03,
+        conductivity: 0.1,
+        heatCapacity: 1.5,
+        thermalShockC: 250
+      },
+      visual: {
+        glows: true,
+        transparent: true
+      },
+      tags: [
+        "glass",
+        "brittle"
+      ],
+      compressive: 2e5
+    },
+    {
+      id: "ceramic",
+      density: 2400,
+      hpPerKg: 25,
+      penetration: 12,
+      ductility: 0.02,
+      fracture: "shatter",
+      fragmentSize: [
+        0.03,
+        0.12
+      ],
+      damageScale: {
+        blunt: 1.3
+      },
+      hitDebris: "chips",
+      breakDebris: "shards",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 1.5,
+        thermalShockC: 200
+      },
+      tags: [
+        "ceramic",
+        "brittle"
+      ],
+      compressive: 15e4
+    },
+    {
+      id: "concrete",
+      density: 2300,
+      hpPerKg: 14,
+      penetration: 18,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.05,
+        0.25
+      ],
+      damageScale: {
+        explosive: 1.2
+      },
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 444e3
+    },
+    {
+      id: "brick",
+      density: 1900,
+      hpPerKg: 12,
+      penetration: 14,
+      ductility: 0.05,
+      fracture: "crumble",
+      fragmentSize: [
+        0.04,
+        0.12
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 4e4
+    },
+    {
+      id: "plaster",
+      density: 850,
+      hpPerKg: 18,
+      penetration: 3,
+      ductility: 0.05,
+      fracture: "crumble",
+      fragmentSize: [
+        0.05,
+        0.3
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 1.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 8e3
+    },
+    {
+      id: "stone",
+      density: 2700,
+      hpPerKg: 25,
+      penetration: 25,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.06,
+        0.3
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.2,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 3e5
+    },
+    {
+      id: "plastic",
+      density: 1100,
+      hpPerKg: 60,
+      penetration: 8,
+      ductility: 0.5,
+      fracture: "snap",
+      fragmentSize: [
+        0.05,
+        0.3
+      ],
+      hitDebris: "chips",
+      breakDebris: "chips",
+      thermal: {
+        ignitionC: 400,
+        flameC: 700,
+        fuelFraction: 0.8,
+        burnRate: 0.02,
+        meltC: 200,
+        meltRate: 0.06,
+        conductivity: 0.05,
+        heatCapacity: 1,
+        smoke: "black"
+      },
+      visual: {
+        charColor: 855309
+      },
+      tags: [
+        "plastic",
+        "flammable"
+      ],
+      compressive: 4e4
+    },
+    {
+      id: "rubber",
+      density: 1100,
+      hpPerKg: 80,
+      penetration: 12,
+      ductility: 0.9,
+      fracture: "tear",
+      fragmentSize: [
+        0.05,
+        0.2
+      ],
+      hitDebris: "chips",
+      breakDebris: "fibers",
+      thermal: {
+        ignitionC: 350,
+        flameC: 750,
+        fuelFraction: 0.6,
+        burnRate: 0.015,
+        conductivity: 0.05,
+        heatCapacity: 1.2,
+        smoke: "black"
+      },
+      visual: {
+        charColor: 855309
+      },
+      tags: [
+        "rubber",
+        "flammable"
+      ],
+      compressive: 2e4
+    },
+    {
+      id: "fabric",
+      density: 400,
+      hpPerKg: 20,
+      penetration: 0.8,
+      ductility: 0.8,
+      fracture: "tear",
+      fragmentSize: [
+        0.05,
+        0.25
+      ],
+      damageScale: {
+        slash: 4,
+        ballistic: 0.5
+      },
+      hitDebris: "fibers",
+      breakDebris: "fibers",
+      thermal: {
+        ignitionC: 230,
+        flameC: 600,
+        fuelFraction: 1,
+        burnRate: 0.05,
+        conductivity: 0.03,
+        heatCapacity: 0.6,
+        smoke: "grey"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "fabric",
+        "organic",
+        "flammable"
+      ],
+      compressive: 500
+    },
+    {
+      id: "foam",
+      density: 30,
+      hpPerKg: 15,
+      penetration: 0.5,
+      ductility: 0.7,
+      fracture: "tear",
+      fragmentSize: [
+        0.03,
+        0.15
+      ],
+      damageScale: {
+        slash: 2,
+        ballistic: 0.4
+      },
+      hitDebris: "fibers",
+      breakDebris: "fibers",
+      thermal: {
+        ignitionC: 250,
+        flameC: 900,
+        fuelFraction: 0.95,
+        burnRate: 0.09,
+        conductivity: 0.02,
+        heatCapacity: 0.5,
+        smoke: "black"
+      },
+      visual: {
+        charColor: 855309
+      },
+      tags: [
+        "fabric",
+        "flammable"
+      ],
+      compressive: 100
+    },
+    {
+      id: "leather",
+      density: 900,
+      hpPerKg: 50,
+      penetration: 4,
+      ductility: 0.8,
+      fracture: "tear",
+      fragmentSize: [
+        0.05,
+        0.25
+      ],
+      damageScale: {
+        slash: 2
+      },
+      hitDebris: "fibers",
+      breakDebris: "fibers",
+      thermal: {
+        ignitionC: 320,
+        flameC: 650,
+        fuelFraction: 0.7,
+        burnRate: 0.01,
+        conductivity: 0.05,
+        heatCapacity: 1,
+        smoke: "grey"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "fabric",
+        "organic",
+        "flammable"
+      ],
+      compressive: 2e3
+    },
+    {
+      id: "paper",
+      density: 700,
+      hpPerKg: 8,
+      penetration: 0.3,
+      ductility: 0.5,
+      fracture: "tear",
+      fragmentSize: [
+        0.03,
+        0.15
+      ],
+      damageScale: {
+        slash: 3
+      },
+      hitDebris: "fibers",
+      breakDebris: "fibers",
+      thermal: {
+        ignitionC: 230,
+        flameC: 600,
+        fuelFraction: 1,
+        burnRate: 0.06,
+        conductivity: 0.03,
+        heatCapacity: 0.5,
+        smoke: "grey"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "fabric",
+        "organic",
+        "flammable"
+      ],
+      compressive: 500
+    },
+    {
+      id: "foliage",
+      density: 150,
+      hpPerKg: 20,
+      penetration: 0.5,
+      ductility: 0.6,
+      fracture: "tear",
+      fragmentSize: [
+        0.03,
+        0.1
+      ],
+      damageScale: {
+        slash: 4
+      },
+      hitDebris: "leaves",
+      breakDebris: "leaves",
+      thermal: {
+        ignitionC: 300,
+        flameC: 700,
+        fuelFraction: 0.8,
+        burnRate: 0.08,
+        conductivity: 0.03,
+        heatCapacity: 0.8,
+        smoke: "white"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "plant",
+        "organic",
+        "flammable"
+      ],
+      compressive: 500
+    },
+    {
+      id: "green_wood",
+      density: 650,
+      hpPerKg: 120,
+      penetration: 10,
+      ductility: 0.5,
+      fracture: "splinter",
+      fragmentSize: [
+        0.03,
+        0.2
+      ],
+      damageScale: {
+        slash: 1.3
+      },
+      hitDebris: "splinters",
+      breakDebris: "leaves",
+      thermal: {
+        ignitionC: 400,
+        flameC: 700,
+        fuelFraction: 0.8,
+        burnRate: 6e-3,
+        conductivity: 0.06,
+        heatCapacity: 2,
+        smoke: "white"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "plant",
+        "wood",
+        "organic",
+        "flammable"
+      ],
+      compressive: 6e4
+    },
+    {
+      id: "cactus",
+      density: 900,
+      hpPerKg: 30,
+      penetration: 2,
+      ductility: 0.6,
+      fracture: "tear",
+      fragmentSize: [
+        0.04,
+        0.15
+      ],
+      damageScale: {
+        slash: 3
+      },
+      hitDebris: "fibers",
+      breakDebris: "fibers",
+      thermal: {
+        ignitionC: 450,
+        flameC: 650,
+        fuelFraction: 0.3,
+        burnRate: 0.01,
+        conductivity: 0.05,
+        heatCapacity: 3,
+        smoke: "white"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "plant",
+        "organic",
+        "flammable"
+      ],
+      compressive: 5e3
+    },
+    {
+      id: "flesh_fruit",
+      density: 950,
+      hpPerKg: 15,
+      penetration: 1.5,
+      ductility: 0.7,
+      fracture: "tear",
+      fragmentSize: [
+        0.02,
+        0.08
+      ],
+      damageScale: {
+        slash: 2
+      },
+      hitDebris: "drips",
+      breakDebris: "drips",
+      thermal: {
+        conductivity: 0.05,
+        heatCapacity: 3
+      },
+      tags: [
+        "plant",
+        "organic"
+      ],
+      compressive: 1e3
+    },
+    {
+      id: "wax",
+      density: 900,
+      hpPerKg: 30,
+      penetration: 3,
+      ductility: 0.5,
+      fracture: "snap",
+      fragmentSize: [
+        0.05,
+        0.2
+      ],
+      hitDebris: "chips",
+      breakDebris: "chips",
+      thermal: {
+        ignitionC: 230,
+        flameC: 700,
+        fuelFraction: 0.9,
+        burnRate: 0.02,
+        meltC: 60,
+        meltRate: 0.2,
+        conductivity: 0.05,
+        heatCapacity: 0.8,
+        smoke: "grey"
+      },
+      tags: [
+        "wax",
+        "flammable"
+      ],
+      compressive: 5e3
+    },
+    {
+      id: "soil",
+      density: 1300,
+      hpPerKg: 3,
+      penetration: 5,
+      ductility: 0.3,
+      fracture: "crumble",
+      fragmentSize: [
+        0.03,
+        0.12
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "soil",
+        "masonry"
+      ],
+      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 });
+      }
+    }
+    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);
+          }
+        }
+      }
+      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);
+    return { spec, parts: meshesOf };
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map