@adatechnology/game-destruction 0.0.0-stage → 0.1.1

package/dist/index.global.js

@@ -0,0 +1,3166 @@
+"use strict";
+var GameDestruction = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  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);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    IMPACT_CONTRACT: () => IMPACT_CONTRACT,
+    JOINT_BY_MATERIALS: () => JOINT_BY_MATERIALS,
+    JOINT_DEFAULTS: () => JOINT_DEFAULTS,
+    MATERIALS: () => MATERIALS,
+    buildFrame: () => buildFrame,
+    checkDestructible: () => checkDestructible2,
+    checkHit: () => checkHit,
+    createDestruction: () => createDestruction,
+    fragility: () => fragility,
+    guessMaterial: () => guessMaterial,
+    inferJoints: () => inferJoints,
+    locales: () => locales,
+    partCapacity: () => partCapacity,
+    partMass: () => partMass,
+    partThickness: () => partThickness,
+    partVolume: () => partVolume,
+    quat: () => quat,
+    quatFromEuler: () => quatFromEuler,
+    resolveStrings: () => resolveStrings,
+    rotateVec: () => rotateVec,
+    toLocal: () => toLocal,
+    toWorld: () => toWorld,
+    vec: () => vec
+  });
+
+  // src/math.ts
+  var EPS = 1e-9;
+  var vec = {
+    add: (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]],
+    sub: (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]],
+    scale: (a, s) => [a[0] * s, a[1] * s, a[2] * s],
+    dot: (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2],
+    cross: (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]],
+    length: (a) => Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]),
+    distance: (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]),
+    normalize: (a, fallback = [0, 1, 0]) => {
+      const l = Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
+      return l < EPS ? [fallback[0], fallback[1], fallback[2]] : [a[0] / l, a[1] / l, a[2] / l];
+    },
+    lerp: (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t],
+    /** `a + b * s` */
+    madd: (a, b, s) => [a[0] + b[0] * s, a[1] + b[1] * s, a[2] + b[2] * s]
+  };
+  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 rotateVec = (q, v) => {
+    const qx = q[0], qy = q[1], qz = q[2], qw = q[3];
+    const tx = 2 * (qy * v[2] - qz * v[1]);
+    const ty = 2 * (qz * v[0] - qx * v[2]);
+    const tz = 2 * (qx * v[1] - qy * v[0]);
+    return [v[0] + qw * tx + (qy * tz - qz * ty), v[1] + qw * ty + (qz * tx - qx * tz), v[2] + qw * tz + (qx * ty - qy * tx)];
+  };
+  var toLocal = (position, rotation, p) => rotateVec([-rotation[0], -rotation[1], -rotation[2], rotation[3]], [p[0] - position[0], p[1] - position[1], p[2] - position[2]]);
+  var toWorld = (position, rotation, p) => {
+    const r = rotateVec(rotation, p);
+    return [r[0] + position[0], r[1] + position[1], r[2] + position[2]];
+  };
+  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 shapeBound = (s) => {
+    if (s.kind === "box") return 0.5 * Math.hypot(s.size[0], s.size[1], s.size[2]);
+    if (s.kind === "cylinder") return Math.hypot(s.radius, s.height / 2);
+    return s.radius;
+  };
+  var shapeArea = (s) => {
+    if (s.kind === "box") return 2 * (s.size[0] * s.size[1] + s.size[1] * s.size[2] + s.size[0] * s.size[2]);
+    if (s.kind === "cylinder") return 2 * Math.PI * s.radius * s.height + 2 * Math.PI * s.radius * s.radius;
+    return 4 * Math.PI * s.radius * s.radius;
+  };
+  var rayShape = (s, o, d) => {
+    if (s.kind === "box") {
+      let tmin = -Infinity, tmax = Infinity;
+      let a0 = 0, a1 = 0, s0 = 1, s1 = 1;
+      for (let i = 0; i < 3; i++) {
+        const h = s.size[i] / 2;
+        if (Math.abs(d[i]) < EPS) {
+          if (Math.abs(o[i]) > h) return null;
+          continue;
+        }
+        let ta = (-h - o[i]) / d[i];
+        let tb = (h - o[i]) / d[i];
+        let sa = -1, sb = 1;
+        if (ta > tb) {
+          const t = ta;
+          ta = tb;
+          tb = t;
+          sa = 1;
+          sb = -1;
+        }
+        if (ta > tmin) {
+          tmin = ta;
+          a0 = i;
+          s0 = sa;
+        }
+        if (tb < tmax) {
+          tmax = tb;
+          a1 = i;
+          s1 = sb;
+        }
+        if (tmin > tmax) return null;
+      }
+      if (tmax < 0 || !Number.isFinite(tmin) || !Number.isFinite(tmax)) return null;
+      const n02 = [0, 0, 0];
+      const n12 = [0, 0, 0];
+      n02[a0] = s0;
+      n12[a1] = s1;
+      return { t0: tmin, n0: n02, t1: tmax, n1: n12 };
+    }
+    if (s.kind === "sphere") {
+      const b = vec.dot(o, d);
+      const a2 = vec.dot(d, d);
+      const c2 = vec.dot(o, o) - s.radius * s.radius;
+      const disc = b * b - a2 * c2;
+      if (disc < 0) return null;
+      const sq = Math.sqrt(disc);
+      const t02 = (-b - sq) / a2;
+      const t12 = (-b + sq) / a2;
+      if (t12 < 0) return null;
+      const p0 = vec.madd(o, d, t02);
+      const p1 = vec.madd(o, d, t12);
+      return { t0: t02, n0: vec.normalize(p0), t1: t12, n1: vec.normalize(p1) };
+    }
+    const r = s.radius;
+    const hh = s.height / 2;
+    const a = d[0] * d[0] + d[2] * d[2];
+    const c = o[0] * o[0] + o[2] * o[2] - r * r;
+    let tA = -Infinity, tB = Infinity;
+    if (a > EPS) {
+      const b = o[0] * d[0] + o[2] * d[2];
+      const disc = b * b - a * c;
+      if (disc < 0) return null;
+      const sq = Math.sqrt(disc);
+      tA = (-b - sq) / a;
+      tB = (-b + sq) / a;
+    } else if (c > 0) return null;
+    let yA = -Infinity, yB = Infinity;
+    if (Math.abs(d[1]) > EPS) {
+      yA = (-hh - o[1]) / d[1];
+      yB = (hh - o[1]) / d[1];
+      if (yA > yB) {
+        const t = yA;
+        yA = yB;
+        yB = t;
+      }
+    } else if (Math.abs(o[1]) > hh) return null;
+    const t0 = Math.max(tA, yA);
+    const t1 = Math.min(tB, yB);
+    if (t0 > t1 || t1 < 0 || !Number.isFinite(t0) || !Number.isFinite(t1)) return null;
+    const normalAt = (t, fromSide, sign) => {
+      if (fromSide) {
+        const p = vec.madd(o, d, t);
+        return vec.normalize([p[0], 0, p[2]], [1, 0, 0]);
+      }
+      return [0, sign, 0];
+    };
+    const n0 = normalAt(t0, tA >= yA, d[1] > 0 ? -1 : 1);
+    const n1 = normalAt(t1, tB <= yB, d[1] > 0 ? 1 : -1);
+    return { t0, n0, t1, n1 };
+  };
+  var distanceToShape = (s, p) => {
+    if (s.kind === "box") {
+      const dx = Math.max(Math.abs(p[0]) - s.size[0] / 2, 0);
+      const dy2 = Math.max(Math.abs(p[1]) - s.size[1] / 2, 0);
+      const dz = Math.max(Math.abs(p[2]) - s.size[2] / 2, 0);
+      return Math.hypot(dx, dy2, dz);
+    }
+    if (s.kind === "sphere") return Math.max(0, vec.length(p) - s.radius);
+    const dr = Math.max(0, Math.hypot(p[0], p[2]) - s.radius);
+    const dy = Math.max(0, Math.abs(p[1]) - s.height / 2);
+    return Math.hypot(dr, dy);
+  };
+  var surfacePoint = (s, p) => {
+    if (s.kind === "box") {
+      const h = [s.size[0] / 2, s.size[1] / 2, s.size[2] / 2];
+      const inside2 = Math.abs(p[0]) <= h[0] && Math.abs(p[1]) <= h[1] && Math.abs(p[2]) <= h[2];
+      if (!inside2) {
+        const c = [Math.max(-h[0], Math.min(h[0], p[0])), Math.max(-h[1], Math.min(h[1], p[1])), Math.max(-h[2], Math.min(h[2], p[2]))];
+        return { point: c, normal: vec.normalize(vec.sub(p, c)) };
+      }
+      let axis = 0;
+      let best = Infinity;
+      for (let i = 0; i < 3; i++) {
+        const g = h[i] - Math.abs(p[i]);
+        if (g < best) {
+          best = g;
+          axis = i;
+        }
+      }
+      const sign2 = p[axis] >= 0 ? 1 : -1;
+      const point = [p[0], p[1], p[2]];
+      point[axis] = sign2 * h[axis];
+      const normal = [0, 0, 0];
+      normal[axis] = sign2;
+      return { point, normal };
+    }
+    if (s.kind === "sphere") {
+      const n = vec.normalize(p);
+      return { point: vec.scale(n, s.radius), normal: n };
+    }
+    const rho = Math.hypot(p[0], p[2]);
+    const hh = s.height / 2;
+    const inside = rho <= s.radius && Math.abs(p[1]) <= hh;
+    if (!inside) {
+      const k = rho > s.radius ? s.radius / rho : 1;
+      const c = [p[0] * k, Math.max(-hh, Math.min(hh, p[1])), p[2] * k];
+      return { point: c, normal: vec.normalize(vec.sub(p, c)) };
+    }
+    if (s.radius - rho < hh - Math.abs(p[1])) {
+      const k = rho < EPS ? 0 : s.radius / rho;
+      const point = rho < EPS ? [s.radius, p[1], 0] : [p[0] * k, p[1], p[2] * k];
+      return { point, normal: vec.normalize([point[0], 0, point[2]], [1, 0, 0]) };
+    }
+    const sign = p[1] >= 0 ? 1 : -1;
+    return { point: [p[0], sign * hh, p[2]], normal: [0, sign, 0] };
+  };
+  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 createRng = (seed) => {
+    let s = seed | 0;
+    return {
+      next() {
+        s = s + 1831565813 | 0;
+        let t = Math.imul(s ^ s >>> 15, 1 | s);
+        t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+        return ((t ^ t >>> 14) >>> 0) / 4294967296;
+      },
+      state: () => s,
+      set(v) {
+        s = v | 0;
+      }
+    };
+  };
+
+  // src/fracture.ts
+  var bsp = (root, count, axes, rnd) => {
+    const pieces = [root];
+    const vol = (b) => axes.reduce((v, a) => v * b.s[a], 1);
+    while (pieces.length < count) {
+      let bi = 0;
+      for (let i = 1; i < pieces.length; i++) if (vol(pieces[i]) > vol(pieces[bi])) bi = i;
+      const b = pieces[bi];
+      let ax = axes[0];
+      for (const a of axes) if (b.s[a] > b.s[ax]) ax = a;
+      if (b.s[ax] < 1e-4) break;
+      const r = 0.3 + 0.4 * rnd();
+      const l1 = b.s[ax] * r;
+      const l2 = b.s[ax] - l1;
+      const c1 = [b.c[0], b.c[1], b.c[2]];
+      const c2 = [b.c[0], b.c[1], b.c[2]];
+      c1[ax] = b.c[ax] - b.s[ax] / 2 + l1 / 2;
+      c2[ax] = b.c[ax] + b.s[ax] / 2 - l2 / 2;
+      const s1 = [b.s[0], b.s[1], b.s[2]];
+      const s2 = [b.s[0], b.s[1], b.s[2]];
+      s1[ax] = l1;
+      s2[ax] = l2;
+      pieces[bi] = { c: c1, s: s1 };
+      pieces.push({ c: c2, s: s2 });
+    }
+    return pieces;
+  };
+  var parity = (p) => {
+    let inv = 0;
+    for (let i = 0; i < 3; i++) for (let j = i + 1; j < 3; j++) if (p[i] > p[j]) inv++;
+    return inv % 2 === 0 ? 1 : -1;
+  };
+  var frame = (ax, ay, az, angle = 0) => {
+    const e = (i) => [i === 0 ? 1 : 0, i === 1 ? 1 : 0, i === 2 ? 1 : 0];
+    const z = e(az);
+    const sg = parity([ax, ay, az]);
+    const q = quat.fromColumns(e(ax), e(ay), [z[0] * sg, z[1] * sg, z[2] * sg]);
+    return angle === 0 ? q : quat.mul(q, quat.fromAxisAngle([0, 0, 1], angle));
+  };
+  var clamp = (v, a, b) => Math.max(a, Math.min(b, v));
+  var planFragments = (inp) => {
+    const { style, dims, rnd, maxFragments } = inp;
+    const [fmin, fmax] = inp.fragmentSize;
+    const mean = (fmin + fmax) / 2;
+    const root = { c: [0, 0, 0], s: [dims[0], dims[1], dims[2]] };
+    const idq = quat.identity();
+    const out = [];
+    const sorted = [0, 1, 2].sort((a, b) => dims[a] - dims[b]);
+    const t = sorted[0];
+    const [u, v] = [sorted[1], sorted[2]].sort((a, b) => a - b);
+    if (style === "snap") {
+      const n2 = Math.min(maxFragments, 2 + Math.floor(rnd() * 3));
+      for (const b of bsp(root, n2, [0, 1, 2], rnd)) out.push({ center: b.c, size: b.s, q: idq, shape: "slab", weight: b.s[0] * b.s[1] * b.s[2] });
+      return out;
+    }
+    if (style === "crumble" || style === "none") {
+      const n2 = clamp(Math.ceil(dims[0] * dims[1] * dims[2] / (mean * mean * mean)), 4, maxFragments);
+      for (const b of bsp(root, n2, [0, 1, 2], rnd)) out.push({ center: b.c, size: b.s, q: idq, shape: "chunk", weight: b.s[0] * b.s[1] * b.s[2] });
+      return out;
+    }
+    if (style === "splinter") {
+      const g = inp.grain ?? [0, 1, 2].sort((a2, b2) => dims[b2] - dims[a2])[0];
+      const [a, b] = [0, 1, 2].filter((i) => i !== g);
+      const w = Math.max(fmin * 1.5, 0.01);
+      const c = clamp(Math.round(dims[a] * dims[b] / (w * w)), 3, Math.max(3, Math.floor(maxFragments / 2)));
+      const maxLen = fmax * 4;
+      const cells = bsp(root, c, [a, b], rnd);
+      const pieces = [];
+      for (const cell of cells) {
+        let list = [cell];
+        const extra = rnd() < 0.4 ? 1 : 0;
+        const k = Math.max(1, Math.ceil(dims[g] / maxLen)) + extra;
+        list = bsp(cell, k, [g], rnd);
+        for (const p of list) pieces.push(p);
+      }
+      for (const p of pieces.slice(0, maxFragments)) {
+        out.push({ center: p.c, size: [p.s[g], p.s[a], p.s[b]], q: frame(g, a, b), shape: "splinter", weight: p.s[0] * p.s[1] * p.s[2] });
+      }
+      return out;
+    }
+    if (style === "tear") {
+      const n2 = clamp(Math.round(dims[u] * dims[v] / (mean * mean)), 3, maxFragments);
+      const th2 = Math.min(inp.thickness, dims[t]);
+      for (const b of bsp(root, n2, [u, v], rnd)) {
+        out.push({ center: [b.c[0], b.c[1], b.c[2]], size: [b.s[u], b.s[v], th2], q: frame(u, v, t), shape: "scrap", weight: b.s[u] * b.s[v] });
+      }
+      return out;
+    }
+    const th = Math.min(inp.thickness, dims[t]);
+    const Hu = dims[u] / 2, Hv = dims[v] / 2;
+    const hu = clamp(inp.hit[u], -Hu * 0.95, Hu * 0.95);
+    const hv = clamp(inp.hit[v], -Hv * 0.95, Hv * 0.95);
+    const R = Math.max(Math.hypot(Hu + Math.abs(hu), Hv + Math.abs(hv)), 0.02);
+    const n = clamp(Math.round(dims[u] * dims[v] / (mean * mean)), 6, maxFragments);
+    const sectors = clamp(Math.round(Math.sqrt(n * 1.6)), 5, 10);
+    const rings = Math.max(1, Math.ceil(n / sectors));
+    const radii = [];
+    for (let k = 0; k <= rings; k++) radii.push(R * Math.pow(k / rings, 1.3));
+    const cap = fmax * 1.5;
+    for (let j = 0; j < sectors && out.length < maxFragments; j++) {
+      const theta = (j + (rnd() - 0.5) * 0.4) * (Math.PI * 2 / sectors);
+      for (let k = 0; k < rings && out.length < maxFragments; k++) {
+        const rm = (radii[k] + radii[k + 1]) / 2;
+        const cu = hu + rm * Math.cos(theta);
+        const cv = hv + rm * Math.sin(theta);
+        if (Math.abs(cu) > Hu + 0.01 || Math.abs(cv) > Hv + 0.01) continue;
+        const radial = clamp(radii[k + 1] - radii[k], 0.01, cap);
+        const tang = clamp(radii[k + 1] * (Math.PI * 2 / sectors) * 0.9, 0.01, cap);
+        const c = [0, 0, 0];
+        c[u] = clamp(cu, -Hu * 0.98, Hu * 0.98);
+        c[v] = clamp(cv, -Hv * 0.98, Hv * 0.98);
+        c[t] = 0;
+        out.push({ center: c, size: [radial, tang, th], q: frame(u, v, t, theta), shape: "shard", weight: radial * tang });
+      }
+    }
+    if (out.length === 0) out.push({ center: [0, 0, 0], size: [dims[u], dims[v], th], q: frame(u, v, t), shape: "shard", weight: 1 });
+    return out;
+  };
+
+  // src/data/materials.json
+  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: 5,
+      penetration: 10,
+      ductility: 0.5,
+      fracture: "splinter",
+      fragmentSize: [
+        0.03,
+        0.2
+      ],
+      damageScale: {
+        slash: 1.3,
+        ballistic: 0.1
+      },
+      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
+    }
+  ];
+
+  // src/data/material-hints.json
+  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"
+  };
+
+  // src/materials.ts
+  var MATERIALS = materials_default;
+  var JOINT_DEFAULTS = {
+    screw: { strength: 80, tools: ["screwdriver"], seconds: 2.5 },
+    bolt: { strength: 200, tools: ["wrench"], seconds: 4 },
+    nail: { strength: 60, tools: ["pry_bar", "hammer"], seconds: 2 },
+    weld: { strength: 600, tools: ["cutting_torch", "saw"], seconds: 8 },
+    glue: { strength: 50, tools: ["pry_bar", "knife"], seconds: 3 },
+    hinge: { strength: 120, tools: ["screwdriver"], seconds: 3 },
+    clip: { strength: 20, tools: ["hand"], seconds: 0.6 },
+    tie: { strength: 15, tools: ["knife", "hand"], seconds: 1 },
+    mortar: { strength: 400, tools: ["hammer"], seconds: 6 },
+    fused: { strength: 1e3, tools: [], seconds: 0 },
+    stem: { strength: 40, tools: ["knife", "saw", "hand"], seconds: 1.5 },
+    rebar: { strength: 1500, tools: ["cutting_torch", "saw"], seconds: 20 },
+    resting: { strength: 30, tools: ["hand"], seconds: 1 }
+  };
+  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 partVolume = (shape) => {
+    if (shape.kind === "box") return shape.size[0] * shape.size[1] * shape.size[2];
+    if (shape.kind === "cylinder") return Math.PI * shape.radius * shape.radius * shape.height;
+    return 4 / 3 * Math.PI * shape.radius ** 3;
+  };
+  var partMass = (part, material) => part.mass ?? material.density * partVolume(part.shape) * (part.fill ?? 1);
+  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;
+  };
+  var partCapacity = (part, material) => {
+    if (part.structure?.capacity !== void 0) return part.structure.capacity;
+    const d = shapeDims(part.shape).sort((a, b) => a - b);
+    const role = part.structure?.role;
+    const sh = shapeDims(part.shape);
+    const section = role === "wall" || role === "partition" ? Math.min(sh[0], sh[2]) * Math.max(sh[0], sh[2]) : role === "slab" ? d[0] * d[2] : d[0] * d[1];
+    return Math.max(1, section * (material.compressive ?? 2e4) * (role === "foundation" ? 10 : 1));
+  };
+  var fragility = (ductility, thickness) => {
+    if (ductility >= 0.3) return 1;
+    return (1 + 4 * (0.3 - ductility) / 0.3) * Math.min(25, Math.max(1, (0.02 / Math.max(thickness, 1e-4)) ** 2));
+  };
+
+  // src/world.ts
+  var DMG_PER_J = 0.02;
+  var BLAST_COUPLING = 0.1;
+  var FLAMMABLE_FLUIDS = ["gas", "fuel"];
+  var clamp2 = (v, a, b) => Math.max(a, Math.min(b, v));
+  var isLost = (p) => p.st.status === "broken" || p.st.status === "melted" || p.st.status === "ashes";
+  var clone = (v) => structuredClone(v);
+  var updateBound = (o) => {
+    if (!o.parts.length) return;
+    const c = [0, 0, 0];
+    for (const p of o.parts) for (let k = 0; k < 3; k++) c[k] += p.pos[k] / o.parts.length;
+    let r = 0;
+    for (const p of o.parts) r = Math.max(r, vec.distance(c, p.pos) + p.bound);
+    o.bc = c;
+    o.br = r;
+  };
+  var AXIS = { x: 0, y: 1, z: 2 };
+  var createDestruction = (options = {}) => {
+    const materials = /* @__PURE__ */ new Map();
+    for (const m of MATERIALS) materials.set(m.id, m);
+    for (const m of options.materials ?? []) materials.set(m.id, m);
+    const ambient = options.ambientC ?? 20;
+    const maxFragments = options.maxFragments ?? 24;
+    const maxDents = options.maxDents ?? 24;
+    const maxHoles = options.maxHoles ?? 32;
+    const fireSpread = options.fireSpread ?? 0.6;
+    const rng = createRng(options.seed ?? 1);
+    const rnd = () => rng.next();
+    let time = 0;
+    let counter = 0;
+    const objects = /* @__PURE__ */ new Map();
+    const listeners = /* @__PURE__ */ new Map();
+    let cur = [];
+    const blasts = [];
+    const impls = /* @__PURE__ */ new Map();
+    const taken = (id) => objects.has(id) || impls.has(id);
+    const emit = (e) => {
+      cur.push(e);
+      options.onEvent?.(e);
+      const all = listeners.get("*");
+      if (all) for (const fn of [...all]) fn(e);
+      const typed = listeners.get(e.type);
+      if (typed) for (const fn of [...typed]) fn(e);
+    };
+    const base = (o, source) => source === void 0 ? { object: o.id, time } : { object: o.id, time, source };
+    const pendingCollapse = /* @__PURE__ */ new Map();
+    let runDepth = 0;
+    const run = (fn) => {
+      const prev = cur;
+      const mine = [];
+      cur = mine;
+      runDepth++;
+      try {
+        const value = fn();
+        let guard = 0;
+        while (blasts.length && guard++ < 64) {
+          const b = blasts.shift();
+          blastWorld(b.point, b.energy, b.radius, b.source);
+        }
+        if (runDepth === 1) flushCollapse();
+        return { value, events: mine };
+      } finally {
+        runDepth--;
+        cur = prev;
+      }
+    };
+    const nextId = () => {
+      let id;
+      do
+        id = `obj_${++counter}`;
+      while (taken(id));
+      return id;
+    };
+    const freshRuntime = () => ({ meltEmitted: 0, dripT: 0, prevTemp: ambient, shockT: 0, jet: false });
+    const resolveSpec = (spec) => {
+      const out = clone(spec);
+      const joints = out.joints ?? inferJoints(out.parts, 0.01, materials);
+      const structural = (id) => {
+        const role = out.parts.find((p) => p.id === id)?.structure?.role;
+        return role !== void 0 && role !== "none";
+      };
+      out.joints = joints.map((j) => {
+        const def = JOINT_DEFAULTS[j.kind];
+        return {
+          id: j.id ?? `${j.a}~${j.b}`,
+          a: j.a,
+          b: j.b,
+          kind: j.kind,
+          strength: j.strength ?? def.strength,
+          tools: j.tools ?? [...def.tools],
+          seconds: j.seconds ?? def.seconds,
+          bears: j.bears ?? (structural(j.a) && structural(j.b))
+        };
+      });
+      return out;
+    };
+    const build = (spec, id, pos, rot, carry) => {
+      const st = { id, position: [pos[0], pos[1], pos[2]], rotation: [rot[0], rot[1], rot[2], rot[3]], parts: [], joints: [], groups: [], destroyed: false };
+      if (spec.name !== void 0) st.name = spec.name;
+      const o = {
+        id,
+        spec,
+        st,
+        parts: [],
+        byId: /* @__PURE__ */ new Map(),
+        idx: /* @__PURE__ */ new Map(),
+        joints: [],
+        jointMap: /* @__PURE__ */ new Map(),
+        byPart: /* @__PURE__ */ new Map(),
+        bc: [0, 0, 0],
+        br: 0,
+        active: false,
+        tmp: [],
+        hasStructure: false,
+        dirty: false,
+        maxStress: 0,
+        collapsed: new Set(carry?.collapsed ?? []),
+        unsup: [],
+        anyAnchor: false
+      };
+      for (const ps of spec.parts) {
+        if (o.byId.has(ps.id)) throw new Error(`duplicate part id "${ps.id}"`);
+        const mat = materials.get(ps.material);
+        if (!mat) throw new Error(`unknown material "${ps.material}" on part "${ps.id}"`);
+        const mass0 = partMass(ps, mat);
+        const maxHp = Math.max(1, ps.hp ?? mass0 * mat.hpPerKg);
+        const fuel0 = mat.thermal.ignitionC !== void 0 ? mass0 * (mat.thermal.fuelFraction ?? 0) : 0;
+        const c = carry?.parts.get(ps.id);
+        const pst = c?.st ?? {
+          id: ps.id,
+          material: ps.material,
+          status: "intact",
+          hp: maxHp,
+          maxHp,
+          mass: mass0,
+          temperature: ambient,
+          burning: false,
+          fuel: fuel0,
+          char: 0,
+          melt: 0,
+          dents: [],
+          holes: [],
+          cracks: [],
+          group: 0
+        };
+        if (!c && ps.contains) pst.liters = ps.contains.liters;
+        const p = {
+          spec: ps,
+          mat,
+          st: pst,
+          q: quatFromEuler(...ps.rotation ?? [0, 0, 0]),
+          pos: [ps.position[0], ps.position[1], ps.position[2]],
+          mass0,
+          fuel0,
+          area: shapeArea(ps.shape),
+          thickness: partThickness(ps),
+          dims: shapeDims(ps.shape),
+          bound: shapeBound(ps.shape),
+          rt: c?.rt ?? { ...freshRuntime(), prevTemp: pst.temperature },
+          structural: !!ps.structure && ps.structure.role !== "none",
+          anchored: !!ps.anchored || ps.structure?.role === "foundation",
+          cap: ps.structure ? partCapacity(ps, mat) : 0
+        };
+        if (p.structural) o.hasStructure = true;
+        o.idx.set(ps.id, o.parts.length);
+        o.parts.push(p);
+        o.byId.set(ps.id, p);
+        o.st.parts.push(pst);
+        o.byPart.set(ps.id, []);
+      }
+      for (const js of spec.joints ?? []) {
+        const r = js;
+        const ia = o.idx.get(r.a), ib = o.idx.get(r.b);
+        if (ia === void 0 || ib === void 0) throw new Error(`joint "${r.id}" references an unknown part`);
+        if (o.jointMap.has(r.id)) throw new Error(`duplicate joint id "${r.id}"`);
+        const pa = o.parts[ia], pb = o.parts[ib];
+        const A = aabbOf(pa.spec.shape, pa.spec.position, pa.q);
+        const B = aabbOf(pb.spec.shape, pb.spec.position, pb.q);
+        const pos2 = [0, 0, 0];
+        for (let k = 0; k < 3; k++) pos2[k] = (Math.max(A.min[k], B.min[k]) + Math.min(A.max[k], B.max[k])) / 2;
+        const bears = r.bears ?? (pa.structural && pb.structural);
+        const c = carry?.joints.get(r.id);
+        const jst = c?.st ?? { id: r.id, a: r.a, b: r.b, kind: r.kind, hp: r.strength, maxHp: r.strength, progress: 0, open: false };
+        const j = { spec: r, st: jst, ia, ib, bears, pos: pos2, step: c?.step ?? 0 };
+        o.joints.push(j);
+        o.jointMap.set(r.id, j);
+        o.byPart.get(r.a).push(j);
+        o.byPart.get(r.b).push(j);
+        o.st.joints.push(jst);
+      }
+      for (const [jid, c] of carry?.joints ?? []) if (c.st.open && !o.jointMap.has(jid)) o.st.joints.push(c.st);
+      updateBound(o);
+      o.anyAnchor = o.parts.some((p) => p.anchored);
+      o.unsup = o.parts.map(() => false);
+      solveStructure(o);
+      recomputeGroups(o);
+      o.st.destroyed = o.parts.length > 0 && o.parts.every(isLost);
+      o.active = o.maxStress > 0.8 || o.parts.some((p) => p.st.burning || p.st.temperature > ambient + 0.5 || (p.st.liters ?? 0) > 0);
+      return o;
+    };
+    const recomputeGroups = (o) => {
+      const n = o.parts.length;
+      const parent = Array.from({ length: n }, (_, i) => i);
+      const find = (i) => {
+        while (parent[i] !== i) {
+          parent[i] = parent[parent[i]];
+          i = parent[i];
+        }
+        return i;
+      };
+      const union = (a, b) => {
+        parent[find(a)] = find(b);
+      };
+      const live = (j) => !j.st.open && !isLost(o.parts[j.ia]) && !isLost(o.parts[j.ib]);
+      if (o.unsup.some(Boolean)) {
+        for (const j of o.joints) if (live(j) && !o.unsup[j.ia] && !o.unsup[j.ib]) union(j.ia, j.ib);
+        const supported = /* @__PURE__ */ new Set();
+        for (let i = 0; i < n; i++) if (!isLost(o.parts[i]) && !o.unsup[i] && (o.parts[i].structural || o.parts[i].anchored)) supported.add(find(i));
+        for (const j of o.joints) {
+          if (!live(j) || !(o.unsup[j.ia] || o.unsup[j.ib])) continue;
+          if (o.unsup[j.ia] && o.unsup[j.ib]) union(j.ia, j.ib);
+          else {
+            const u = o.unsup[j.ia] ? j.ia : j.ib;
+            const other = u === j.ia ? j.ib : j.ia;
+            if (!o.parts[other].structural && !supported.has(find(other))) union(u, other);
+          }
+        }
+      } else for (const j of o.joints) if (live(j)) union(j.ia, j.ib);
+      const comps = /* @__PURE__ */ new Map();
+      for (let i = 0; i < n; i++) {
+        if (isLost(o.parts[i])) continue;
+        const r = find(i);
+        const l = comps.get(r);
+        if (l) l.push(i);
+        else comps.set(r, [i]);
+      }
+      const list = [...comps.values()].map((ix) => ({
+        ix,
+        anchored: ix.some((i) => o.parts[i].anchored),
+        mass: ix.reduce((s, i) => s + o.parts[i].st.mass, 0)
+      }));
+      list.sort((a, b) => a.anchored === b.anchored ? b.mass - a.mass || a.ix[0] - b.ix[0] : a.anchored ? -1 : 1);
+      o.st.groups = list.map((g) => g.ix.map((i) => o.parts[i].spec.id));
+      for (const p of o.parts) if (isLost(p)) p.st.group = -1;
+      list.forEach((g, gi) => g.ix.forEach((i) => o.parts[i].st.group = gi));
+    };
+    const restsOn = (j, r) => {
+      const b = j.bears;
+      if (!b) return -1;
+      if (b === true) return j.ia === r ? j.ib : j.ia;
+      if (b === "a_on_b") return j.ia === r ? j.ib : -1;
+      return j.ib === r ? j.ia : -1;
+    };
+    const solveStructure = (o) => {
+      o.maxStress = 0;
+      if (!o.hasStructure) return;
+      const parts = o.parts;
+      const n = parts.length;
+      const dist = new Array(n).fill(-1);
+      const queue = [];
+      const ok = (i) => parts[i].structural && !isLost(parts[i]);
+      const isPartition = (i) => parts[i].spec.structure?.role === "partition";
+      for (let i = 0; i < n; i++) if (ok(i) && parts[i].anchored) {
+        dist[i] = 0;
+        queue.push(i);
+      }
+      for (let h = 0; h < queue.length; h++) {
+        const s = queue[h];
+        if (isPartition(s)) continue;
+        for (const j of o.byPart.get(parts[s].spec.id)) {
+          if (j.st.open || !j.bears) continue;
+          const r = j.ia === s ? j.ib : j.ia;
+          if (dist[r] >= 0 || !ok(r) || restsOn(j, r) !== s) continue;
+          dist[r] = dist[s] + 1;
+          queue.push(r);
+        }
+      }
+      const incoming = new Array(n).fill(0);
+      for (let h = queue.length - 1; h >= 0; h--) {
+        const i = queue[h];
+        const total = parts[i].st.mass + incoming[i];
+        parts[i].st.load = total;
+        const lower = [];
+        for (const j of o.byPart.get(parts[i].spec.id)) {
+          if (j.st.open || !j.bears) continue;
+          const k = restsOn(j, i);
+          if (k >= 0 && dist[k] >= 0 && dist[k] < dist[i] && !isPartition(k)) lower.push(k);
+        }
+        for (const k of lower) incoming[k] += total / lower.length;
+      }
+      for (let i = 0; i < n; i++) {
+        const p = parts[i];
+        o.unsup[i] = false;
+        if (!p.structural) continue;
+        if (dist[i] < 0 || isLost(p)) {
+          p.st.load = p.st.mass;
+          p.st.stress = 0;
+          o.unsup[i] = o.anyAnchor && !isLost(p);
+          continue;
+        }
+        p.st.stress = p.st.load / p.cap;
+        if (p.st.stress > o.maxStress) o.maxStress = p.st.stress;
+      }
+      if (o.maxStress > 0.8) o.active = true;
+    };
+    const collapseCheck = (o, src) => {
+      if (!o.hasStructure || !o.parts.some((p) => p.anchored)) return;
+      if (!pendingCollapse.has(o)) pendingCollapse.set(o, src);
+    };
+    const flushCollapse = () => {
+      for (const [o, src] of [...pendingCollapse]) {
+        pendingCollapse.delete(o);
+        if (!objects.has(o.id) || objects.get(o.id) !== o) continue;
+        for (const g of o.st.groups) {
+          const ps = g.map((id) => o.byId.get(id)).filter((p) => !isLost(p) && !o.collapsed.has(p.spec.id));
+          if (ps.length === 0 || g.some((id) => o.byId.get(id).anchored) || !ps.some((p) => p.structural)) continue;
+          for (const p of ps) o.collapsed.add(p.spec.id);
+          emit({ ...base(o, src), type: "collapse", parts: ps.map((p) => p.spec.id), mass: ps.reduce((sum, p) => sum + p.st.mass, 0) });
+        }
+      }
+    };
+    const getObj = (id) => {
+      const o = objects.get(id);
+      if (!o) throw new Error(`unknown object "${id}"`);
+      return o;
+    };
+    const getPart = (o, id) => {
+      const p = o.byId.get(id);
+      if (!p) throw new Error(`unknown part "${id}" in object "${o.id}"`);
+      return p;
+    };
+    const partXf = (o, p) => ({ c: toWorld(o.st.position, o.st.rotation, p.pos), q: quat.mul(o.st.rotation, p.q) });
+    const objLocal = (o, w) => toLocal(o.st.position, o.st.rotation, w);
+    const objLocalDir = (o, w) => rotateVec(quat.conjugate(o.st.rotation), w);
+    const jointWorld = (o, j) => toWorld(o.st.position, o.st.rotation, j.pos);
+    const distToPart = (o, p, w) => {
+      const { c, q } = partXf(o, p);
+      return distanceToShape(p.spec.shape, toLocal(c, q, w));
+    };
+    const partWorldAabb = (o, p) => {
+      const { c, q } = partXf(o, p);
+      return aabbOf(p.spec.shape, c, q);
+    };
+    const rayPartRaw = (pos, rot, spec, pq, origin, d, lp = spec.position) => {
+      const c = toWorld(pos, rot, lp);
+      const q = quat.mul(rot, pq);
+      const qi = quat.conjugate(q);
+      const r = rayShape(spec.shape, rotateVec(qi, vec.sub(origin, c)), rotateVec(qi, d));
+      return r ? { t0: r.t0, t1: r.t1, n: rotateVec(q, r.n0) } : null;
+    };
+    const rayPart = (o, p, origin, d) => rayPartRaw(o.st.position, o.st.rotation, p.spec, p.q, origin, d, p.pos);
+    const raySphereMiss = (origin, d, c, r, maxDist) => {
+      const oc = vec.sub(origin, c);
+      const b = vec.dot(oc, d);
+      const cc = vec.dot(oc, oc) - r * r;
+      if (cc > 0 && b > 0) return true;
+      const disc = b * b - cc;
+      if (disc < 0) return true;
+      return -b - Math.sqrt(disc) > maxDist;
+    };
+    const raycastInternal = (origin, dir, maxDist, ignore) => {
+      const d = vec.normalize(dir);
+      let best = null;
+      for (const o of objects.values()) {
+        if (raySphereMiss(origin, d, toWorld(o.st.position, o.st.rotation, o.bc), o.br, best ? Math.min(maxDist, best.distance) : maxDist)) continue;
+        for (const p of o.parts) {
+          if (isLost(p) || ignore?.has(`${o.id}\0${p.spec.id}`)) continue;
+          const r = rayPart(o, p, origin, d);
+          if (!r || r.t0 < 0 || r.t0 > maxDist) continue;
+          if (!best || r.t0 < best.distance) best = { object: o.id, part: p.spec.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
+        }
+      }
+      for (const im of impls.values()) {
+        for (const ps of im.impl.describe().parts) {
+          if (ignore?.has(`${im.impl.id}\0${ps.id}`)) continue;
+          const ov = im.poses.get(ps.id);
+          const r = rayPartRaw(im.position, im.rotation, ps, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]), origin, d, ov?.pos);
+          if (!r || r.t0 < 0 || r.t0 > maxDist) continue;
+          if (!best || r.t0 < best.distance) best = { object: im.impl.id, part: ps.id, point: vec.madd(origin, d, r.t0), normal: r.n, distance: r.t0, pathLen: r.t1 - r.t0 };
+        }
+      }
+      return best;
+    };
+    const implHit = (im, hit) => {
+      let h = hit;
+      if (hit.space === "local") {
+        h = { ...hit, space: "world", point: toWorld(im.position, im.rotation, hit.point) };
+        if (hit.direction) h.direction = rotateVec(im.rotation, hit.direction);
+      }
+      const start = cur.length;
+      for (const e of im.impl.hit(h) ?? []) emit(e.time === void 0 ? { ...e, time } : e);
+      const mine = cur.slice(start);
+      const res = { object: im.impl.id, damage: 0, penetrated: false, exitEnergy: 0, events: mine, point: hit.point };
+      for (const e of mine) {
+        if (e.type === "damage") res.damage += e.amount;
+        if (e.type === "hole" && e.hole.through) res.penetrated = true;
+        if (res.part === void 0 && "part" in e) res.part = e.part;
+      }
+      return res;
+    };
+    const implJointPos = (im, a, b) => {
+      const parts = im.impl.describe().parts;
+      const pa = parts.find((p) => p.id === a), pb = parts.find((p) => p.id === b);
+      if (!pa || !pb) return null;
+      const A = aabbOf(pa.shape, pa.position, quatFromEuler(...pa.rotation ?? [0, 0, 0]));
+      const B = aabbOf(pb.shape, pb.position, quatFromEuler(...pb.rotation ?? [0, 0, 0]));
+      const pos = [0, 0, 0];
+      for (let k = 0; k < 3; k++) pos[k] = (Math.max(A.min[k], B.min[k]) + Math.min(A.max[k], B.max[k])) / 2;
+      return toWorld(im.position, im.rotation, pos);
+    };
+    const locate = (o, point, dir, tol, only) => {
+      const cands = only ? [only] : o.parts;
+      if (dir && vec.length(dir) > 1e-9) {
+        const d = vec.normalize(dir);
+        const origin = vec.madd(point, d, -0.05);
+        let best = null;
+        let bestT = Infinity;
+        let inside = null;
+        for (const p of cands) {
+          if (isLost(p)) continue;
+          const r = rayPart(o, p, origin, d);
+          if (!r) continue;
+          if (r.t0 >= 0 && r.t0 <= 0.15) {
+            if (r.t0 < bestT) {
+              bestT = r.t0;
+              best = { p, point: vec.madd(origin, d, r.t0), normal: r.n, dir: d, pathLen: Math.max(r.t1 - r.t0, 1e-4) };
+            }
+          } else if (r.t0 < 0 && r.t1 > 0 && !inside) {
+            inside = { p, point, normal: vec.scale(d, -1), dir: d, pathLen: Math.max(r.t1 - 0.05, p.thickness) };
+          }
+        }
+        if (best) return best;
+        if (inside) return inside;
+      }
+      let np = null;
+      let nd = Infinity;
+      for (const p of cands) {
+        if (isLost(p)) continue;
+        const dd = distToPart(o, p, point);
+        if (dd < nd) {
+          nd = dd;
+          np = p;
+        }
+      }
+      if (!np || nd > tol) return null;
+      const { c, q } = partXf(o, np);
+      const sp = surfacePoint(np.spec.shape, toLocal(c, q, point));
+      const normal = rotateVec(q, sp.normal);
+      return { p: np, point: toWorld(c, q, sp.point), normal, dir: dir && vec.length(dir) > 1e-9 ? vec.normalize(dir) : vec.scale(normal, -1), pathLen: np.thickness };
+    };
+    const markDamaged = (p) => {
+      if (p.st.status === "intact") p.st.status = "damaged";
+    };
+    const addDent = (o, p, wp, wn, radius, depth, src) => {
+      const dent = { point: objLocal(o, wp), normal: objLocalDir(o, wn), radius, depth };
+      const arr = p.st.dents;
+      let ni = -1, nd = Infinity;
+      for (let i = 0; i < arr.length; i++) {
+        const dd = vec.distance(arr[i].point, dent.point);
+        if (dd < nd) {
+          nd = dd;
+          ni = i;
+        }
+      }
+      if (ni >= 0 && (arr.length >= maxDents || nd < arr[ni].radius * 0.6)) {
+        arr[ni].depth = Math.min(0.1, Math.max(arr[ni].depth, depth) + depth * 0.3);
+        arr[ni].radius = Math.max(arr[ni].radius, radius);
+      } else arr.push(dent);
+      markDamaged(p);
+      emit({ ...base(o, src), type: "dent", part: p.spec.id, dent, worldPoint: wp });
+    };
+    const addHole = (o, p, wp, wn, diameter, through, exit, src) => {
+      const hole = { point: objLocal(o, wp), normal: objLocalDir(o, wn), diameter, through };
+      p.st.holes.push(hole);
+      if (p.st.holes.length > maxHoles) p.st.holes.shift();
+      markDamaged(p);
+      emit({ ...base(o, src), type: "hole", part: p.spec.id, hole, worldPoint: wp, ...exit ? { exitPoint: exit } : {} });
+      return hole;
+    };
+    const addCrack = (o, p, wp, wn, length, src) => {
+      const crack = { point: objLocal(o, wp), normal: objLocalDir(o, wn), length: Math.min(length, Math.max(p.bound, 0.05)), rays: 5 + Math.floor(rnd() * 5) };
+      p.st.cracks.push(crack);
+      if (p.st.cracks.length > 16) p.st.cracks.shift();
+      markDamaged(p);
+      emit({ ...base(o, src), type: "crack", part: p.spec.id, crack, worldPoint: wp });
+    };
+    const debris = (o, p, kind, point, normal, count, speed, src) => emit({ ...base(o, src), type: "debris", part: p.spec.id, kind, point, normal, count, speed });
+    const holeRate = (hole, pressurized) => (pressurized ? 0.5 : 0.1) * (hole.diameter / 9e-3);
+    const detachEvents = (o, opened, by, src) => {
+      for (const j of opened) emit({ ...base(o, src), type: "detach", joint: j.spec.id, parts: [j.spec.a, j.spec.b], by, groups: o.st.groups.map((g) => [...g]) });
+    };
+    const checkDestroyed = (o, src) => {
+      if (!o.st.destroyed && o.parts.length > 0 && o.parts.every(isLost)) {
+        o.st.destroyed = true;
+        emit({ ...base(o, src), type: "destroyed" });
+      }
+    };
+    const partLost = (o, p, src) => {
+      const opened = [];
+      for (const j of o.byPart.get(p.spec.id) ?? []) {
+        if (j.st.open) continue;
+        j.st.open = true;
+        j.st.openedBy = "part_lost";
+        opened.push(j);
+      }
+      solveStructure(o);
+      recomputeGroups(o);
+      detachEvents(o, opened, "part_lost", src);
+      collapseCheck(o, src);
+      checkDestroyed(o, src);
+    };
+    const jointReach = (o, j, point) => {
+      const A = partWorldAabb(o, o.parts[j.ia]), B = partWorldAabb(o, o.parts[j.ib]);
+      let d2 = 0;
+      for (let k = 0; k < 3; k++) {
+        const lo = Math.min(Math.max(A.min[k], B.min[k]), Math.min(A.max[k], B.max[k]));
+        const hi = Math.max(Math.max(A.min[k], B.min[k]), Math.min(A.max[k], B.max[k]));
+        const d = point[k] < lo ? lo - point[k] : point[k] > hi ? point[k] - hi : 0;
+        d2 += d * d;
+      }
+      return Math.sqrt(d2);
+    };
+    const jointReachLimit = (o, j) => {
+      const pa = o.parts[j.ia], pb = o.parts[j.ib];
+      const small = pa.dims[0] * pa.dims[1] * pa.dims[2] <= pb.dims[0] * pb.dims[1] * pb.dims[2] ? pa : pb;
+      return Math.max(0.06, 0.5 * Math.min(small.dims[0], small.dims[1], small.dims[2]));
+    };
+    const wearJoints = (o, p, amount, near, radius = 0.06, src, split = false) => {
+      if (amount <= 0) return;
+      const mine = (o.byPart.get(p.spec.id) ?? []).filter((j) => !j.st.open);
+      if (split && mine.length) amount /= mine.length;
+      for (const j of mine) {
+        if (j.st.open) continue;
+        if (near && jointReach(o, j, near) > Math.max(radius, jointReachLimit(o, j))) continue;
+        j.st.hp -= amount;
+        if (j.st.hp <= 0) {
+          j.st.hp = 0;
+          j.st.open = true;
+          j.st.openedBy = "break";
+          solveStructure(o);
+          recomputeGroups(o);
+          detachEvents(o, [j], "break", src);
+          collapseCheck(o, src);
+        }
+      }
+    };
+    const failPart = (o, p, origin, dir, fragEnergy, cap, src) => {
+      if (isLost(p)) return;
+      const ex = p.spec.explodes;
+      const style = p.mat.fracture === "none" ? "snap" : p.mat.fracture;
+      const { c, q } = partXf(o, p);
+      const hitW = origin ?? c;
+      const grain = p.spec.grain ? AXIS[p.spec.grain] : void 0;
+      const plan = planFragments({
+        style,
+        dims: p.dims,
+        thickness: p.thickness,
+        grain,
+        hit: toLocal(c, q, hitW),
+        fragmentSize: p.mat.fragmentSize ?? [0.04, 0.2],
+        maxFragments,
+        rnd
+      });
+      const mass = p.st.mass;
+      const totW = plan.reduce((s, f) => s + f.weight, 0) || 1;
+      const energy = ex ? ex.energy * 0.2 : fragEnergy;
+      const speed = clamp2(Math.sqrt(2 * energy / Math.max(mass, 0.05)), 0.3, ex ? 40 : cap);
+      const fragments = plan.map((f, i) => {
+        const cw = toWorld(c, q, f.center);
+        const out = vec.normalize(vec.sub(cw, hitW), [0, 1, 0]);
+        const dv = dir ? vec.normalize(vec.madd(out, dir, 0.6)) : out;
+        const k = speed * (0.6 + 0.8 * rnd());
+        return {
+          id: `${p.spec.id}#${i}`,
+          part: p.spec.id,
+          material: p.spec.material,
+          shape: f.shape,
+          center: cw,
+          size: f.size,
+          rotation: quat.mul(q, f.q),
+          velocity: [dv[0] * k, dv[1] * k + 0.5 * rnd(), dv[2] * k],
+          angularVelocity: [(rnd() - 0.5) * 12, (rnd() - 0.5) * 12, (rnd() - 0.5) * 12],
+          mass: mass * f.weight / totW
+        };
+      });
+      p.st.status = "broken";
+      p.st.hp = 0;
+      p.st.mass = 0;
+      p.st.burning = false;
+      p.rt.jet = false;
+      emit({ ...base(o, src), type: "fracture", part: p.spec.id, style, fragments, point: hitW });
+      debris(o, p, p.mat.breakDebris, c, [0, 1, 0], clamp2(Math.round(Math.cbrt(partVolume(p.spec.shape)) * 30), 3, 20), 2, src);
+      if (ex) {
+        emit({ ...base(o, src), type: "explode", part: p.spec.id, point: c, energy: ex.energy, radius: ex.radius });
+        blasts.push({ point: c, energy: ex.energy, radius: ex.radius, source: src });
+      }
+      partLost(o, p, src);
+    };
+    const applyDamage = (o, p, amount, type, origin, dir, fragEnergy, cap, src) => {
+      if (isLost(p) || amount <= 0) return 0;
+      const prev = p.st.hp;
+      p.st.hp -= amount;
+      markDamaged(p);
+      if (p.st.hp <= 0 && p.mat.fracture === "none" && !p.spec.explodes) p.st.hp = Math.min(prev, 1);
+      const done = prev - p.st.hp;
+      if (done > 0) emit({ ...base(o, src), type: "damage", part: p.spec.id, amount: done, hp: Math.max(0, p.st.hp), damageType: type });
+      if (p.st.hp <= 0) failPart(o, p, origin, dir, fragEnergy, cap, src);
+      return done;
+    };
+    const ballistic = (o, p, entry, n, d, E, caliber, pathLen, src) => {
+      const mat = p.mat;
+      const sin = Math.min(1, Math.abs(vec.dot(d, n)));
+      const angle = Math.asin(sin) * 180 / Math.PI;
+      const effM = p.thickness / Math.max(sin, 0.3);
+      const thr = mat.penetration * effM * 1e3;
+      const penetrated = E > thr;
+      const scale = mat.damageScale?.ballistic ?? 1;
+      const id = p.spec.id;
+      if (!penetrated && mat.ricochetDeg && angle < mat.ricochetDeg) {
+        const r = vec.sub(d, vec.scale(n, 2 * vec.dot(d, n)));
+        emit({ ...base(o, src), type: "ricochet", part: id, point: entry, direction: vec.normalize(r), energy: E * 0.4 });
+        debris(o, p, mat.hitDebris, entry, n, 3, 3, src);
+        const dmg2 = applyDamage(o, p, E * DMG_PER_J * scale * 0.2, "ballistic", entry, d, E * 0.1, 12, src);
+        return { penetrated: false, exitEnergy: 0, damage: dmg2 };
+      }
+      const brittle = mat.ductility < 0.3;
+      const ratio = E / Math.max(thr, 1e-6);
+      const crackLen = clamp2(0.03 + ratio * 0.2, 0.03, 0.8);
+      let exitPoint;
+      if (penetrated) {
+        exitPoint = vec.madd(entry, d, Math.min(pathLen, effM));
+        const hole = addHole(o, p, entry, n, caliber / 1e3 * (mat.ductility >= 0.3 ? 1 : 1.5), true, exitPoint, src);
+        if (brittle && mat.fracture === "shatter") addCrack(o, p, entry, n, crackLen, src);
+        if (p.spec.contains && (p.st.liters ?? 0) > 0) {
+          emit({
+            ...base(o, src),
+            type: "leak",
+            part: id,
+            fluid: p.spec.contains.fluid,
+            point: entry,
+            direction: n,
+            rate: holeRate(hole, !!p.spec.contains.pressurized),
+            pressurized: !!p.spec.contains.pressurized
+          });
+        }
+      } else if (mat.ductility >= 0.5) {
+        addDent(o, p, entry, n, Math.max(caliber * 3 / 1e3, 0.012), clamp2(Math.min(Math.max(p.thickness * 3, 3e-3), ratio * 0.01), 1e-3, 0.05), src);
+      } else if (brittle) {
+        addCrack(o, p, entry, n, crackLen, src);
+        if (mat.fracture !== "shatter") addHole(o, p, entry, n, caliber / 1e3, false, void 0, src);
+      } else addHole(o, p, entry, n, caliber / 1e3, false, void 0, src);
+      debris(o, p, mat.hitDebris, entry, n, clamp2(Math.round(E / 60) + 2, 2, 14), clamp2(Math.sqrt(E) / 6, 1, 8), src);
+      wearJoints(o, p, (penetrated ? thr : E) * 0.02, void 0, 0, src, true);
+      const dmg = applyDamage(o, p, E * DMG_PER_J * scale, "ballistic", entry, d, E * 0.1, 12, src);
+      return { penetrated, exitEnergy: penetrated ? E - thr : 0, exitPoint, damage: dmg };
+    };
+    const melee = (o, p, kind, E, point, n, d, contactR, src) => {
+      const mat = p.mat;
+      const thrMm = mat.penetration * p.thickness * 1e3;
+      const fragile = kind === "blunt" ? fragility(mat.ductility, p.thickness) : 1;
+      const Ec = E * fragile;
+      if (E > 0) {
+        if (kind === "blunt") {
+          if (mat.ductility >= 0.5) addDent(o, p, point, n, Math.max(contactR, 0.015), clamp2(E * 1e-4, 1e-3, 0.06), src);
+          else if (mat.ductility < 0.3) {
+            if (Ec >= 5) addCrack(o, p, point, n, clamp2(0.04 + Math.min(Ec, E * 6) * 8e-4, 0.04, 0.6), src);
+          } else if (E >= thrMm * 0.2) addDent(o, p, point, n, Math.max(contactR, 0.015), clamp2(E * 6e-5, 1e-3, 0.04), src);
+        } else if (mat.fracture === "tear") {
+          addHole(o, p, point, n, clamp2(0.02 + E * 5e-4, 0.02, 0.3), true, void 0, src);
+        } else if (mat.ductility >= 0.5) {
+          addDent(o, p, point, n, Math.max(contactR, 0.01), clamp2(E * 4e-5, 5e-4, 0.02), src);
+        }
+        debris(o, p, mat.hitDebris, point, n, clamp2(Math.round(E / 25) + 1, 1, 10), clamp2(Math.sqrt(E) / 8, 1, 6), src);
+      }
+      if (kind === "blunt") wearJoints(o, p, E * 0.3, void 0, 0, src);
+      else wearJoints(o, p, E * 0.3, point, 0.06, src);
+      const scale = mat.damageScale?.[kind] ?? 1;
+      return applyDamage(o, p, Ec * DMG_PER_J * scale, kind, point, d, E * 0.1, 12, src);
+    };
+    const blastObject = (o, point, energy, radius, src) => {
+      const start = cur.length;
+      const res = { object: o.id, damage: 0, penetrated: false, exitEnergy: 0, events: [] };
+      for (const p of o.parts) {
+        if (isLost(p)) continue;
+        const { c, q } = partXf(o, p);
+        const lp = toLocal(c, q, point);
+        const dist = distanceToShape(p.spec.shape, lp);
+        if (dist >= radius) continue;
+        const f = (1 - dist / radius) ** 2;
+        const Ein = energy * f * BLAST_COUPLING;
+        const sp = surfacePoint(p.spec.shape, lp);
+        const wp = toWorld(c, q, sp.point);
+        const wn = rotateVec(q, sp.normal);
+        if (!res.part) {
+          res.part = p.spec.id;
+          res.point = wp;
+        }
+        const mat = p.mat;
+        if (Ein > 20) {
+          if (mat.ductility >= 0.5) addDent(o, p, wp, wn, clamp2(0.05 + Math.sqrt(Ein) * 2e-3, 0.05, 0.4), clamp2(4e-3 + Ein * 2e-5, 4e-3, 0.08), src);
+          else if (mat.ductility < 0.3 && Ein > 60) addCrack(o, p, wp, wn, clamp2(0.05 + Ein * 5e-4, 0.05, 1), src);
+          debris(o, p, mat.hitDebris, wp, wn, clamp2(Math.round(Ein / 80) + 1, 1, 12), clamp2(Math.sqrt(Ein) / 4, 2, 15), src);
+        }
+        const th = mat.thermal;
+        if (th.ignitionC !== void 0 && p.st.fuel > 0) {
+          p.st.temperature += 300 * f;
+          o.active = true;
+          if (f >= 0.25 && !p.st.burning) {
+            p.st.temperature = Math.max(p.st.temperature, th.ignitionC + 1);
+            checkIgnite(o, p, src);
+          }
+        }
+        wearJoints(o, p, Ein * 0.5, void 0, 0, src);
+        res.damage += applyDamage(o, p, Ein * DMG_PER_J * (mat.damageScale?.explosive ?? 1), "explosive", point, null, Ein * 0.3, 40, src);
+      }
+      res.events = cur.slice(start);
+      return res;
+    };
+    const blastWorld = (point, energy, radius, src) => {
+      const out = [];
+      for (const o of [...objects.values()]) {
+        if (vec.distance(toWorld(o.st.position, o.st.rotation, o.bc), point) - o.br >= radius) continue;
+        const r = blastObject(o, point, energy, radius, src);
+        if (r.part) out.push(r);
+      }
+      for (const im of [...impls.values()]) {
+        const inRange = im.impl.describe().parts.some((ps) => {
+          const ov = im.poses.get(ps.id);
+          const c = toWorld(im.position, im.rotation, ov?.pos ?? ps.position);
+          const q = quat.mul(im.rotation, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]));
+          return distanceToShape(ps.shape, toLocal(c, q, point)) < radius;
+        });
+        if (inRange) out.push(implHit(im, { type: "explosive", point, energy, radius, ...src !== void 0 ? { source: src } : {} }));
+      }
+      return out;
+    };
+    const heatObject = (o, point, T, radius, duration, src) => {
+      const start = cur.length;
+      const res = { object: o.id, damage: 0, penetrated: false, exitEnergy: 0, events: [] };
+      for (const p of o.parts) {
+        if (isLost(p)) continue;
+        const dist = distToPart(o, p, point);
+        if (dist >= radius) continue;
+        const f = clamp2(1 - dist / radius, 0.25, 1);
+        if (!res.part) {
+          res.part = p.spec.id;
+          res.point = point;
+        }
+        if (T > p.st.temperature) {
+          const k = 0.8 * f / (p.mat.thermal.heatCapacity ?? 1);
+          p.st.temperature += (T - p.st.temperature) * (1 - Math.exp(-k * duration));
+        }
+        o.active = true;
+        checkIgnite(o, p, src);
+      }
+      res.events = cur.slice(start);
+      return res;
+    };
+    const doHit = (o, hit, only) => {
+      let point = hit.point;
+      let dir = hit.direction;
+      if (hit.space === "local") {
+        point = toWorld(o.st.position, o.st.rotation, point);
+        if (dir) dir = rotateVec(o.st.rotation, dir);
+      }
+      const src = hit.source;
+      const start = cur.length;
+      let res = { object: o.id, damage: 0, penetrated: false, exitEnergy: 0, events: [] };
+      const E = hit.energy ?? 0;
+      if (hit.type === "ballistic") {
+        const loc = locate(o, point, dir, 0.05, only);
+        if (loc) {
+          const out = ballistic(o, loc.p, loc.point, loc.normal, loc.dir, E, hit.caliber ?? 9, loc.pathLen, src);
+          res = { ...res, part: loc.p.spec.id, point: loc.point, damage: out.damage, penetrated: out.penetrated, exitEnergy: out.exitEnergy };
+        }
+      } else if (hit.type === "blunt" || hit.type === "slash") {
+        const radius = hit.radius ?? 0;
+        const loc = locate(o, point, dir, Math.max(0.05, radius), only);
+        if (loc) {
+          res.part = loc.p.spec.id;
+          res.point = loc.point;
+          res.damage += melee(o, loc.p, hit.type, E, loc.point, loc.normal, loc.dir, radius || 0.03, src);
+          if (radius > 0.1 && !only) {
+            for (const p of o.parts) {
+              if (p === loc.p || isLost(p)) continue;
+              const dd = distToPart(o, p, point);
+              if (dd >= radius) continue;
+              const { c, q } = partXf(o, p);
+              const sp = surfacePoint(p.spec.shape, toLocal(c, q, point));
+              res.damage += melee(o, p, hit.type, E * (1 - dd / radius) ** 2, toWorld(c, q, sp.point), rotateVec(q, sp.normal), loc.dir, radius, src);
+            }
+          }
+        }
+      } else if (hit.type === "explosive") {
+        res = blastObject(o, point, E, hit.radius ?? 2, src);
+      } else {
+        res = heatObject(o, point, hit.temperature ?? 800, hit.radius ?? 0.25, hit.duration ?? 1, src);
+      }
+      res.events = cur.slice(start);
+      return res;
+    };
+    const checkIgnite = (o, p, src) => {
+      const th = p.mat.thermal;
+      if (isLost(p) || p.st.burning || th.ignitionC === void 0 || p.st.fuel <= 0 || p.st.temperature < th.ignitionC) return;
+      p.st.burning = true;
+      p.st.temperature = Math.max(p.st.temperature, th.flameC ?? 800);
+      o.active = true;
+      markDamaged(p);
+      emit({ ...base(o, src), type: "ignite", part: p.spec.id, point: partXf(o, p).c });
+    };
+    const syncMass = (p) => {
+      p.st.mass = Math.max(0, p.mass0 * (1 - p.st.melt) - (p.fuel0 - p.st.fuel));
+    };
+    const burnStep = (o, p, dt) => {
+      const th = p.mat.thermal;
+      const use = Math.min((th.burnRate ?? 0.01) * p.area * dt, p.st.fuel);
+      p.st.fuel -= use;
+      syncMass(p);
+      if (p.structural) o.dirty = true;
+      p.st.temperature = th.flameC ?? 800;
+      markDamaged(p);
+      if (p.fuel0 > 0) {
+        p.st.char = clamp2(1 - p.st.fuel / p.fuel0, 0, 1);
+        p.st.hp = Math.min(p.st.hp, Math.max(1, p.st.maxHp * (p.st.fuel / p.fuel0)));
+      }
+      if (p.st.fuel <= 1e-9) {
+        p.st.fuel = 0;
+        p.st.burning = false;
+        p.st.char = 1;
+        const c = partXf(o, p).c;
+        if ((th.fuelFraction ?? 0) >= 0.8) {
+          p.st.status = "ashes";
+          p.st.hp = 0;
+          p.st.mass = p.mass0 * (1 - (th.fuelFraction ?? 0));
+          emit({ ...base(o), type: "burnout", part: p.spec.id, point: c });
+          debris(o, p, "ash", c, [0, 1, 0], clamp2(Math.round(Math.cbrt(partVolume(p.spec.shape)) * 30), 3, 20), 1);
+          partLost(o, p);
+        } else {
+          emit({ ...base(o), type: "burnout", part: p.spec.id, point: c });
+        }
+      }
+    };
+    const meltStep = (o, p, dt) => {
+      const th = p.mat.thermal;
+      if (th.meltC === void 0 || p.st.temperature <= th.meltC) return;
+      const rate = (th.meltRate ?? 0.05) * ((p.st.temperature - th.meltC) / 100);
+      p.st.melt = Math.min(1, p.st.melt + rate * dt);
+      syncMass(p);
+      if (p.structural) o.dirty = true;
+      markDamaged(p);
+      p.rt.dripT += dt;
+      if (p.rt.dripT >= 0.25) {
+        p.rt.dripT -= 0.25;
+        const b = partWorldAabb(o, p);
+        const pt = [b.min[0] + (b.max[0] - b.min[0]) * (0.2 + 0.6 * rnd()), b.min[1], b.min[2] + (b.max[2] - b.min[2]) * (0.2 + 0.6 * rnd())];
+        emit({ ...base(o), type: "drip", part: p.spec.id, point: pt, material: p.mat.id });
+      }
+      if (p.st.melt - p.rt.meltEmitted >= 0.05 || p.st.melt >= 1) {
+        p.rt.meltEmitted = p.st.melt;
+        emit({ ...base(o), type: "melt", part: p.spec.id, melt: p.st.melt });
+      }
+      if (p.st.melt >= 1) {
+        p.st.status = "melted";
+        p.st.hp = 0;
+        p.st.mass = 0;
+        p.st.burning = false;
+        p.rt.jet = false;
+        partLost(o, p);
+      }
+    };
+    const stepObject = (o, dt, sources) => {
+      const parts = o.parts;
+      const T0 = o.tmp;
+      T0.length = parts.length;
+      for (let i = 0; i < parts.length; i++) T0[i] = parts[i].st.temperature;
+      let hot = false;
+      for (let i = 0; i < parts.length; i++) {
+        const p = parts[i];
+        if (isLost(p)) continue;
+        const th = p.mat.thermal;
+        const hc = th.heatCapacity ?? 1;
+        const s = p.st;
+        if (p.rt.jet) {
+          s.temperature = Math.max(s.temperature, 900);
+        } else if (s.burning) {
+          burnStep(o, p, dt);
+          if (isLost(p)) continue;
+        }
+        if (!s.burning && !p.rt.jet) {
+          let dT = 0;
+          let maxN = s.temperature;
+          for (const j of o.byPart.get(p.spec.id)) {
+            if (j.st.open) continue;
+            const k = j.ia === i ? j.ib : j.ia;
+            if (isLost(parts[k]) || T0[k] <= T0[i]) continue;
+            const c = (th.conductivity + parts[k].mat.thermal.conductivity) / 2;
+            dT += (T0[k] - T0[i]) * (1 - Math.exp(-1.2 * c * dt / hc));
+            if (T0[k] > maxN) maxN = T0[k];
+          }
+          if (dT > 0) s.temperature = Math.min(s.temperature + dT, maxN);
+          s.temperature += (ambient - s.temperature) * (1 - Math.exp(-dt / (20 * hc)));
+          if (Math.abs(s.temperature - ambient) < 0.05) s.temperature = ambient;
+        }
+        meltStep(o, p, dt);
+        if (isLost(p)) continue;
+        checkIgnite(o, p);
+        const ex = p.spec.explodes;
+        if (ex && ex.atC !== void 0 && s.temperature >= ex.atC) {
+          failPart(o, p, null, null, 0, 40);
+          continue;
+        }
+        const cont = p.spec.contains;
+        if (cont && (s.liters ?? 0) > 0) {
+          let rate = 0;
+          for (const h of s.holes) if (h.through) rate += holeRate(h, !!cont.pressurized);
+          if (rate > 0) {
+            s.liters = Math.max(0, (s.liters ?? 0) - rate * dt);
+            hot = true;
+            if (FLAMMABLE_FLUIDS.includes(cont.fluid) && s.temperature >= 350 && !p.rt.jet) {
+              if (ex) {
+                failPart(o, p, null, null, 0, 40);
+                continue;
+              }
+              p.rt.jet = true;
+              s.burning = true;
+              emit({ ...base(o), type: "ignite", part: p.spec.id, point: partXf(o, p).c });
+            }
+          }
+        }
+        if (p.rt.jet && (s.liters ?? 0) <= 0) {
+          p.rt.jet = false;
+          s.burning = false;
+          emit({ ...base(o), type: "extinguish", part: p.spec.id });
+        }
+        const sc = th.thermalShockC;
+        if (sc !== void 0) {
+          p.rt.shockT = Math.max(0, p.rt.shockT - dt);
+          const rate = Math.abs(s.temperature - p.rt.prevTemp) / dt;
+          p.rt.prevTemp = s.temperature;
+          if (rate > sc && p.rt.shockT <= 0) {
+            p.rt.shockT = 1;
+            const { c, q } = partXf(o, p);
+            const lp = [(rnd() - 0.5) * p.dims[0], (rnd() - 0.5) * p.dims[1], (rnd() - 0.5) * p.dims[2]];
+            const sp = surfacePoint(p.spec.shape, lp);
+            addCrack(o, p, toWorld(c, q, sp.point), rotateVec(q, sp.normal), 0.1 + rate / sc * 0.1);
+            applyDamage(o, p, p.st.maxHp * 0.25, "heat", null, null, 5, 3);
+            if (isLost(p)) continue;
+          }
+        }
+        if (s.burning || p.rt.jet) sources.push({ o, p, flame: p.rt.jet ? 900 : th.flameC ?? 800 });
+        if (s.burning || p.rt.jet || s.temperature > ambient + 0.5) hot = true;
+      }
+      if (o.hasStructure) {
+        if (o.dirty) {
+          o.dirty = false;
+          solveStructure(o);
+        }
+        for (const p of parts) {
+          if (!p.structural || isLost(p)) continue;
+          const stress = p.st.stress ?? 0;
+          p.rt.stressT = Math.max(0, (p.rt.stressT ?? 0) - dt);
+          if (stress > 1) {
+            if (p.rt.stressT <= 0) {
+              p.rt.stressT = 0.5;
+              emit({ ...base(o), type: "stress", part: p.spec.id, stress, load: p.st.load ?? 0 });
+            }
+            applyDamage(o, p, (stress - 1) * p.st.maxHp * 0.5 * dt, "blunt", null, null, 5, 3);
+          } else if (stress > 0.8 && p.mat.ductility < 0.3 && p.rt.stressT <= 0 && p.st.cracks.length < 6) {
+            p.rt.stressT = 0.5;
+            const { c, q } = partXf(o, p);
+            const sp = surfacePoint(p.spec.shape, [(rnd() - 0.5) * p.dims[0], (rnd() - 0.5) * p.dims[1], (rnd() - 0.5) * p.dims[2]]);
+            addCrack(o, p, toWorld(c, q, sp.point), rotateVec(q, sp.normal), 0.1 + (stress - 0.8) * 0.5);
+          }
+        }
+        if (o.maxStress > 0.8) hot = true;
+      }
+      o.active = hot;
+    };
+    const spread = (sources, dt) => {
+      for (const src of sources) {
+        if (!src.p.st.burning && !src.p.rt.jet) continue;
+        const sc = toWorld(src.o.st.position, src.o.st.rotation, src.p.pos);
+        const A = partWorldAabb(src.o, src.p);
+        for (const o of objects.values()) {
+          if (o === src.o) continue;
+          if (vec.distance(toWorld(o.st.position, o.st.rotation, o.bc), sc) > o.br + src.p.bound + fireSpread) continue;
+          for (const q of o.parts) {
+            if (isLost(q) || q.st.burning) continue;
+            const B = partWorldAabb(o, q);
+            const gap = Math.hypot(
+              Math.max(0, A.min[0] - B.max[0], B.min[0] - A.max[0]),
+              Math.max(0, A.min[1] - B.max[1], B.min[1] - A.max[1]),
+              Math.max(0, A.min[2] - B.max[2], B.min[2] - A.max[2])
+            );
+            if (gap >= fireSpread || src.flame <= q.st.temperature) continue;
+            const f = 1 - gap / fireSpread;
+            q.st.temperature += (src.flame - q.st.temperature) * (1 - Math.exp(-0.6 * f * dt / (q.mat.thermal.heatCapacity ?? 1)));
+            o.active = true;
+          }
+        }
+      }
+    };
+    const withCollapses = (r) => {
+      const last = r.value[r.value.length - 1];
+      if (!last) return r.value;
+      for (const e of r.events) if (e.type === "collapse" && !r.value.some((h) => h.events.includes(e))) last.events.push(e);
+      return r.value;
+    };
+    const whole = (fn) => {
+      const r = run(fn);
+      r.value.events = r.events;
+      return r.value;
+    };
+    const world = {
+      materials,
+      get time() {
+        return time;
+      },
+      add(spec, opts = {}) {
+        const id = opts.id ?? nextId();
+        if (taken(id)) throw new Error(`object "${id}" already exists`);
+        objects.set(id, build(resolveSpec(spec), id, opts.position ?? [0, 0, 0], opts.rotation ?? [0, 0, 0, 1]));
+        return id;
+      },
+      register(impl, opts = {}) {
+        const id = opts.id ?? impl.id;
+        if (taken(id)) throw new Error(`object "${id}" already exists`);
+        impls.set(id, { impl, position: opts.position ?? [0, 0, 0], rotation: opts.rotation ?? [0, 0, 0, 1], poses: /* @__PURE__ */ new Map() });
+        return id;
+      },
+      setPartPose(objectId, partId, position, rotation) {
+        const q = quatFromEuler(...rotation ?? [0, 0, 0]);
+        const im = impls.get(objectId);
+        if (im) {
+          im.impl.setPartPose?.(partId, position, rotation);
+          im.poses.set(partId, { pos: [position[0], position[1], position[2]], q });
+          return;
+        }
+        const o = getObj(objectId);
+        const p = getPart(o, partId);
+        p.pos = [position[0], position[1], position[2]];
+        p.q = q;
+        updateBound(o);
+      },
+      remove(id) {
+        objects.delete(id);
+        impls.delete(id);
+      },
+      has: (id) => taken(id),
+      ids: () => [...objects.keys(), ...impls.keys()],
+      setTransform(id, position, rotation) {
+        const im = impls.get(id);
+        if (im) {
+          im.position = [position[0], position[1], position[2]];
+          im.rotation = [rotation[0], rotation[1], rotation[2], rotation[3]];
+          return;
+        }
+        const o = getObj(id);
+        o.st.position = [position[0], position[1], position[2]];
+        o.st.rotation = [rotation[0], rotation[1], rotation[2], rotation[3]];
+      },
+      splitGroup(id, group, newId) {
+        if (impls.has(id)) throw new Error(`object "${id}" is a registered DestructibleImpl and cannot be split; its module owns its pieces`);
+        const o = getObj(id);
+        if (o.st.groups.length < 2) return id;
+        const names = o.st.groups[group];
+        if (!names) throw new Error(`object "${id}" has no group ${group}`);
+        const moved = new Set(names);
+        const nid = newId ?? nextId();
+        if (objects.has(nid)) throw new Error(`object "${nid}" already exists`);
+        const carryFor = (keep, keepOpen = () => false) => ({
+          parts: new Map(o.parts.filter((p) => keep(p.spec.id)).map((p) => [p.spec.id, { st: p.st, rt: p.rt }])),
+          joints: new Map([
+            ...o.joints.filter((j) => keep(j.spec.a) && keep(j.spec.b) || j.st.open && keepOpen(j.spec.a, j.spec.b)).map((j) => [j.spec.id, { st: j.st, step: j.step }]),
+            ...o.st.joints.filter((st) => st.open && !o.jointMap.has(st.id) && keepOpen(st.a, st.b)).map((st) => [st.id, { st, step: 0 }])
+          ]),
+          collapsed: [...o.collapsed].filter(keep)
+        });
+        const sub = (keep) => {
+          const s = { parts: o.spec.parts.filter((p) => keep(p.id)), joints: (o.spec.joints ?? []).filter((j) => keep(j.a) && keep(j.b)) };
+          if (o.spec.name !== void 0) s.name = o.spec.name;
+          if (o.spec.tags) s.tags = [...o.spec.tags];
+          return clone(s);
+        };
+        const inNew = (pid) => moved.has(pid);
+        const inOld = (pid) => !moved.has(pid);
+        const pos = o.st.position, rot = o.st.rotation;
+        const fresh = build(sub(inNew), nid, pos, rot, carryFor(inNew, (a, b) => inNew(a) && inNew(b)));
+        const rest = build(sub(inOld), id, pos, rot, carryFor(inOld, (a, b) => !(inNew(a) && inNew(b))));
+        objects.set(id, rest);
+        objects.set(nid, fresh);
+        return nid;
+      },
+      hit(objectId, h) {
+        const im = impls.get(objectId);
+        if (im) return whole(() => implHit(im, h));
+        const o = getObj(objectId);
+        return whole(() => doHit(o, h));
+      },
+      hitPart(objectId, partId, h) {
+        const im = impls.get(objectId);
+        if (im) return whole(() => implHit(im, h));
+        const o = getObj(objectId);
+        const p = getPart(o, partId);
+        return whole(() => doHit(o, h, p));
+      },
+      explode(point, energy, radius, source) {
+        return withCollapses(run(() => blastWorld(point, energy, radius, source)));
+      },
+      raycast(origin, direction, maxDistance = Infinity) {
+        const r = raycastInternal(origin, direction, maxDistance);
+        return r ? { object: r.object, part: r.part, point: r.point, normal: r.normal, distance: r.distance } : null;
+      },
+      shoot(origin, direction, energy, caliber, source) {
+        return withCollapses(run(() => {
+          const results = [];
+          const d = vec.normalize(direction);
+          const ignore = /* @__PURE__ */ new Set();
+          let org = origin;
+          let E = energy;
+          for (let i = 0; i < 4 && E > 0; i++) {
+            const rh = raycastInternal(org, d, Infinity, ignore);
+            if (!rh) break;
+            const im = impls.get(rh.object);
+            if (im) {
+              const r = implHit(im, { type: "ballistic", point: rh.point, direction: d, energy: E, caliber, ...source !== void 0 ? { source } : {} });
+              r.part = rh.part;
+              r.point = rh.point;
+              r.exitEnergy = r.penetrated ? E * 0.5 : 0;
+              results.push(r);
+              ignore.add(`${im.impl.id}\0${rh.part}`);
+              if (!r.penetrated) break;
+              org = vec.madd(rh.point, d, Math.min(rh.pathLen, 0.05) + 1e-3);
+              E = r.exitEnergy;
+              continue;
+            }
+            const o = getObj(rh.object);
+            const p = getPart(o, rh.part);
+            const start = cur.length;
+            const out = ballistic(o, p, rh.point, rh.normal, d, E, caliber, rh.pathLen, source);
+            results.push({ object: o.id, part: p.spec.id, point: rh.point, damage: out.damage, penetrated: out.penetrated, exitEnergy: out.exitEnergy, events: cur.slice(start) });
+            ignore.add(`${o.id}\0${p.spec.id}`);
+            if (!out.penetrated || !out.exitPoint) break;
+            org = vec.madd(out.exitPoint, d, 1e-3);
+            E = out.exitEnergy;
+          }
+          return results;
+        }));
+      },
+      disassemble(objectId, jointId, tool, dt) {
+        const im = impls.get(objectId);
+        if (im) return im.impl.disassemble ? im.impl.disassemble(jointId, tool, dt) : -1;
+        const o = getObj(objectId);
+        const j = o.jointMap.get(jointId);
+        if (!j || !j.spec.tools.includes(tool)) return -1;
+        if (j.st.open) return 1;
+        return run(() => {
+          j.st.progress = Math.min(1, j.st.progress + (j.spec.seconds > 0 ? dt / j.spec.seconds : 1));
+          if (j.st.progress >= 1 - 1e-9) j.st.progress = 1;
+          const step = Math.floor(j.st.progress * 10 + 1e-9);
+          if (step > j.step || j.st.progress >= 1) {
+            j.step = step;
+            emit({ ...base(o), type: "disassemble_progress", joint: j.spec.id, tool, progress: j.st.progress });
+          }
+          if (j.st.progress >= 1) {
+            j.st.open = true;
+            j.st.openedBy = "tool";
+            solveStructure(o);
+            recomputeGroups(o);
+            detachEvents(o, [j], "tool");
+            collapseCheck(o);
+          }
+          return j.st.progress;
+        }).value;
+      },
+      workableJoints(objectId, tool) {
+        const im = impls.get(objectId);
+        if (im) {
+          const spec = im.impl.describe();
+          return im.impl.state().joints.filter((js) => {
+            const j = (spec.joints ?? []).find((x) => (x.id ?? `${x.a}~${x.b}`) === js.id);
+            return !js.open && !!j && (j.tools ?? JOINT_DEFAULTS[j.kind].tools).includes(tool);
+          });
+        }
+        return getObj(objectId).joints.filter((j) => !j.st.open && j.spec.tools.includes(tool)).map((j) => j.st);
+      },
+      nearestJoint(objectId, point, maxDistance = 0.3, tool) {
+        const im = impls.get(objectId);
+        const cands = [];
+        if (im) {
+          const spec = im.impl.describe();
+          for (const js of im.impl.state().joints) {
+            if (js.open) continue;
+            const pos = implJointPos(im, js.a, js.b);
+            const j = (spec.joints ?? []).find((x) => (x.id ?? `${x.a}~${x.b}`) === js.id);
+            cands.push({ st: js, d: pos ? vec.distance(pos, point) : Infinity, ok: !!j && (j.tools ?? JOINT_DEFAULTS[j.kind].tools).includes(tool) });
+          }
+        } else {
+          const o = getObj(objectId);
+          for (const j of o.joints) {
+            if (j.st.open) continue;
+            cands.push({ st: j.st, d: vec.distance(jointWorld(o, j), point), ok: tool ? j.spec.tools.includes(tool) : true });
+          }
+        }
+        const pick = (only) => {
+          let best = null;
+          let bd = maxDistance;
+          for (const c of cands) {
+            if (only && !c.ok) continue;
+            if (c.d <= bd) {
+              bd = c.d;
+              best = c.st;
+            }
+          }
+          return best;
+        };
+        return (tool ? pick(true) : null) ?? pick(false);
+      },
+      extinguish(objectId, partId, coolC = 200) {
+        const im = impls.get(objectId);
+        if (im) {
+          run(() => im.impl.extinguish?.(partId));
+          return;
+        }
+        const o = getObj(objectId);
+        run(() => {
+          for (const p of partId ? [getPart(o, partId)] : o.parts) {
+            if (isLost(p)) continue;
+            if (p.st.burning) {
+              p.st.burning = false;
+              p.rt.jet = false;
+              emit({ ...base(o), type: "extinguish", part: p.spec.id });
+            }
+            p.st.temperature = Math.max(ambient, p.st.temperature - coolC);
+          }
+          o.active = true;
+        });
+      },
+      setLiters(objectId, partId, liters) {
+        if (impls.has(objectId)) return;
+        const p = getPart(getObj(objectId), partId);
+        if (!p.spec.contains) return;
+        p.st.liters = clamp2(liters, 0, p.spec.contains.liters);
+        getObj(objectId).active = true;
+      },
+      update(dt) {
+        if (!(dt > 0)) return [];
+        return run(() => {
+          time += dt;
+          const sources = [];
+          for (const o of [...objects.values()]) if (o.active) stepObject(o, dt, sources);
+          if (sources.length) spread(sources, dt);
+          for (const im of [...impls.values()]) {
+            if (!im.impl.update) continue;
+            for (const e of im.impl.update(dt) ?? []) emit(e.time === void 0 ? { ...e, time } : e);
+          }
+        }).events;
+      },
+      state: (id) => objects.get(id)?.st ?? impls.get(id)?.impl.state() ?? null,
+      snapshot: (id) => {
+        const st = objects.get(id)?.st ?? impls.get(id)?.impl.state();
+        return st ? clone(st) : null;
+      },
+      part: (id, partId) => objects.get(id)?.byId.get(partId)?.st ?? impls.get(id)?.impl.state().parts.find((p) => p.id === partId) ?? null,
+      reset(id) {
+        const im = impls.get(id);
+        if (im) {
+          im.impl.reset?.();
+          return;
+        }
+        const o = getObj(id);
+        objects.set(id, build(o.spec, id, o.st.position, o.st.rotation));
+      },
+      on(type, fn) {
+        let set = listeners.get(type);
+        if (!set) listeners.set(type, set = /* @__PURE__ */ new Set());
+        set.add(fn);
+        return () => {
+          set.delete(fn);
+        };
+      },
+      serialize() {
+        return {
+          version: 1,
+          time,
+          rng: rng.state(),
+          counter,
+          objects: [...objects.values()].map((o) => {
+            const runtime = { parts: {}, joints: {}, collapsed: [...o.collapsed] };
+            for (const p of o.parts) runtime.parts[p.spec.id] = { ...p.rt };
+            for (const j of o.joints) runtime.joints[j.spec.id] = j.step;
+            return { id: o.id, spec: clone(o.spec), state: clone(o.st), runtime };
+          }),
+          ...impls.size ? { impls: [...impls.values()].map((im) => ({ id: im.impl.id, position: [...im.position], rotation: [...im.rotation], data: im.impl.serialize?.() })) } : {}
+        };
+      },
+      load(snap) {
+        if (snap.version !== 1) throw new Error(`unsupported snapshot version ${String(snap.version)}`);
+        objects.clear();
+        time = snap.time;
+        rng.set(snap.rng);
+        counter = snap.counter ?? 0;
+        for (const e of snap.objects) {
+          const state = clone(e.state);
+          const carry = {
+            parts: new Map(
+              state.parts.map((st) => [st.id, { st, rt: e.runtime?.parts[st.id] ? { ...e.runtime.parts[st.id] } : { ...freshRuntime(), prevTemp: st.temperature } }])
+            ),
+            joints: new Map(state.joints.map((st) => [st.id, { st, step: e.runtime?.joints[st.id] ?? 0 }])),
+            collapsed: e.runtime?.collapsed
+          };
+          objects.set(e.id, build(clone(e.spec), e.id, state.position, state.rotation, carry));
+        }
+        for (const e of snap.impls ?? []) {
+          const im = impls.get(e.id);
+          if (!im) continue;
+          im.position = [e.position[0], e.position[1], e.position[2]];
+          im.rotation = [e.rotation[0], e.rotation[1], e.rotation[2], e.rotation[3]];
+          if (e.data !== void 0) im.impl.load?.(e.data);
+        }
+      }
+    };
+    return world;
+  };
+
+  // src/frame.ts
+  var buildFrame = (o = {}) => {
+    const spanX = o.spanX ?? 8, spanZ = o.spanZ ?? 8;
+    const nx = Math.max(2, o.columnsX ?? 3), nz = Math.max(2, o.columnsZ ?? 3);
+    const H = o.height ?? 3, floors = Math.max(1, o.floors ?? 1);
+    const cs = o.columnSize ?? 0.3, bh = o.beamHeight ?? 0.3, bw = 0.2, T = o.slabThickness ?? 0.2, wt = o.wallThickness ?? 0.2;
+    const dw = o.doorWidth ?? 1, dh = o.doorHeight ?? 2.1;
+    const mat = o.material ?? "concrete", wmat = o.wallMaterial ?? "brick";
+    const roof = o.roof ?? true;
+    const xs = Array.from({ length: nx }, (_, i) => -spanX / 2 + i * spanX / (nx - 1));
+    const zs = Array.from({ length: nz }, (_, j) => -spanZ / 2 + j * spanZ / (nz - 1));
+    const parts = [];
+    const joints = [];
+    const on = (a, b, kind) => joints.push({ id: `${a}~${b}`, a, b, kind, bears: "a_on_b" });
+    for (let i = 0; i < nx; i++) {
+      for (let j = 0; j < nz; j++) {
+        parts.push({
+          id: `foundation_${i}_${j}`,
+          material: mat,
+          shape: { kind: "box", size: [cs * 2.2, 0.3, cs * 2.2] },
+          position: [xs[i], -0.15, zs[j]],
+          structure: { role: "foundation" },
+          anchored: true
+        });
+      }
+    }
+    for (let f = 0; f < floors; f++) {
+      const yb = f * (H + T);
+      const top = yb + H;
+      const last = f === floors - 1;
+      const slabId = last && roof ? "roof" : `slab_${f}`;
+      for (let i = 0; i < nx; i++) {
+        for (let j = 0; j < nz; j++) {
+          const id = `column_${f}_${i}_${j}`;
+          parts.push({
+            id,
+            material: mat,
+            shape: { kind: "box", size: [cs, H, cs] },
+            position: [xs[i], yb + H / 2, zs[j]],
+            structure: o.columnCapacity === void 0 ? { role: "column" } : { role: "column", capacity: o.columnCapacity }
+          });
+          on(id, f === 0 ? `foundation_${i}_${j}` : `slab_${f - 1}`, "rebar");
+        }
+      }
+      const beams = [];
+      const beam = (id, size, pos, c1, c2) => {
+        parts.push({ id, material: mat, shape: { kind: "box", size }, position: pos, structure: { role: "beam" } });
+        on(id, c1, "rebar");
+        on(id, c2, "rebar");
+        beams.push(id);
+      };
+      for (let j = 0; j < nz; j++) {
+        for (let i = 0; i < nx - 1; i++) {
+          beam(`beam_x_${f}_${i}_${j}`, [xs[i + 1] - xs[i] - cs, bh, bw], [(xs[i] + xs[i + 1]) / 2, top - bh / 2, zs[j]], `column_${f}_${i}_${j}`, `column_${f}_${i + 1}_${j}`);
+        }
+      }
+      for (let i = 0; i < nx; i++) {
+        for (let j = 0; j < nz - 1; j++) {
+          beam(`beam_z_${f}_${i}_${j}`, [bw, bh, zs[j + 1] - zs[j] - cs], [xs[i], top - bh / 2, (zs[j] + zs[j + 1]) / 2], `column_${f}_${i}_${j}`, `column_${f}_${i}_${j + 1}`);
+        }
+      }
+      const thick = last && roof ? T * 0.75 : T;
+      parts.push({
+        id: slabId,
+        material: mat,
+        shape: { kind: "box", size: [spanX + cs + 0.2, thick, spanZ + cs + 0.2] },
+        position: [0, top + thick / 2, 0],
+        structure: { role: last && roof ? "roof" : "slab" }
+      });
+      for (const b of beams) on(slabId, b, last && roof ? "resting" : "rebar");
+      if (o.walls) {
+        const wh = H - bh;
+        const wy = yb + wh / 2;
+        const wall = (id, size, pos, supports) => {
+          parts.push({ id, material: wmat, shape: { kind: "box", size }, position: pos, structure: { role: "wall" } });
+          for (const s of supports) on(id, s, "mortar");
+        };
+        for (const j of [0, nz - 1]) {
+          for (let i = 0; i < nx - 1; i++) {
+            const c1 = `column_${f}_${i}_${j}`, c2 = `column_${f}_${i + 1}_${j}`;
+            const avail = xs[i + 1] - xs[i] - cs;
+            if (f === 0 && j === 0 && i === 0 && avail > dw + 0.4) {
+              const side = (avail - dw) / 2;
+              const lx = xs[i] + cs / 2 + side / 2, rx = xs[i + 1] - cs / 2 - side / 2;
+              wall(`wall_door_left`, [side, wh, wt], [lx, wy, zs[j]], [c1]);
+              wall(`wall_door_right`, [side, wh, wt], [rx, wy, zs[j]], [c2]);
+              const lh = wh - dh;
+              wall(`wall_door_lintel`, [dw, lh, wt], [xs[i] + cs / 2 + side + dw / 2, yb + dh + lh / 2, zs[j]], ["wall_door_left", "wall_door_right"]);
+              parts.push({ id: "door", material: "wood_hard", shape: { kind: "box", size: [dw - 0.04, dh, 0.05] }, position: [xs[i] + cs / 2 + side + dw / 2, yb + dh / 2, zs[j]], tags: ["door"] });
+              joints.push({ id: "door~wall_door_left", a: "door", b: "wall_door_left", kind: "hinge", bears: false });
+            } else wall(`wall_x_${f}_${i}_${j}`, [avail, wh, wt], [(xs[i] + xs[i + 1]) / 2, wy, zs[j]], [c1, c2]);
+          }
+        }
+        for (const i of [0, nx - 1]) {
+          for (let j = 0; j < nz - 1; j++) {
+            wall(`wall_z_${f}_${i}_${j}`, [wt, wh, zs[j + 1] - zs[j] - cs], [xs[i], wy, (zs[j] + zs[j + 1]) / 2], [`column_${f}_${i}_${j}`, `column_${f}_${i}_${j + 1}`]);
+          }
+        }
+      }
+    }
+    return { name: "frame", parts, joints, tags: ["structure"] };
+  };
+
+  // src/locale.ts
+  var locales = {
+    en: {
+      materialNames: {
+        steel: "steel",
+        cast_iron: "cast iron",
+        aluminium: "aluminium",
+        copper: "copper",
+        wood_soft: "softwood",
+        wood_hard: "hardwood",
+        plywood: "plywood",
+        mdf: "MDF",
+        glass: "glass",
+        tempered_glass: "tempered glass",
+        ceramic: "ceramic",
+        concrete: "concrete",
+        brick: "brick",
+        plaster: "plaster",
+        stone: "stone",
+        plastic: "plastic",
+        rubber: "rubber",
+        fabric: "fabric",
+        foam: "foam",
+        leather: "leather",
+        paper: "paper",
+        foliage: "foliage",
+        green_wood: "green wood",
+        cactus: "cactus",
+        flesh_fruit: "fruit",
+        wax: "wax",
+        soil: "soil"
+      },
+      partStatus: { intact: "intact", damaged: "damaged", broken: "broken", melted: "melted", ashes: "ashes" },
+      jointKinds: {
+        screw: "screw",
+        bolt: "nut and bolt",
+        nail: "nail",
+        weld: "weld",
+        glue: "glue",
+        hinge: "hinge",
+        clip: "clip",
+        tie: "tie",
+        mortar: "mortar",
+        fused: "fused",
+        stem: "stem",
+        rebar: "rebar",
+        resting: "resting"
+      },
+      toolKinds: {
+        hand: "hand",
+        screwdriver: "screwdriver",
+        wrench: "wrench",
+        pry_bar: "pry bar",
+        saw: "saw",
+        cutting_torch: "cutting torch",
+        knife: "knife",
+        hammer: "hammer"
+      },
+      damageTypes: { ballistic: "ballistic", blunt: "blunt", slash: "slash", explosive: "explosive", fire: "fire", heat: "heat" },
+      eventLabels: {
+        damage: "damage",
+        dent: "dent",
+        hole: "hole",
+        crack: "crack",
+        ricochet: "ricochet",
+        debris: "debris",
+        fracture: "broke",
+        detach: "came loose",
+        disassemble_progress: "taking apart",
+        ignite: "caught fire",
+        extinguish: "put out",
+        burnout: "burned to ash",
+        melt: "melting",
+        drip: "dripping",
+        leak: "leak",
+        explode: "exploded",
+        stress: "overload",
+        collapse: "collapsed",
+        destroyed: "destroyed"
+      },
+      fractureStyles: { shatter: "shatter", crumble: "crumble", splinter: "splinter", tear: "tear", snap: "snap", none: "none" },
+      structureRoles: { foundation: "foundation", column: "column", beam: "beam", slab: "slab", wall: "wall", partition: "partition", roof: "roof", stair: "stairs", none: "none" }
+    },
+    "pt-BR": {
+      materialNames: {
+        steel: "a\xE7o",
+        cast_iron: "ferro fundido",
+        aluminium: "alum\xEDnio",
+        copper: "cobre",
+        wood_soft: "madeira macia",
+        wood_hard: "madeira de lei",
+        plywood: "compensado",
+        mdf: "MDF",
+        glass: "vidro",
+        tempered_glass: "vidro temperado",
+        ceramic: "cer\xE2mica",
+        concrete: "concreto",
+        brick: "tijolo",
+        plaster: "gesso",
+        stone: "pedra",
+        plastic: "pl\xE1stico",
+        rubber: "borracha",
+        fabric: "tecido",
+        foam: "espuma",
+        leather: "couro",
+        paper: "papel",
+        foliage: "folhagem",
+        green_wood: "madeira verde",
+        cactus: "cacto",
+        flesh_fruit: "fruta",
+        wax: "cera",
+        soil: "terra"
+      },
+      partStatus: { intact: "intacto", damaged: "danificado", broken: "quebrado", melted: "derretido", ashes: "cinzas" },
+      jointKinds: {
+        screw: "parafuso",
+        bolt: "porca e parafuso",
+        nail: "prego",
+        weld: "solda",
+        glue: "cola",
+        hinge: "dobradi\xE7a",
+        clip: "encaixe",
+        tie: "amarra\xE7\xE3o",
+        mortar: "argamassa",
+        fused: "fundido",
+        stem: "caule",
+        rebar: "vergalh\xE3o",
+        resting: "apoiado"
+      },
+      toolKinds: {
+        hand: "m\xE3o",
+        screwdriver: "chave de fenda",
+        wrench: "chave inglesa",
+        pry_bar: "p\xE9 de cabra",
+        saw: "serra",
+        cutting_torch: "ma\xE7arico",
+        knife: "faca",
+        hammer: "martelo"
+      },
+      damageTypes: { ballistic: "tiro", blunt: "impacto", slash: "corte", explosive: "explos\xE3o", fire: "fogo", heat: "calor" },
+      eventLabels: {
+        damage: "dano",
+        dent: "amassado",
+        hole: "furo",
+        crack: "trinca",
+        ricochet: "ricochete",
+        debris: "estilha\xE7os",
+        fracture: "quebrou",
+        detach: "soltou",
+        disassemble_progress: "desmontando",
+        ignite: "pegou fogo",
+        extinguish: "apagou",
+        burnout: "virou cinza",
+        melt: "derretendo",
+        drip: "pingando",
+        leak: "vazamento",
+        explode: "explodiu",
+        stress: "sobrecarga",
+        collapse: "desabou",
+        destroyed: "destru\xEDdo"
+      },
+      fractureStyles: { shatter: "estilha\xE7ar", crumble: "esfarelar", splinter: "lascar", tear: "rasgar", snap: "partir", none: "nenhuma" },
+      structureRoles: { foundation: "funda\xE7\xE3o", column: "pilar", beam: "viga", slab: "laje", wall: "parede", partition: "divis\xF3ria", roof: "telhado", stair: "escada", none: "nenhum" }
+    }
+  };
+  var resolveStrings = (locale) => locales[locale ?? "en"] ?? locales.en;
+
+  // ../game-contracts/dist/index.js
+  var IMPACT_CONTRACT = {
+    ballistic: { required: ["type", "point", "direction", "energy", "caliber"], optional: ["space", "source"], note: "bullets and pellets: joules and diameter in millimetres" },
+    blunt: { required: ["type", "point", "energy"], optional: ["direction", "radius", "space", "source"], note: "contact radius in metres (default 3 cm)" },
+    slash: { required: ["type", "point", "energy"], optional: ["direction", "radius", "space", "source"], note: "axes, knives, machetes" },
+    explosive: { required: ["type", "point", "energy", "radius"], optional: ["space", "source"], note: "point is the centre of the blast, radius the range in metres" },
+    fire: { required: ["type", "point", "temperature", "radius"], optional: ["duration", "space", "source"], note: "flame temperature in \xB0C; duration in seconds (call every frame with `dt`)" },
+    heat: { required: ["type", "point", "temperature", "radius"], optional: ["duration", "space", "source"], note: "heat without flame (cutting torch, hot plate)" }
+  };
+  var checkHit = (hit) => {
+    const c = IMPACT_CONTRACT[hit.type];
+    if (!c) return [`unknown damage type "${String(hit.type)}"`];
+    const out = [];
+    for (const f of c.required) {
+      const v = hit[f];
+      if (v === void 0 || (Array.isArray(v) ? v.some((n) => !Number.isFinite(n)) : typeof v === "number" && !Number.isFinite(v))) out.push(`${hit.type} hit needs "${f}"`);
+    }
+    return out;
+  };
+  var finiteJson = (v, path, out) => {
+    if (typeof v === "number") {
+      if (!Number.isFinite(v)) out.push(`${path} is not a finite number`);
+    } else if (Array.isArray(v)) v.forEach((x, i) => finiteJson(x, `${path}[${i}]`, out));
+    else if (v && typeof v === "object") for (const [k, x] of Object.entries(v)) finiteJson(x, `${path}.${k}`, out);
+    else if (typeof v === "function" || typeof v === "symbol" || typeof v === "bigint") out.push(`${path} is not JSON`);
+  };
+  var checkDestructible = (impl, options = {}) => {
+    const problems = [];
+    const known = options.materials ? new Set(options.materials) : null;
+    let spec;
+    try {
+      spec = impl.describe();
+    } catch (e) {
+      return { ok: false, problems: [`describe() threw: ${String(e)}`] };
+    }
+    if (!spec || !Array.isArray(spec.parts) || spec.parts.length === 0) return { ok: false, problems: ["describe() must return at least one part"] };
+    const ids = /* @__PURE__ */ new Set();
+    for (const p of spec.parts) {
+      if (ids.has(p.id)) problems.push(`duplicate part id "${p.id}"`);
+      ids.add(p.id);
+      if (known && !known.has(p.material)) problems.push(`part "${p.id}" has unknown material "${p.material}"`);
+      if (!p.shape || !["box", "cylinder", "sphere"].includes(p.shape.kind)) problems.push(`part "${p.id}" has no valid shape`);
+      if (!Array.isArray(p.position) || p.position.length !== 3) problems.push(`part "${p.id}" has no position`);
+    }
+    const jointIds = /* @__PURE__ */ new Set();
+    for (const j of spec.joints ?? []) {
+      if (!ids.has(j.a) || !ids.has(j.b)) problems.push(`joint "${j.id ?? `${j.a}~${j.b}`}" references an unknown part`);
+      const jid = j.id ?? `${j.a}~${j.b}`;
+      if (jointIds.has(jid)) problems.push(`duplicate joint id "${jid}"`);
+      jointIds.add(jid);
+    }
+    const checkState = (label) => {
+      let st;
+      try {
+        st = impl.state();
+      } catch (e) {
+        problems.push(`state() threw ${label}: ${String(e)}`);
+        return;
+      }
+      const sids = st.parts.map((p) => p.id).sort().join(",");
+      if (sids !== [...ids].sort().join(",")) problems.push(`state() part ids do not match describe() ${label}`);
+      for (const p of st.parts) if (!(p.hp >= 0)) problems.push(`part "${p.id}" has negative or invalid hp ${label}`);
+    };
+    const checkEvents = (events, label) => {
+      if (!Array.isArray(events)) {
+        problems.push(`${label} must return an array`);
+        return;
+      }
+      const evs = events;
+      evs.forEach((e, i) => {
+        if (e.object !== impl.id) problems.push(`${label} event ${i} (${e.type}) has object "${String(e.object)}", expected "${impl.id}"`);
+        const part = e.part;
+        if (part !== void 0 && !ids.has(part)) problems.push(`${label} event ${i} (${e.type}) names unknown part "${part}"`);
+      });
+      const bad = [];
+      finiteJson(evs, "events", bad);
+      problems.push(...bad.map((b) => `${label}: ${b}`));
+      try {
+        const s = JSON.stringify(evs);
+        if (JSON.stringify(JSON.parse(s)) !== s) problems.push(`${label} events do not survive a JSON round trip`);
+      } catch (e) {
+        problems.push(`${label} events are not JSON-serializable: ${String(e)}`);
+      }
+    };
+    checkState("before the hit");
+    const target = spec.parts[0];
+    try {
+      const hit = { type: "ballistic", point: [target.position[0], target.position[1], target.position[2]], direction: [0, 0, -1], energy: 500, caliber: 9 };
+      checkEvents(impl.hit(hit), "hit()");
+    } catch (e) {
+      problems.push(`hit() threw: ${String(e)}`);
+    }
+    checkState("after the hit");
+    if (impl.update) {
+      try {
+        checkEvents(impl.update(0.016), "update()");
+      } catch (e) {
+        problems.push(`update() threw: ${String(e)}`);
+      }
+      checkState("after update");
+    }
+    try {
+      impl.reset?.();
+    } catch (e) {
+      problems.push(`reset() threw: ${String(e)}`);
+    }
+    return { ok: problems.length === 0, problems };
+  };
+
+  // src/contracts.ts
+  var checkDestructible2 = (impl, options = {}) => {
+    const contractOptions = { materials: [...MATERIALS.map((m) => m.id), ...options.materials ?? []] };
+    return checkDestructible(impl, contractOptions);
+  };
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map