@adatechnology/game-test-room 0.5.0 → 0.6.1

package/dist/index.global.js

@@ -134,6 +134,31 @@ var GameTestRoom = (() => {
   var positive = (n) => finite(n) && n > 0;
   var vec3 = (v) => Array.isArray(v) && v.length === 3 && v.every(finite);
   var nonNegative = (n) => n === void 0 || finite(n) && n >= 0;
+  var FACES = ["both", "+", "-"];
+  var BONDS = ["running", "stack"];
+  var checkStagedFields = (p, label, materials, problems) => {
+    const known = (m, what) => {
+      if (materials && !materials.has(m)) problems.push(`${label} ${what} has unknown material "${String(m)}"`);
+    };
+    (p?.layers ?? []).forEach((l, i) => {
+      known(l?.material, `layer ${i}`);
+      if (!positive(l?.thickness)) problems.push(`${label} layer ${i} thickness must be finite and positive`);
+      if (!FACES.includes(l?.faces)) problems.push(`${label} layer ${i} has an invalid faces "${String(l?.faces)}"`);
+    });
+    const r = p?.reinforcement;
+    if (r) {
+      known(r.material, "reinforcement");
+      if (!positive(r.spacing) || !positive(r.diameter)) problems.push(`${label} reinforcement spacing and diameter must be finite and positive`);
+      if (r.residualCapacity !== void 0 && !(finite(r.residualCapacity) && r.residualCapacity >= 0 && r.residualCapacity <= 1)) problems.push(`${label} reinforcement residualCapacity must be between 0 and 1`);
+    }
+    const u = p?.units;
+    if (u) {
+      known(u.mortar, "units mortar");
+      if (!vec3(u.size) || !u.size.every(positive)) problems.push(`${label} units size must be three finite positive numbers`);
+      if (!BONDS.includes(u.bond)) problems.push(`${label} units has an invalid bond "${String(u.bond)}"`);
+    }
+    if (p?.breach && p.breach.area !== void 0 && !positive(p.breach.area)) problems.push(`${label} breach area must be finite and positive`);
+  };
   var checkSpec = (spec, options = {}) => {
     const problems = [];
     const warnings = [];
@@ -166,6 +191,7 @@ var GameTestRoom = (() => {
         if (!nonNegative(p.structure.capacity)) problems.push(`${label} structure capacity must be a finite number >= 0`);
       }
       if (p?.contains && !nonNegative(p.contains.liters)) problems.push(`${label} contains.liters must be a finite number >= 0`);
+      checkStagedFields(p, label, materials, problems);
     }
     const jointIds = /* @__PURE__ */ new Set();
     const edges = [];
@@ -242,6 +268,32 @@ var GameTestRoom = (() => {
     });
     return { ok: problems.length === 0, problems };
   };
+  var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+  var deepMerge = (base, patch) => {
+    if (!patch) return base;
+    const result2 = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+      if (value === void 0 || UNSAFE_KEYS.has(key)) continue;
+      const current = result2[key];
+      result2[key] = isPlainObject(current) && isPlainObject(value) ? deepMerge(current, value) : value;
+    }
+    return result2;
+  };
+  var mergeById = (shipped, extra) => {
+    const entries = /* @__PURE__ */ new Map();
+    for (const entry of [...shipped, ...extra ?? []]) entries.set(entry.id, entry);
+    return entries;
+  };
+  var applyPatches = (entries, patches) => {
+    for (const [id, patch] of Object.entries(patches ?? {})) {
+      const entry = entries.get(id);
+      if (entry) entries.set(id, deepMerge(entry, patch));
+    }
+  };
+  var removeIds = (entries, ids) => {
+    for (const id of ids ?? []) entries.delete(id);
+  };
   var SNAKE_CASE = /^[a-z][a-z0-9_]*$/;
   var finite2 = (n) => typeof n === "number" && Number.isFinite(n);
   function checkControl(control, problems) {
@@ -691,6 +743,147 @@ var GameTestRoom = (() => {
     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;
   };
+  var planeAxes = (thin) => thin === 1 ? [0, 2] : [thin === 0 ? 2 : 0, 1];
+  var unitGrid = (dims, thin, units, cap) => {
+    const [u, v] = planeAxes(thin);
+    let unitU = Math.min(units.size[0], dims[u]), unitV = Math.min(units.size[1], dims[v]);
+    const rowsFor = (h) => Math.ceil(dims[v] / h - 1e-9);
+    const colsFor = (w) => Math.ceil(dims[u] / w - 1e-9) + (units.bond === "running" ? 1 : 0);
+    const merge = Math.ceil(Math.sqrt(rowsFor(unitV) * colsFor(unitU) / cap));
+    if (merge > 1) {
+      unitU = Math.min(unitU * merge, dims[u]);
+      unitV = Math.min(unitV * merge, dims[v]);
+    }
+    const cells = [];
+    for (let row = 0; row < rowsFor(unitV); row++) {
+      const v0 = -dims[v] / 2 + row * unitV, v1 = Math.min(v0 + unitV, dims[v] / 2);
+      const shift = units.bond === "running" && row % 2 === 1 ? unitU / 2 : 0;
+      for (let col = 0; col < colsFor(unitU); col++) {
+        const u0 = Math.max(-dims[u] / 2 + col * unitU - shift, -dims[u] / 2), u1 = Math.min(-dims[u] / 2 + (col + 1) * unitU - shift, dims[u] / 2);
+        if (u1 - u0 < 0.01) continue;
+        const center = [0, 0, 0], size = [0, 0, 0];
+        center[u] = (u0 + u1) / 2;
+        center[v] = (v0 + v1) / 2;
+        size[u] = u1 - u0;
+        size[v] = v1 - v0;
+        size[thin] = dims[thin];
+        cells.push({ center, size });
+      }
+    }
+    return cells;
+  };
+  var planeDistance = (cell, thin, point) => {
+    const [u, v] = planeAxes(thin);
+    const du = cell.center[u] - point[u], dv = cell.center[v] - point[v];
+    return Math.sqrt(du * du + dv * dv);
+  };
+  var cellsWithin = (cells, thin, point, radius) => {
+    const inside = cells.filter((c) => planeDistance(c, thin, point) <= radius);
+    if (inside.length > 0 || cells.length === 0) return inside;
+    return [cells.reduce((best, c) => planeDistance(c, thin, point) < planeDistance(best, thin, point) ? c : best)];
+  };
+  var cellsOutside = (cells, thin, point, radius) => cells.filter((c) => planeDistance(c, thin, point) > radius);
+  var MAX_MARKS_PER_FRAGMENT = 12;
+  var marksInBox = (center, size, rotation, holes) => {
+    const inverse = rotation ? quat.conjugate(rotation) : void 0;
+    const marks = [];
+    for (const hole of holes) {
+      const offset = [hole.point[0] - center[0], hole.point[1] - center[1], hole.point[2] - center[2]];
+      const point = inverse ? rotateVec(inverse, offset) : offset;
+      const inside = point.every((value, k) => Math.abs(value) <= size[k] / 2 + hole.diameter / 2);
+      if (!inside) continue;
+      marks.push({ point, normal: inverse ? rotateVec(inverse, hole.normal) : hole.normal, diameter: hole.diameter });
+      if (marks.length >= MAX_MARKS_PER_FRAGMENT) break;
+    }
+    return marks;
+  };
+  var MAX_SPALLS = 64;
+  var thinAxisOf = (dims) => dims[0] <= dims[1] && dims[0] <= dims[2] ? 0 : dims[1] <= dims[2] ? 1 : 2;
+  var resolveLayer = (def, index, mat) => ({ index, def, mat, energy: mat.penetration * def.thickness * 1e3 });
+  var onFace = (layer, face) => layer.def.faces === "both" || layer.def.faces === (face > 0 ? "+" : "-");
+  var isSpalled = (spalls, layer, face, point) => {
+    for (const s of spalls ?? []) {
+      if (s[0] !== layer || s[1] !== face) continue;
+      const dx = s[2] - point[0], dy = s[3] - point[1], dz = s[4] - point[2];
+      if (dx * dx + dy * dy + dz * dz <= s[5] * s[5]) return true;
+    }
+    return false;
+  };
+  var outerLayer = (layers, spalls, face, point) => layers.find((l) => onFace(l, face) && !isSpalled(spalls, l.index, face, point));
+  var layersEnergy = (layers, spalls, face, point) => {
+    let sum2 = 0;
+    for (const l of layers) if (onFace(l, face) && !isSpalled(spalls, l.index, face, point)) sum2 += l.energy;
+    return sum2;
+  };
+  var layersThickness = (layers, face) => {
+    let sum2 = 0;
+    for (const l of layers) if (onFace(l, face)) sum2 += l.def.thickness;
+    return sum2;
+  };
+  var COVER = 0.03;
+  var MAX_BARS_PER_DIRECTION = 24;
+  var MAX_MEMBER_BARS_PER_SIDE = 6;
+  var STEEL_DENSITY = 7850;
+  var spread = (length3, cover, spacing, cap) => {
+    const room = Math.max(0, length3 - 2 * cover);
+    const count = Math.min(cap, Math.max(2, Math.floor(room / spacing) + 1));
+    const step = count > 1 && room / (count - 1) < spacing ? room / (count - 1) : spacing;
+    return Array.from({ length: count }, (_, i) => (i - (count - 1) / 2) * step);
+  };
+  var bar = (axis, along, fixed) => {
+    const a = [0, 0, 0], b = [0, 0, 0];
+    for (const [index, value] of fixed) {
+      a[index] = value;
+      b[index] = value;
+    }
+    a[axis] = -along;
+    b[axis] = along;
+    return [a, b];
+  };
+  var isMember = (dims) => {
+    const [a = 0, b = 0, c = 0] = [...dims].sort((x, y) => x - y);
+    return b / a < 3 && c / b >= 3;
+  };
+  var rebarBars = (dims, thin, spacing) => {
+    const out = [];
+    if (isMember(dims)) {
+      const long = dims.indexOf(Math.max(...dims));
+      const [u2 = 0, v2 = 0] = [0, 1, 2].filter((i) => i !== long);
+      const us = spread(dims[u2], COVER, spacing, MAX_MEMBER_BARS_PER_SIDE);
+      const vs = spread(dims[v2], COVER, spacing, MAX_MEMBER_BARS_PER_SIDE);
+      us.forEach((x, i) => vs.forEach((y, j) => {
+        if (i === 0 || j === 0 || i === us.length - 1 || j === vs.length - 1) out.push(bar(long, dims[long] / 2 - 0.02, [[u2, x], [v2, y]]));
+      }));
+      return out;
+    }
+    const [u = 0, v = 0] = [0, 1, 2].filter((i) => i !== thin);
+    for (const y of spread(dims[v], COVER, spacing, MAX_BARS_PER_DIRECTION)) out.push(bar(u, dims[u] / 2 - 0.02, [[v, y], [thin, 0]]));
+    for (const x of spread(dims[u], COVER, spacing, MAX_BARS_PER_DIRECTION)) out.push(bar(v, dims[v] / 2 - 0.02, [[u, x], [thin, 0]]));
+    return out;
+  };
+  var clipBarsToDisc = (bars, u, v, center, radius) => {
+    const out = [];
+    for (const [a, b] of bars) {
+      const axis = a[u] !== b[u] ? u : v;
+      const other = axis === u ? v : u;
+      const off = a[other] - center[other === u ? 0 : 1];
+      if (Math.abs(off) >= radius) continue;
+      const half = Math.sqrt(radius * radius - off * off);
+      const mid = center[axis === u ? 0 : 1];
+      const lo = Math.max(Math.min(a[axis], b[axis]), mid - half), hi = Math.min(Math.max(a[axis], b[axis]), mid + half);
+      if (hi - lo < 1e-6) continue;
+      const p = [a[0], a[1], a[2]], q = [b[0], b[1], b[2]];
+      p[axis] = lo;
+      q[axis] = hi;
+      out.push([p, q]);
+    }
+    return out;
+  };
+  var rebarMass = (bars, diameter, density = STEEL_DENSITY) => {
+    let length3 = 0;
+    for (const [a, b] of bars) length3 += Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]) + Math.abs(a[2] - b[2]);
+    return Math.PI * (diameter / 2) * (diameter / 2) * length3 * density;
+  };
   var materials_default = [
     {
       id: "steel",
@@ -1692,9 +1885,19 @@ var GameTestRoom = (() => {
   var DMG_PER_J = 0.02;
   var BLAST_COUPLING = 0.1;
   var FLAMMABLE_FLUIDS = ["gas", "fuel"];
+  var BREACH_RADIUS = 0.55;
+  var BREACH_BLAST_FACTOR = 6;
+  var BREACH_AREA = 0.25;
+  var RESIDUAL_CAPACITY = 0.15;
+  var UNIT_FRAGMENT_FACTOR = 4;
+  var BREACH_GRID_CAP = 4096;
   var CUT_SLICE = 1;
   var cutFactorOf = (shape) => clamp2(Math.max(...shapeDims(shape)) / CUT_SLICE, 1, 50);
   var clamp2 = (v, a, b) => Math.max(a, Math.min(b, v));
+  var capacityScale = (p) => {
+    if (p.st.stripped) return p.spec.reinforcement?.residualCapacity ?? RESIDUAL_CAPACITY;
+    return p.rt.removed ? Math.max(0.05, 1 - p.rt.removed / p.mass0) : 1;
+  };
   var isLost = (p) => p.st.status === "broken" || p.st.status === "melted" || p.st.status === "ashes";
   var clone = (v) => structuredClone(v);
   var overloadRate = (stress) => Math.min(0.6, 0.12 + 0.8 * (stress - 1));
@@ -1717,6 +1920,8 @@ var GameTestRoom = (() => {
     const maxDents = options.maxDents ?? 24;
     const maxHoles = options.maxHoles ?? 32;
     const fireSpread = options.fireSpread ?? 0.6;
+    const breachRadius = options.breach?.radius ?? BREACH_RADIUS;
+    const breachBlastFactor = options.breach?.blastFactor ?? BREACH_BLAST_FACTOR;
     const rng = createRng(options.seed ?? 1);
     const rnd = () => rng.next();
     let time = 0;
@@ -1821,6 +2026,13 @@ var GameTestRoom = (() => {
         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 staged = !!(ps.layers?.length || ps.reinforcement || ps.units || ps.breach);
+        const layers = (ps.layers ?? []).map((l, i) => {
+          const lm = materials.get(l.material);
+          if (!lm) throw new Error(`unknown material "${l.material}" on layer ${i} of part "${ps.id}"`);
+          return resolveLayer(l, i, lm);
+        });
+        if (ps.reinforcement && !materials.has(ps.reinforcement.material)) throw new Error(`unknown material "${ps.reinforcement.material}" on the reinforcement of part "${ps.id}"`);
         const pst = c?.st ?? {
           id: ps.id,
           material: ps.material,
@@ -1836,7 +2048,8 @@ var GameTestRoom = (() => {
           dents: [],
           holes: [],
           cracks: [],
-          group: 0
+          group: 0,
+          ...staged ? { stage: 0 } : {}
         };
         if (!c && ps.contains) pst.liters = ps.contains.liters;
         const p = {
@@ -1855,7 +2068,10 @@ var GameTestRoom = (() => {
           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
+          cap: ps.structure ? partCapacity(ps, mat) : 0,
+          staged,
+          thin: thinAxisOf(shapeDims(ps.shape)),
+          layers
         };
         if (p.structural) o.hasStructure = true;
         if (p.rt.chainDue !== void 0 && !isLost(p)) primed.set(p, o);
@@ -1995,7 +2211,7 @@ var GameTestRoom = (() => {
           o.unsup[i] = o.anyAnchor && !isLost(p);
           continue;
         }
-        p.st.stress = p.st.load / p.cap;
+        p.st.stress = p.st.load / (p.cap * capacityScale(p));
         if (p.st.stress > o.maxStress) o.maxStress = p.st.stress;
       }
       if (o.maxStress > 0.8) o.active = true;
@@ -2014,6 +2230,7 @@ var GameTestRoom = (() => {
           for (const p of ps) {
             o.collapsed.add(p.spec.id);
             p.st.status = "collapsed";
+            setStage(o, p, 3, {}, src);
           }
           emit({ ...base(o, src), type: "collapse", parts: ps.map((p) => p.spec.id), mass: ps.reduce((sum2, p) => sum2 + p.st.mass, 0) });
         }
@@ -2067,6 +2284,7 @@ var GameTestRoom = (() => {
           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 (p.st.opening && insideOpening(o, p, vec.madd(origin, d, r.t0))) 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 };
         }
       }
@@ -2175,6 +2393,7 @@ var GameTestRoom = (() => {
       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 } : {} });
+      setStage(o, p, 1, {}, src);
       return hole;
     };
     const addCrack = (o, p, wp, wn, length3, src) => {
@@ -2183,6 +2402,7 @@ var GameTestRoom = (() => {
       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 });
+      setStage(o, p, 1, {}, src);
     };
     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);
@@ -2231,6 +2451,7 @@ var GameTestRoom = (() => {
       if (split && mine.length) amount /= mine.length;
       for (const j of mine) {
         if (j.st.open) continue;
+        if (j.spec.kind === "rebar" && (o.parts[j.ia].spec.reinforcement || o.parts[j.ib].spec.reinforcement)) continue;
         if (near && jointReach(o, j, near) > Math.max(radius, jointReachLimit(o, j))) continue;
         j.st.hp -= amount;
         if (j.st.hp <= 0) {
@@ -2244,23 +2465,172 @@ var GameTestRoom = (() => {
         }
       }
     };
+    const setStage = (o, p, stage, extra = {}, src) => {
+      if (!p.staged || (p.st.stage ?? 0) >= stage) return;
+      p.st.stage = stage;
+      emit({ ...base(o, src), type: "stage", part: p.spec.id, stage, ...extra });
+    };
+    const faceOf = (o, p, worldNormal) => rotateVec(quat.conjugate(partXf(o, p).q), worldNormal)[p.thin] >= 0 ? 1 : -1;
+    const spallOuter = (o, p, wp, face, normal, radius, src) => {
+      var _a;
+      if (p.layers.length === 0) return;
+      const lp = objLocal(o, wp);
+      const layer = outerLayer(p.layers, p.rt.spalls, face, lp);
+      if (!layer) return;
+      const spalls = (_a = p.rt).spalls ?? (_a.spalls = []);
+      spalls.push([layer.index, face, lp[0], lp[1], lp[2], radius]);
+      if (spalls.length > MAX_SPALLS) spalls.shift();
+      markDamaged(p);
+      emit({ ...base(o, src), type: "spall", part: p.spec.id, layer: layer.index, point: wp, area: Math.PI * radius * radius });
+      debris(o, p, layer.mat.hitDebris, wp, normal, 5, 2, src);
+      setStage(o, p, 1, {}, src);
+    };
+    const insideOpening = (o, p, objectPoint) => {
+      const op = p.st.opening;
+      if (!op) return false;
+      const [u, v] = planeAxes(p.thin);
+      const lp = toLocal(p.pos, p.q, objectPoint);
+      const lc = toLocal(p.pos, p.q, op.center);
+      return Math.hypot(lp[u] - lc[u], lp[v] - lc[v]) <= op.radius;
+    };
+    const breachAreaOf = (p, damage, blast) => damage / (p.mat.hpPerKg * p.mat.density) / Math.max(p.thickness, 5e-3) * (blast ? breachBlastFactor : 1);
+    const localHolesOf = (p) => p.st.holes.map((h) => ({ point: toLocal(p.pos, p.q, h.point), normal: rotateVec(quat.conjugate(p.q), h.normal), diameter: h.diameter }));
+    const unitsOf = (p) => p.spec.units ?? { size: [p.mat.fragmentSize?.[1] ?? 0.2, p.mat.fragmentSize?.[1] ?? 0.2, p.thickness], bond: "stack" };
+    const FRAGMENT_SHAPE = { shatter: "shard", splinter: "splinter", tear: "scrap" };
+    const cellFragments = (o, p, cells, hitW, dir, speed, mass, tag) => {
+      const { c, q } = partXf(o, p);
+      const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
+      const [u, v] = planeAxes(p.thin);
+      const faceArea = (cell) => cell.size[u] * cell.size[v];
+      const total = cells.reduce((sum2, cell) => sum2 + faceArea(cell), 0) || 1;
+      const shape = p.spec.units ? "chunk" : FRAGMENT_SHAPE[p.mat.fracture] ?? "chunk";
+      return cells.map((cell, i) => {
+        const cw = toWorld(c, q, cell.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());
+        const marks = marksInBox(cell.center, cell.size, void 0, holes);
+        return {
+          id: `${p.spec.id}#${tag}${i}`,
+          part: p.spec.id,
+          material: p.spec.material,
+          shape,
+          center: cw,
+          size: [cell.size[0], cell.size[1], cell.size[2]],
+          rotation: q,
+          velocity: [dv[0] * k, dv[1] * k + 0.5 * rnd(), dv[2] * k],
+          angularVelocity: [(rnd() - 0.5) * 8, (rnd() - 0.5) * 8, (rnd() - 0.5) * 8],
+          mass: mass * faceArea(cell) / total,
+          ...marks.length > 0 ? { marks } : {}
+        };
+      });
+    };
+    const worldBars = (o, p, bars) => {
+      const { c, q } = partXf(o, p);
+      return bars.map(([a, b]) => [toWorld(c, q, a), toWorld(c, q, b)]);
+    };
+    const addBreach = (o, p, wp, area, energy, dir, src) => {
+      var _a;
+      if (!p.staged || area <= 0 || (p.st.stage ?? 0) >= 2 || p.st.stripped || isLost(p)) return;
+      const lp = objLocal(o, wp);
+      const list = (_a = p.rt).breach ?? (_a.breach = []);
+      list.push([lp[0], lp[1], lp[2], area]);
+      if (list.length > MAX_SPALLS) list.shift();
+      let total = 0;
+      const sum2 = [0, 0, 0];
+      for (const [x, y, z, a] of list) {
+        if (vec.distance([x, y, z], lp) > breachRadius) continue;
+        total += a;
+        sum2[0] += x * a;
+        sum2[1] += y * a;
+        sum2[2] += z * a;
+      }
+      if (total < (p.spec.breach?.area ?? BREACH_AREA)) return;
+      openBreach(o, p, [sum2[0] / total, sum2[1] / total, sum2[2] / total], total, energy, dir, src);
+    };
+    const openBreach = (o, p, center, total, energy, dir, src) => {
+      const [u, v] = planeAxes(p.thin);
+      const radius = clamp2(Math.sqrt(total / Math.PI), Math.sqrt((p.spec.breach?.area ?? BREACH_AREA) / Math.PI), breachRadius);
+      const lc = toLocal(p.pos, p.q, center);
+      lc[p.thin] = 0;
+      const { c, q } = partXf(o, p);
+      const worldCenter = toWorld(c, q, lc);
+      if (2 * radius >= Math.min(p.dims[u], p.dims[v])) {
+        failPart(o, p, worldCenter, dir, energy, 12, src);
+        return;
+      }
+      const cells = cellsWithin(unitGrid(p.dims, p.thin, unitsOf(p), BREACH_GRID_CAP), p.thin, lc, radius);
+      const removed = p.st.mass * cells.reduce((sum2, cell) => sum2 + cell.size[u] * cell.size[v], 0) / (p.dims[u] * p.dims[v]);
+      const speed = clamp2(Math.sqrt(2 * energy * 0.1 / Math.max(removed, 0.05)), 0.5, 8);
+      const fragments = cellFragments(o, p, cells, worldCenter, dir, speed, removed, "b");
+      const holes = localHolesOf(p);
+      p.st.holes = p.st.holes.filter((_, i) => !cells.some((cell) => marksInBox(cell.center, cell.size, void 0, [holes[i]]).length > 0));
+      p.st.mass = Math.max(0, p.st.mass - removed);
+      p.rt.removed = (p.rt.removed ?? 0) + removed;
+      p.st.opening = { center: objLocal(o, worldCenter), radius };
+      markDamaged(p);
+      setStage(o, p, 1, {}, src);
+      setStage(o, p, 2, { opening: { center: worldCenter, radius }, fragments }, src);
+      debris(o, p, p.mat.breakDebris, worldCenter, vec.scale(dir ?? [0, 1, 0], -1), 14, 3, src);
+      const reinforcement = p.spec.reinforcement;
+      if (reinforcement) {
+        const bars = worldBars(o, p, clipBarsToDisc(rebarBars(p.dims, p.thin, reinforcement.spacing), u, v, [lc[u], lc[v]], radius + 0.05));
+        if (bars.length > 0) emit({ ...base(o, src), type: "expose", part: p.spec.id, bars });
+      }
+      if (p.structural) solveStructure(o);
+    };
+    const stripPart = (o, p, reinforcement, src) => {
+      const bars = rebarBars(p.dims, p.thin, reinforcement.spacing);
+      p.st.stripped = true;
+      p.st.hp = p.st.maxHp;
+      p.st.mass = rebarMass(bars, reinforcement.diameter, materials.get(reinforcement.material)?.density);
+      p.st.holes = [];
+      p.st.burning = false;
+      p.rt.jet = false;
+      markDamaged(p);
+      emit({ ...base(o, src), type: "expose", part: p.spec.id, bars: worldBars(o, p, bars) });
+      solveStructure(o);
+      collapseCheck(o, src);
+    };
+    const unitFragmentPlan = (p, cap) => {
+      const grid = unitGrid(p.dims, p.thin, unitsOf(p), cap);
+      const op = p.st.opening;
+      const cells = op ? cellsOutside(grid, p.thin, toLocal(p.pos, p.q, op.center), op.radius) : grid;
+      const [u, v] = planeAxes(p.thin);
+      return cells.map((cell) => ({ center: cell.center, size: cell.size, q: quat.identity(), shape: "chunk", weight: cell.size[u] * cell.size[v] }));
+    };
+    const loseCage = (o, p, src) => {
+      p.st.status = "broken";
+      p.st.hp = 0;
+      p.st.mass = 0;
+      emit({ ...base(o, src), type: "expose", part: p.spec.id, bars: [] });
+      debris(o, p, "sparks", partXf(o, p).c, [0, 1, 0], 6, 3, src);
+      partLost(o, p, src);
+    };
     const failPart = (o, p, origin, dir, fragEnergy, cap, src) => {
       if (isLost(p)) return;
+      if (p.st.stripped) {
+        loseCage(o, p, src);
+        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({
+      const hitLocal = toLocal(c, q, hitW);
+      const unitPlan = p.spec.units ? unitFragmentPlan(p, maxFragments * UNIT_FRAGMENT_FACTOR) : [];
+      const plan = unitPlan.length > 0 ? unitPlan : planFragments({
         style,
         dims: p.dims,
         thickness: p.thickness,
         grain,
-        hit: toLocal(c, q, hitW),
+        hit: hitLocal,
         fragmentSize: p.mat.fragmentSize ?? [0.04, 0.2],
         maxFragments,
         rnd
       });
+      const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
       const mass = p.st.mass;
       const totW = plan.reduce((s, f) => s + f.weight, 0) || 1;
       const energy = ex ? ex.energy * 0.2 : fragEnergy;
@@ -2270,6 +2640,7 @@ var GameTestRoom = (() => {
         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());
+        const marks = marksInBox(f.center, f.size, f.q, holes);
         return {
           id: `${p.spec.id}#${i}`,
           part: p.spec.id,
@@ -2280,16 +2651,25 @@ var GameTestRoom = (() => {
           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
+          mass: mass * f.weight / totW,
+          ...marks.length > 0 ? { marks } : {}
         };
       });
-      p.st.status = "broken";
-      p.st.hp = 0;
-      p.st.mass = 0;
-      p.st.burning = false;
-      p.rt.jet = false;
+      const reinforcement = p.spec.reinforcement;
+      if (!reinforcement) {
+        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);
+      setStage(o, p, 3, {}, src);
+      if (reinforcement) {
+        stripPart(o, p, reinforcement, src);
+        return;
+      }
       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 });
@@ -2323,10 +2703,17 @@ var GameTestRoom = (() => {
     };
     const ballistic2 = (o, p, entry, n, d, E, caliber, pathLen, src) => {
       const mat = p.mat;
+      if (p.st.stripped || p.st.opening && insideOpening(o, p, objLocal(o, entry))) {
+        return { penetrated: true, exitEnergy: E, exitPoint: vec.madd(entry, d, Math.min(pathLen, p.thickness)), damage: 0 };
+      }
       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 slant = Math.max(sin, 0.3);
+      const effM = p.thickness / slant;
+      const face = p.layers.length > 0 ? faceOf(o, p, n) : 1;
+      const exitLocal = objLocal(o, vec.madd(entry, d, Math.min(pathLen, effM)));
+      const coats = p.layers.length > 0 ? layersEnergy(p.layers, p.rt.spalls, face, objLocal(o, entry)) + layersEnergy(p.layers, p.rt.spalls, -face, exitLocal) : 0;
+      const thr = coats > 0 ? (mat.penetration * p.thickness * 1e3 + coats) / slant : mat.penetration * effM * 1e3;
       const penetrated = E > thr;
       const scale2 = (mat.damageScale?.ballistic ?? 1) * (mat.fracture === "shatter" ? fragility(mat.ductility, p.thickness) : 1);
       const id = p.spec.id;
@@ -2337,13 +2724,16 @@ var GameTestRoom = (() => {
         const dmg2 = applyDamage(o, p, E * DMG_PER_J * scale2 * 0.2, "ballistic", entry, d, E * 0.1, 12, src);
         return { penetrated: false, exitEnergy: 0, damage: dmg2 };
       }
+      if (p.layers.length > 0) spallOuter(o, p, entry, face, n, Math.max(0.03, caliber / 1e3 * 4), src);
       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));
+        exitPoint = vec.madd(entry, d, Math.min(pathLen, effM + layersThickness(p.layers, face) / slant + layersThickness(p.layers, -face) / slant));
         const hole = addHole(o, p, entry, n, caliber / 1e3 * (mat.ductility >= 0.3 ? 1 : 1.5), true, exitPoint, src);
+        if (p.layers.length > 0) spallOuter(o, p, exitPoint, -face, vec.scale(n, -1), Math.max(0.03, caliber / 1e3 * 4), src);
+        addBreach(o, p, entry, Math.PI * (hole.diameter / 2) * (hole.diameter / 2), E, d, src);
         if (brittle && mat.fracture === "shatter") addCrack(o, p, entry, n, crackLen, src);
         if (p.spec.contains && (p.st.liters ?? 0) > 0) {
           emit({
@@ -2388,8 +2778,11 @@ var GameTestRoom = (() => {
       }
       if (kind === "blunt") wearJoints(o, p, E * 0.3, void 0, 0, src);
       else wearJoints(o, p, E * 0.3, point, 0.06, src);
+      if (kind === "blunt" && E > 0 && p.layers.length > 0) spallOuter(o, p, point, faceOf(o, p, n), n, Math.max(contactR, 0.05), src);
       const scale2 = mat.damageScale?.[kind] ?? 1;
-      return applyDamage(o, p, Ec * DMG_PER_J * scale2 * (kind === "slash" ? p.cutFactor : 1), kind, point, d, E * 0.1, 12, src);
+      const done = applyDamage(o, p, Ec * DMG_PER_J * scale2 * (kind === "slash" ? p.cutFactor : 1), kind, point, d, E * 0.1, 12, src);
+      addBreach(o, p, point, breachAreaOf(p, done, false), E, d, src);
+      return done;
     };
     const blastObject = (o, point, energy, radius, src) => {
       const start = cur.length;
@@ -2425,7 +2818,10 @@ var GameTestRoom = (() => {
           }
         }
         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);
+        if (Ein > 20 && p.layers.length > 0) spallOuter(o, p, wp, faceOf(o, p, wn), wn, clamp2(0.05 + Math.sqrt(Ein) * 2e-3, 0.05, 0.4), src);
+        const dealt = applyDamage(o, p, Ein * DMG_PER_J * (mat.damageScale?.explosive ?? 1), "explosive", point, null, Ein * 0.3, 40, src);
+        res.damage += dealt;
+        addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
       }
       res.events = cur.slice(start);
       return res;
@@ -2696,7 +3092,7 @@ var GameTestRoom = (() => {
       }
       o.active = hot;
     };
-    const spread = (sources, dt) => {
+    const spread2 = (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);
@@ -2997,7 +3393,7 @@ var GameTestRoom = (() => {
           time += dt;
           const sources = [];
           for (const o of [...objects.values()]) if (o.active) stepObject(o, dt, sources);
-          if (sources.length) spread(sources, dt);
+          if (sources.length) spread2(sources, dt);
           detonatePrimed(time);
           for (const im of [...impls.values()]) {
             if (!im.impl.update) continue;
@@ -3036,7 +3432,7 @@ var GameTestRoom = (() => {
           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 p of o.parts) runtime.parts[p.spec.id] = clone(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 };
           }),
@@ -3053,7 +3449,7 @@ var GameTestRoom = (() => {
           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 } }])
+              state.parts.map((st) => [st.id, { st, rt: e.runtime?.parts[st.id] ? clone(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
@@ -3250,6 +3646,10 @@ var GameTestRoom = (() => {
         primed: "about to explode",
         stress: "overload",
         collapse: "collapsed",
+        spall: "plaster came off",
+        stage: "damage stage",
+        expose: "rebar bare",
+        body: "body",
         destroyed: "destroyed"
       },
       fractureStyles: { shatter: "shatter", crumble: "crumble", splinter: "splinter", tear: "tear", snap: "snap", none: "none" },
@@ -3332,6 +3732,10 @@ var GameTestRoom = (() => {
         primed: "prestes a explodir",
         stress: "sobrecarga",
         collapse: "desabou",
+        spall: "reboco soltou",
+        stage: "est\xE1gio de dano",
+        expose: "vergalh\xE3o \xE0 mostra",
+        body: "corpo",
         destroyed: "destru\xEDdo"
       },
       fractureStyles: { shatter: "estilha\xE7ar", crumble: "esfarelar", splinter: "lascar", tear: "rasgar", snap: "partir", none: "nenhuma" },
@@ -3396,6 +3800,8 @@ var GameTestRoom = (() => {
       __publicField(this, "v");
       __publicField(this, "w");
       __publicField(this, "rng", createRng2(1374496523));
+      __publicField(this, "markGeometry", null);
+      __publicField(this, "markMaterial", null);
       this.box = new THREE.BoxGeometry(1, 1, 1);
       this.q = new THREE.Quaternion();
       this.dq = new THREE.Quaternion();
@@ -3442,6 +3848,25 @@ var GameTestRoom = (() => {
       }
       return g;
     }
+    /**
+     * Bullet holes that stay on a fragment (`Fragment.marks`): dark discs that are children of its mesh, so they fall, spin and settle with it. The mesh is
+     * a unit box scaled to the fragment, so each disc is scaled back; exact for a mark on a face, which is where a bullet hole is.
+     */
+    addMarks(mesh, f) {
+      if (!f.marks?.length) return;
+      this.markGeometry ?? (this.markGeometry = new this.THREE.CircleGeometry(1, 10));
+      this.markMaterial ?? (this.markMaterial = new this.THREE.MeshBasicMaterial({ color: 723465, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -4, polygonOffsetUnits: -4 }));
+      const sc = mesh.scale;
+      for (const mark of f.marks) {
+        const disc = new this.THREE.Mesh(this.markGeometry, this.markMaterial);
+        const radius = Math.max(4e-3, mark.diameter) * 0.6;
+        const n = this.v.set(mark.normal[0], mark.normal[1], mark.normal[2]).normalize();
+        disc.position.set(mark.point[0] / sc.x + n.x * 2e-3 / sc.x, mark.point[1] / sc.y + n.y * 2e-3 / sc.y, mark.point[2] / sc.z + n.z * 2e-3 / sc.z);
+        disc.quaternion.setFromUnitVectors(this.w.set(0, 0, 1), n);
+        disc.scale.set(radius / sc.x, radius / sc.y, radius / sc.z);
+        mesh.add(disc);
+      }
+    }
     /** Create the mesh of a fragment and start its motion. `maxAllowed` is the live budget. */
     spawn(f, material, home, maxAllowed) {
       const geo = f.shape === "shard" ? this.shardGeometry(hashString(f.id)) : this.box;
@@ -3475,6 +3900,8 @@ var GameTestRoom = (() => {
           alive--;
         }
       }
+      this.addMarks(mesh, f);
+      return mesh;
     }
     /** Add velocity to every fragment within `radius` of a point (blasts). */
     blast(point, radius, speed) {
@@ -3598,6 +4025,8 @@ var GameTestRoom = (() => {
     dispose() {
       this.clear();
       this.box.dispose();
+      this.markGeometry?.dispose();
+      this.markMaterial?.dispose();
       for (const g of this.shardGeos) g?.dispose();
       this.shardGeos = [];
       for (const m of this.materials.values()) m.dispose();
@@ -4342,6 +4771,76 @@ void main() {
       }
     }
   };
+  var RebarCages = class {
+    constructor(THREE, scene, radius = 4e-3) {
+      __publicField(this, "THREE", THREE);
+      __publicField(this, "scene", scene);
+      __publicField(this, "cages", /* @__PURE__ */ new Map());
+      __publicField(this, "geometry");
+      __publicField(this, "material");
+      __publicField(this, "up");
+      __publicField(this, "dir");
+      __publicField(this, "mid");
+      __publicField(this, "q");
+      __publicField(this, "scale");
+      __publicField(this, "m");
+      this.geometry = new THREE.CylinderGeometry(radius, radius, 1, 6);
+      this.material = new THREE.MeshStandardMaterial({ color: 7628380, roughness: 0.55, metalness: 0.6 });
+      this.up = new THREE.Vector3(0, 1, 0);
+      this.dir = new THREE.Vector3();
+      this.mid = new THREE.Vector3();
+      this.q = new THREE.Quaternion();
+      this.scale = new THREE.Vector3();
+      this.m = new THREE.Matrix4();
+    }
+    /** Bars drawn now, over every part. */
+    get count() {
+      let n = 0;
+      for (const mesh of this.cages.values()) n += mesh.count;
+      return n;
+    }
+    /** Meshes of the live cages (tests and picking). */
+    meshes() {
+      return [...this.cages.values()];
+    }
+    /** Draw `bars` (world space) as the cage of `key`; an empty list removes it. */
+    set(key, bars) {
+      this.remove(key);
+      if (bars.length === 0) return;
+      const mesh = new this.THREE.InstancedMesh(this.geometry, this.material, bars.length);
+      bars.forEach(([a, b], i) => {
+        this.dir.set(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+        const length3 = this.dir.length();
+        this.mid.set((a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2);
+        this.q.setFromUnitVectors(this.up, length3 > 1e-9 ? this.dir.divideScalar(length3) : this.up);
+        this.m.compose(this.mid, this.q, this.scale.set(1, Math.max(length3, 1e-4), 1));
+        mesh.setMatrixAt(i, this.m);
+      });
+      mesh.instanceMatrix.needsUpdate = true;
+      mesh.castShadow = true;
+      this.scene.add(mesh);
+      this.cages.set(key, mesh);
+    }
+    remove(key) {
+      const mesh = this.cages.get(key);
+      if (!mesh) return;
+      this.scene.remove(mesh);
+      mesh.dispose();
+      this.cages.delete(key);
+    }
+    /** Remove the cages of every part of `object` (keys are `object|part`). */
+    removeObject(object) {
+      for (const key of [...this.cages.keys()]) if (key.startsWith(`${object}|`)) this.remove(key);
+    }
+    clear() {
+      for (const key of [...this.cages.keys()]) this.remove(key);
+    }
+    dispose() {
+      this.clear();
+      this.geometry.dispose();
+      this.material.dispose();
+    }
+  };
   function partHintOf(value) {
     if (typeof value === "string") return value ? { id: value } : null;
     if (!value || typeof value !== "object") return null;
@@ -4540,6 +5039,7 @@ void main() {
       __publicField(this, "disc", null);
       __publicField(this, "discMat", null);
       __publicField(this, "lineMats", /* @__PURE__ */ new Map());
+      __publicField(this, "patchMats", /* @__PURE__ */ new Map());
     }
     discGeometry() {
       return this.disc ?? (this.disc = new this.THREE.CircleGeometry(1, 14));
@@ -4555,6 +5055,15 @@ void main() {
         polygonOffsetUnits: -4
       }));
     }
+    /** Opaque patch in the colour of what shows under a spalled coat. */
+    patchMaterial(color) {
+      let m = this.patchMats.get(color);
+      if (!m) {
+        m = new this.THREE.MeshBasicMaterial({ color, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -3, polygonOffsetUnits: -3 });
+        this.patchMats.set(color, m);
+      }
+      return m;
+    }
     lineMaterial(color) {
       let m = this.lineMats.get(color);
       if (!m) {
@@ -4567,6 +5076,8 @@ void main() {
       this.disc?.dispose();
       this.discMat?.dispose();
       for (const m of this.lineMats.values()) m.dispose();
+      for (const m of this.patchMats.values()) m.dispose();
+      this.patchMats.clear();
       this.disc = null;
       this.discMat = null;
       this.lineMats.clear();
@@ -4809,9 +5320,9 @@ void main() {
           const n = (Math.imul(v + 1, 2654435761) >>> 0) % 1e3 / 1e3;
           const n2 = (Math.imul(v + 7, 40503) >>> 0) % 1e3 / 1e3;
           const lowness = 1 - (work[i + 1] - minY) / h;
-          const spread = 1 + 0.12 * melt * (0.4 + n2) * (0.3 + lowness);
-          arr[i] = work[i] * spread;
-          arr[i + 2] = work[i + 2] * spread;
+          const spread2 = 1 + 0.12 * melt * (0.4 + n2) * (0.3 + lowness);
+          arr[i] = work[i] * spread2;
+          arr[i + 2] = work[i + 2] * spread2;
           arr[i + 1] = Math.max(minY, work[i + 1] - n * melt * h * 0.08);
         }
       }
@@ -4857,6 +5368,16 @@ void main() {
       disc.renderOrder = 2;
       this.addDecal(mv, { obj: disc });
     }
+    /** A patch where a surface coat came off, in the colour of the core under it; drawn under the bullet holes. */
+    addSpall(mv, worldPoint, worldNormal, radius, color) {
+      const { s, pos, quat: quat2 } = this.decalPose(mv.mesh, worldPoint, worldNormal, 15e-4);
+      const disc = new this.THREE.Mesh(this.kit.discGeometry(), this.kit.patchMaterial(color));
+      disc.position.copy(pos);
+      disc.quaternion.copy(quat2);
+      disc.scale.setScalar(Math.max(0.01, radius) / s);
+      disc.renderOrder = 1;
+      this.addDecal(mv, { obj: disc });
+    }
     /** A star of jagged lines: `rays` rays up to `length` metres, seeded so the same event always draws the same star. */
     addCrack(mv, worldPoint, worldNormal, rays, length3, color, seed) {
       const { s, pos, quat: quat2 } = this.decalPose(mv.mesh, worldPoint, worldNormal, 2e-3);
@@ -5380,6 +5901,7 @@ void main() {
       __publicField(this, "fragments");
       __publicField(this, "ground");
       __publicField(this, "pieceSys");
+      __publicField(this, "cages");
       __publicField(this, "active", /* @__PURE__ */ new Map());
       __publicField(this, "fires", /* @__PURE__ */ new Map());
       __publicField(this, "leaks", []);
@@ -5431,6 +5953,7 @@ void main() {
         max: this.maxFragments,
         life: o.fragmentLife ?? 12
       });
+      this.cages = new RebarCages(THREE, o.scene);
       this.pieceSys = new PieceSystem(THREE, {
         groundAt: this.groundAt,
         gravity: this.gravity,
@@ -5732,6 +6255,15 @@ void main() {
             this.sound("ignite", ev.point, 0.7);
           }
           break;
+        case "spall":
+          this.onSpall(ev);
+          break;
+        case "stage":
+          this.onStage(ev);
+          break;
+        case "expose":
+          this.cages.set(`${ev.object}|${ev.part}`, ev.bars);
+          break;
         case "extinguish": {
           const f = this.fires.get(`${ev.object}|${ev.part}`);
           if (f) {
@@ -5897,6 +6429,43 @@ void main() {
       }
       this.sound(impactKey(def), ev.worldPoint, 0.5);
     }
+    /** Outward normal of the face of `mv` nearest to a world point: the thin axis of its world box (right for a wall; a sloped face is left to the vertex-range binding). */
+    faceNormal(mv, point) {
+      const box2 = this.visuals.worldBox(mv, this.box);
+      const size = box2.getSize(this.v1);
+      const axis = size.x <= size.y && size.x <= size.z ? "x" : size.y <= size.z ? "y" : "z";
+      const side = point[axis] >= (box2.min[axis] + box2.max[axis]) / 2 ? 1 : -1;
+      return new this.THREE.Vector3(axis === "x" ? side : 0, axis === "y" ? side : 0, axis === "z" ? side : 0);
+    }
+    /** A coat came off: a patch in the colour of the core under it, below the bullet holes and cracks. */
+    onSpall(ev) {
+      const pv = this.partVis(ev.object, ev.part);
+      if (!pv) return;
+      const wp = new this.THREE.Vector3(ev.point[0], ev.point[1], ev.point[2]);
+      const mv = this.nearestMesh(pv, wp);
+      if (!mv) return;
+      const def = this.world.materials.get(pv.material);
+      this.visuals.addSpall(mv, wp, this.faceNormal(mv, wp), Math.sqrt(ev.area / Math.PI), fallbackColor(pv.material, def));
+    }
+    /**
+     * Stage 2 of a staged part: the unit-sized fragments come out and the part stays drawn (hiding it is what `fracture` does). The opening itself
+     * (cutting the wall's faces) is not drawn yet: it needs the per-vertex binding of the house renderer.
+     */
+    onStage(ev) {
+      if (!ev.fragments || !ev.opening) return;
+      const pv = this.partVis(ev.object, ev.part);
+      const def = pv ? this.world.materials.get(pv.material) : void 0;
+      const color = (pv ? this.partColor(pv, def) : null) ?? fallbackColor(pv?.material ?? "", def);
+      const maxAlive = this.low ? Math.floor(this.maxFragments / 2) : this.maxFragments;
+      const step = this.low ? 2 : 1;
+      for (let i = 0; i < ev.fragments.length; i += step) {
+        const fr = ev.fragments[i];
+        const fdef = this.world.materials.get(fr.material);
+        this.fragments.spawn(fr, this.fragments.materialFor(fr.material, fdef === def || !fdef ? color : fallbackColor(fr.material, fdef), false), ev.object, maxAlive);
+      }
+      this.particles.burst("dust", ev.opening.center, [0, 1, 0], 14, 1.2, { color });
+      this.sound(impactKey(def), ev.opening.center, 0.8);
+    }
     onFracture(ev) {
       const b = this.bounds.get(ev.object);
       const pv = b?.parts.get(ev.part);
@@ -6053,8 +6622,8 @@ void main() {
         const speed = Math.min(30, Math.sqrt(2 * ev.energy * 0.02 / pc.mass)) * fall;
         const inv = d > 1e-4 ? 1 / d : 0;
         const dir = d > 1e-4 ? [dx * inv, dy * inv + 0.3, dz * inv] : [0, 1, 0];
-        const spread = pc.halfExtents[0];
-        this.pieceSys.impulse(pc, [dir[0] * speed * pc.mass, dir[1] * speed * pc.mass, dir[2] * speed * pc.mass], [c.x + (this.rng() - 0.5) * spread, c.y + spread * 0.5, c.z + (this.rng() - 0.5) * spread]);
+        const spread2 = pc.halfExtents[0];
+        this.pieceSys.impulse(pc, [dir[0] * speed * pc.mass, dir[1] * speed * pc.mass, dir[2] * speed * pc.mass], [c.x + (this.rng() - 0.5) * spread2, c.y + spread2 * 0.5, c.z + (this.rng() - 0.5) * spread2]);
       }
       this.fragments.blast(p, ev.radius, Math.min(20, Math.sqrt(ev.energy) * 0.08));
       this.sound("explode", p, clamp3(0.5 + ev.radius / 10, 0.5, 1));
@@ -6207,6 +6776,7 @@ void main() {
       for (const home of homes) {
         this.fragments.removeHome(home);
         this.ground.removeHome(home);
+        this.cages.removeObject(home);
       }
     }
     restoreHome(home) {
@@ -6243,6 +6813,7 @@ void main() {
       }
       this.fragments.clear();
       this.ground.clear();
+      this.cages.clear();
       this.particles.clear();
       if (this.light) {
         this.light.intensity = 0;
@@ -6253,6 +6824,9 @@ void main() {
     stats() {
       return { fragments: this.fragments.count, particles: this.particles.live, pieces: this.pieceSys.list.length, decals: this.visuals.decalCount + this.ground.count };
     }
+    rebarCount() {
+      return this.cages.count;
+    }
     dispose() {
       if (this.disposed) return;
       this.unsubscribe();
@@ -6260,6 +6834,7 @@ void main() {
       for (const id of [...this.bounds.keys()]) this.unbind(id);
       this.fragments.dispose();
       this.ground.dispose();
+      this.cages.dispose();
       this.particles.dispose();
       this.visuals.dispose();
       this.light?.dispose?.();
@@ -17340,6 +17915,207 @@ void main() {
     if (context.isCompatible && !context.isCompatible(def, attachment, fitted)) return { ok: false, reason: "rejected" };
     return { ok: true, mount: place.kind };
   };
+  var melee_weapons_default = [
+    {
+      id: "tactical_knife",
+      name: "Tactical knife",
+      category: "melee_blade",
+      action: {
+        kind: "melee",
+        damage: "slash",
+        energy: 45,
+        radius: 0.03,
+        reach: 0.6,
+        rpm: 100,
+        noise: 1
+      },
+      mass: 0.3
+    },
+    {
+      id: "meat_cleaver",
+      name: "Meat cleaver",
+      category: "melee_blade",
+      action: {
+        kind: "melee",
+        damage: "slash",
+        energy: 120,
+        radius: 0.05,
+        reach: 0.6,
+        rpm: 70,
+        noise: 2
+      },
+      mass: 0.6
+    },
+    {
+      id: "hatchet",
+      name: "Hatchet",
+      category: "melee_blade",
+      action: {
+        kind: "melee",
+        damage: "slash",
+        energy: 180,
+        radius: 0.06,
+        reach: 0.7,
+        rpm: 55,
+        noise: 2
+      },
+      mass: 0.8
+    },
+    {
+      id: "nail_bat",
+      name: "Nail bat",
+      category: "melee_blunt",
+      action: {
+        kind: "melee",
+        damage: "blunt",
+        energy: 170,
+        radius: 0.1,
+        reach: 1,
+        rpm: 60,
+        noise: 3
+      },
+      mass: 1.2
+    },
+    {
+      id: "iron_pipe",
+      name: "Iron pipe",
+      category: "melee_blunt",
+      action: {
+        kind: "melee",
+        damage: "blunt",
+        energy: 140,
+        radius: 0.06,
+        reach: 1,
+        rpm: 60,
+        noise: 4
+      },
+      mass: 1.2
+    },
+    {
+      id: "pickaxe",
+      name: "Pickaxe",
+      category: "melee_blade",
+      action: {
+        kind: "melee",
+        damage: "slash",
+        energy: 260,
+        radius: 0.05,
+        reach: 1,
+        rpm: 40,
+        noise: 4
+      },
+      mass: 2.8,
+      tags: [
+        "heavy"
+      ]
+    },
+    {
+      id: "sickle",
+      name: "Sickle",
+      category: "melee_blade",
+      action: {
+        kind: "melee",
+        damage: "slash",
+        energy: 70,
+        radius: 0.05,
+        reach: 1.1,
+        rpm: 70,
+        noise: 2
+      },
+      mass: 1.2
+    },
+    {
+      id: "police_baton",
+      name: "Police baton",
+      category: "melee_blunt",
+      action: {
+        kind: "melee",
+        damage: "blunt",
+        energy: 70,
+        radius: 0.04,
+        reach: 0.7,
+        rpm: 90,
+        noise: 3
+      },
+      mass: 0.6
+    },
+    {
+      id: "cast_iron_skillet",
+      name: "Cast iron skillet",
+      category: "melee_blunt",
+      action: {
+        kind: "melee",
+        damage: "blunt",
+        energy: 110,
+        radius: 0.12,
+        reach: 0.6,
+        rpm: 60,
+        noise: 8
+      },
+      mass: 1.2
+    },
+    {
+      id: "improvised_spear",
+      name: "Improvised spear",
+      category: "melee_blade",
+      action: {
+        kind: "melee",
+        damage: "slash",
+        energy: 90,
+        radius: 0.02,
+        reach: 1.6,
+        rpm: 50,
+        noise: 1
+      },
+      mass: 1.1
+    },
+    {
+      id: "chainsaw",
+      name: "Chainsaw",
+      category: "melee_blade",
+      action: {
+        kind: "melee",
+        damage: "slash",
+        energy: 400,
+        radius: 0.1,
+        reach: 0.9,
+        rpm: 300,
+        noise: 120
+      },
+      mass: 6,
+      tags: [
+        "heavy"
+      ]
+    },
+    {
+      id: "recurve_bow",
+      name: "Recurve bow",
+      category: "bow",
+      action: {
+        kind: "firearm",
+        caliber: "arrow",
+        rpm: 20,
+        modes: [
+          "single"
+        ],
+        magazine: 1,
+        reload: 1.5,
+        barrel: 1,
+        spreadDeg: 0.4,
+        bloomDeg: 0.4,
+        recoveryDegPerS: 2,
+        recoil: [
+          0.3,
+          0.1
+        ],
+        range: 40
+      },
+      mass: 1.2,
+      tags: [
+        "silent"
+      ]
+    }
+  ];
   var findDuplicateIds = (kind, entries) => {
     const seen = /* @__PURE__ */ new Set();
     const problems = [];
@@ -17424,18 +18200,6 @@ void main() {
     ...[...explosives.values()].flatMap(checkExplosiveNumbers),
     ...checkRuleDefaults(rules)
   ];
-  var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-  var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
-  var deepMerge = (base, patch) => {
-    if (!patch) return base;
-    const result2 = { ...base };
-    for (const [key, value] of Object.entries(patch)) {
-      if (value === void 0 || UNSAFE_KEYS.has(key)) continue;
-      const current = result2[key];
-      result2[key] = isPlainObject(current) && isPlainObject(value) ? deepMerge(current, value) : value;
-    }
-    return result2;
-  };
   var modesEn = { single: "single action", semi: "semi-automatic", burst: "burst", auto: "automatic", pump: "pump action", bolt: "bolt action", lever: "lever action", break: "break action", volley: "volley" };
   var categoriesEn = {
     pistol: "pistol",
@@ -17627,20 +18391,6 @@ void main() {
     if (explosive.fuseRange) return explosive.fuseRange[0] + (explosive.fuseRange[1] - explosive.fuseRange[0]) * random();
     return explosive.fuse;
   };
-  var mergeById = (shipped, extra) => {
-    const entries = /* @__PURE__ */ new Map();
-    for (const entry of [...shipped, ...extra ?? []]) entries.set(entry.id, entry);
-    return entries;
-  };
-  var applyPatches = (entries, patches) => {
-    for (const [id, patch] of Object.entries(patches ?? {})) {
-      const entry = entries.get(id);
-      if (entry) entries.set(id, deepMerge(entry, patch));
-    }
-  };
-  var removeIds = (entries, ids) => {
-    for (const id of ids ?? []) entries.delete(id);
-  };
   var resolveThrowables = (weapons, explosives) => {
     for (const [id, def] of weapons) {
       if (def.action.kind !== "throwable" || def.action.explosive === void 0) continue;
@@ -18864,8 +19614,8 @@ void main() {
         return energy * f * f;
       };
       const bloomNow = this.extraAt(t);
-      const spread = a.spreadDeg + bloomNow;
-      const aim = sampleCone(dir, spread, this.rng);
+      const spread2 = a.spreadDeg + bloomNow;
+      const aim = sampleCone(dir, spread2, this.rng);
       const pellets = cal.pellets ?? 1;
       const pelletSpread = pellets > 1 ? a.pelletSpreadDeg ?? 3 : 0;
       for (let p = 0; p < pellets; p++) {
@@ -18876,6 +19626,7 @@ void main() {
           caliber: cal.diameter,
           caliberId: cal.id,
           speed,
+          mass: cal.bulletGrams,
           energyAt,
           pellet: p,
           weapon: this.def.id
@@ -19061,7 +19812,7 @@ void main() {
   var EXPLOSIVES = explosives_default;
   var ARCHETYPES = archetypes_default;
   var ARCHETYPE_IDS = ARCHETYPES.map((def) => def.id);
-  var WEAPONS = [...ARCHETYPES, ...firearms_default, ...launchers_default, ...explosive_weapons_default];
+  var WEAPONS = [...ARCHETYPES, ...firearms_default, ...launchers_default, ...explosive_weapons_default, ...melee_weapons_default];
   var DEFAULT_LOADOUT = [
     "hand",
     "kick",
@@ -25509,19 +26260,19 @@ void main() {
         const dd = mk("dd");
         const text = mk("span", void 0, row.text);
         dd.appendChild(text);
-        let bar = null;
+        let bar2 = null;
         if (row.ratio !== void 0) {
-          bar = mk("div", "tr-bar");
-          bar.appendChild(mk("i"));
-          dd.appendChild(bar);
+          bar2 = mk("div", "tr-bar");
+          bar2.appendChild(mk("i"));
+          dd.appendChild(bar2);
         }
         metricList.append(mk("dt", void 0, row.name), dd);
-        metricNodes.set(row.id, { text, bar });
+        metricNodes.set(row.id, { text, bar: bar2 });
       }
     };
-    const fillBar = (bar, ratio) => {
-      bar.className = `tr-bar${ratio > 1 ? " bad" : ratio >= 0.8 ? " warn" : ""}`;
-      const fill = bar.firstElementChild;
+    const fillBar = (bar2, ratio) => {
+      bar2.className = `tr-bar${ratio > 1 ? " bad" : ratio >= 0.8 ? " warn" : ""}`;
+      const fill = bar2.firstElementChild;
       fill.style.width = `${Math.round(Math.max(0, Math.min(1, ratio)) * 100)}%`;
     };
     return {
@@ -25576,6 +26327,10 @@ void main() {
 .tr-search{width:100%;margin:0 0 6px;padding:5px 8px;border-radius:5px;border:1px solid #3a404c;background:#0f1116;color:#e8eaee;font:inherit}
 .tr-search::placeholder{color:#7d8594}
 .tr-item small{color:#7d8594;margin-left:4px}
+.tr-thumb{display:block;width:100%;height:26px;background:currentColor;-webkit-mask:var(--tr-thumb) center/contain no-repeat;mask:var(--tr-thumb) center/contain no-repeat}
+.tr-item{min-width:0}
+.tr-item .tr-btn.has-thumb{display:flex;flex-direction:column;gap:3px;min-width:0}.tr-item .tr-btn.has-thumb .tr-name{overflow:hidden;text-overflow:ellipsis}
+.tr-insp .tr-thumb{width:140px;height:28px;margin-bottom:3px}
 .tr-empty{color:#9aa3b2;padding:4px 2px;grid-column:1/-1}
 .tr-cross{position:absolute;left:50%;top:50%;width:18px;height:18px;margin:-9px 0 0 -9px}
 .tr-cross:before,.tr-cross:after{content:"";position:absolute;background:#fff;opacity:.85;box-shadow:0 0 2px #000}
@@ -25641,6 +26396,17 @@ void main() {
     if (text !== void 0) e.textContent = text;
     return e;
   };
+  var thumbSource = (thumbnail) => {
+    const source = thumbnail.trim().startsWith("<") ? `data:image/svg+xml,${encodeURIComponent(thumbnail.trim())}` : thumbnail.trim();
+    return source.replace(/["\\\n\r]/g, (char) => encodeURIComponent(char));
+  };
+  var thumb = (thumbnail, credit) => {
+    const e = mk2("span", "tr-thumb");
+    if (credit) e.title = credit;
+    else e.setAttribute("aria-hidden", "true");
+    e.style.setProperty("--tr-thumb", `url("${thumbSource(thumbnail)}")`);
+    return e;
+  };
   function createUi(o) {
     const { t } = o;
     const style = mk2("style");
@@ -25794,7 +26560,8 @@ void main() {
       if (!found.length) items.appendChild(mk2("div", "tr-empty", t("ui.no_results")));
       for (const { item: it, group } of found) {
         const wrap = mk2("div", "tr-item");
-        const b = mk2("button", "tr-btn", it.name);
+        const b = mk2("button", it.thumbnail ? "tr-btn has-thumb" : "tr-btn", it.thumbnail ? void 0 : it.name);
+        if (it.thumbnail) b.append(thumb(it.thumbnail), mk2("span", "tr-name", it.name));
         if (searching) b.appendChild(mk2("small", void 0, group));
         b.type = "button";
         b.title = it.note ?? it.name;
@@ -25930,7 +26697,7 @@ void main() {
     };
     toggle.onclick = togglePanels;
     root.append(cross4, top, bottom, help, left, right, toggle);
-    const bar = (value, max, cls) => {
+    const bar2 = (value, max, cls) => {
       const b = mk2("div", `tr-bar ${cls}`);
       const i = mk2("i");
       i.style.width = `${Math.max(0, Math.min(100, value / Math.max(1e-9, max) * 100))}%`;
@@ -25953,12 +26720,13 @@ void main() {
         insp.appendChild(mk2("div", void 0, t("ui.aim_at_something")));
         return;
       }
+      if (i.thumbnail) insp.appendChild(thumb(i.thumbnail, i.thumbnailCredit));
       insp.appendChild(mk2("div", "t", `${i.object} \u203A ${i.part}`));
       insp.appendChild(row(t("ins.material"), i.material));
       insp.appendChild(row(t("ins.status"), i.status + (i.burning ? ` \xB7 ${t("ins.burning")}` : "")));
       insp.appendChild(row(t("ins.hp"), `${num(i.hp, 0)} / ${num(i.maxHp, 0)}`));
       const frac = i.hp / Math.max(1e-9, i.maxHp);
-      insp.appendChild(bar(i.hp, i.maxHp, frac < 0.25 ? "bad" : frac < 0.6 ? "warn" : "hp"));
+      insp.appendChild(bar2(i.hp, i.maxHp, frac < 0.25 ? "bad" : frac < 0.6 ? "warn" : "hp"));
       insp.appendChild(row(t("ins.temperature"), `${num(i.temperature, 0)} \xB0C`));
       if (i.char > 0.01) insp.appendChild(row(t("ins.char"), `${num(i.char * 100, 0)} %`));
       if (i.melt > 0.01) insp.appendChild(row(t("ins.melt"), `${num(i.melt * 100, 0)} %`));
@@ -25969,7 +26737,7 @@ void main() {
       if (i.load !== void 0) insp.appendChild(row(t("ins.load"), `${num(i.load, 0)} kg`));
       if (i.stress !== void 0) {
         insp.appendChild(row(t("ins.stress"), `${num(i.stress * 100, 0)} %`));
-        insp.appendChild(bar(Math.min(i.stress, 1.2), 1.2, i.stress > 1 ? "bad" : i.stress > 0.7 ? "warn" : "hp"));
+        insp.appendChild(bar2(Math.min(i.stress, 1.2), 1.2, i.stress > 1 ? "bad" : i.stress > 0.7 ? "warn" : "hp"));
       }
       if (i.joints.length) {
         insp.appendChild(mk2("div", void 0, t("ins.joints") + ":"));
@@ -27324,6 +28092,8 @@ void main() {
         stress: ext.stress,
         joints,
         note: e?.item?.note,
+        thumbnail: e?.item?.thumbnail,
+        thumbnailCredit: e?.item?.thumbnailCredit,
         distance: r.distance
       };
     };
@@ -27723,7 +28493,9 @@ void main() {
           fluid: ti.fluid,
           weapon: ti.weapon,
           impl: ti.impl,
-          animations: ti.animations
+          animations: ti.animations,
+          thumbnail: ti.thumbnail,
+          thumbnailCredit: ti.thumbnailCredit
         };
         catalogMap.set(item.id, item);
         const at = catalog.findIndex((c) => c.id === item.id);