@adatechnology/game-destruction 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,3034 @@
+// 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;
+
+// src/contracts.ts
+import { checkDestructible as check } from "@adatechnology/game-contracts";
+import { IMPACT_CONTRACT, checkHit } from "@adatechnology/game-contracts";
+var checkDestructible = (impl, options = {}) => {
+  const contractOptions = { materials: [...MATERIALS.map((m) => m.id), ...options.materials ?? []] };
+  return check(impl, contractOptions);
+};
+export {
+  IMPACT_CONTRACT,
+  JOINT_BY_MATERIALS,
+  JOINT_DEFAULTS,
+  MATERIALS,
+  buildFrame,
+  checkDestructible,
+  checkHit,
+  createDestruction,
+  fragility,
+  guessMaterial,
+  inferJoints,
+  locales,
+  partCapacity,
+  partMass,
+  partThickness,
+  partVolume,
+  quat,
+  quatFromEuler,
+  resolveStrings,
+  rotateVec,
+  toLocal,
+  toWorld,
+  vec
+};
+//# sourceMappingURL=index.js.map