@adatechnology/game-weapons-three 0.10.4 → 0.11.1

package/dist/index.global.js

@@ -19264,26 +19264,26 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const e of planned.items) if (e.type === "wall_switch") e.lit = (e.connections.controls || []).some((id) => (planned.items.find((x) => x.id === id) || {}).lit === true);
       }
       for (const e of planned.items) if (e.type === "lantern_lamp") e.item.on = !!e.lit;
-      let scratch = null;
+      let scratch2 = null;
       function probe(e, hinge, setback) {
-        if (!scratch) scratch = GI.createWorld({ locale, strings: hh.strings, items: hh.items, loot: hh.loot, grid: false });
+        if (!scratch2) scratch2 = GI.createWorld({ locale, strings: hh.strings, items: hh.items, loot: hh.loot, grid: false });
         const it = e.item;
         const x = it.x + Math.sin(it.ry) * setback;
         const z = it.z + Math.cos(it.ry) * setback;
         const spec = hh.build(e.type, Object.assign({}, it, { hinge }), HH.createRecorder().api);
-        scratch.add("__probe", spec, { x, y: e.floorY, z, ry: it.ry });
+        scratch2.add("__probe", spec, { x, y: e.floorY, z, ry: it.ry });
         const blocks = (px, pz) => isBlocked2(px, pz, e.floor);
         let sum2 = 0;
         let min2 = 1;
         let n = 0;
         for (const p of spec.parts || []) {
           if (p.motion.kind !== "hinge" || !(p.bounds || p.sweep)) continue;
-          const t = scratch.fitSweep("__probe", p.id, blocks);
+          const t = scratch2.fitSweep("__probe", p.id, blocks);
           sum2 += t;
           min2 = Math.min(min2, t);
           n++;
         }
-        scratch.remove("__probe");
+        scratch2.remove("__probe");
         return { sum: sum2, min: min2, n };
       }
       const better = (a, b) => a.sum > b.sum + 1e-9 || Math.abs(a.sum - b.sum) <= 1e-9 && a.min > b.min + 1e-9;
@@ -21972,6 +21972,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var FLAMMABLE_FLUIDS = ["gas", "fuel"];
   var VENT_DIAMETER = 8e-3;
   var FLAME_LIGHTS_LEAK_C = 470;
+  var RESTING_HOLD_COS = Math.cos(Math.PI / 6);
   var BREACH_RADIUS = 0.55;
   var BREACH_BLAST_FACTOR = 6;
   var BREACH_AREA = 0.25;
@@ -21987,6 +21988,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var BREACH_GRID_CAP = 4096;
   var CHIP_ENERGY = 200;
   var CHIP_SPLASH = 0.5;
+  var CRATER_SPENT = 0.6;
   var BAR_BOW = 0.08;
   var BULLET_JOINT_SPAN = 0.3;
   var CUT_SLICE = 1;
@@ -22007,12 +22009,22 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const cells = p.st.chipped;
     if (!cells?.length) return 0;
     const [u, v] = planeAxes(p.thin);
-    const along = p.dims[u] >= p.dims[v] ? u : v;
+    const role = p.spec.structure?.role;
+    const up = rotateVec(p.q, [0, 0, 0].map((_, k) => k === v ? 1 : 0));
+    const upright = Math.abs(up[1]) > 0.7 ? v : Math.abs(rotateVec(p.q, [0, 0, 0].map((_, k) => k === u ? 1 : 0))[1]) > 0.7 ? u : -1;
+    const along = (role === "wall" || role === "partition" || role === "column") && upright >= 0 ? upright : p.dims[u] >= p.dims[v] ? u : v;
     const across2 = along === u ? v : u;
     let worst = 0;
     for (const c of cells) {
-      let gone = 0;
-      for (const d of cells) if (Math.abs(d.center[along] - c.center[along]) < d.size[along] / 2 + 1e-6) gone += d.size[across2];
+      const spans = [];
+      for (const d of cells) if (Math.abs(d.center[along] - c.center[along]) < d.size[along] / 2 + 1e-6) spans.push([d.center[across2] - d.size[across2] / 2, d.center[across2] + d.size[across2] / 2]);
+      spans.sort((a, b) => a[0] - b[0]);
+      let gone = 0, end3 = -Infinity;
+      for (const [a, b] of spans) {
+        if (b <= end3) continue;
+        gone += b - Math.max(a, end3);
+        end3 = b;
+      }
       worst = Math.max(worst, gone / Math.max(p.dims[across2], 1e-6));
     }
     return Math.min(1, worst);
@@ -22308,7 +22320,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (k < 0 || j.spec.kind !== "tie") return k;
       return partXf(o, o.parts[k]).c[1] > partXf(o, o.parts[r]).c[1] + 1e-6 ? k : -1;
     };
+    let poseVersion = 0;
+    const contactMemo = /* @__PURE__ */ new WeakMap();
     const contactBox = (p, support) => {
+      let byTouching = contactMemo.get(p);
+      if (!byTouching) contactMemo.set(p, byTouching = /* @__PURE__ */ new Map());
+      const known = byTouching.get(support);
+      if (known && known.version === poseVersion) return known.box;
+      const box5 = measureContact(p, support);
+      byTouching.set(support, { version: poseVersion, box: box5 });
+      return box5;
+    };
+    const measureContact = (p, support) => {
       const A = aabbOf(p.spec.shape, p.pos, p.q), B = aabbOf(support.spec.shape, support.pos, support.q);
       const lo = [0, 0, 0], hi = [0, 0, 0];
       for (let k = 0; k < 3; k++) {
@@ -23103,7 +23126,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       p.st.holes.push(hole);
       if (p.st.holes.length > maxHoles) p.st.holes.shift();
       markDamaged(p);
-      emit2({ ...base(o, src), type: "hole", part: p.spec.id, hole, worldPoint: wp, ...exit ? { exitPoint: exit } : {} });
+      emit2({ ...base(o, src), type: "hole", part: p.spec.id, hole, worldPoint: wp, ...exit ? { exitPoint: exit } : {}, ...p.spec.powder ? { powder: { ...p.spec.powder } } : {} });
       setStage(o, p, 1, {}, src);
       return hole;
     };
@@ -23120,6 +23143,22 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const detachEvents = (o, opened, by, src) => {
       for (const j of opened) emit2({ ...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 slideOffResting = (o, rotation) => {
+      const upY = 1 - 2 * (rotation[0] * rotation[0] + rotation[2] * rotation[2]);
+      if (upY >= RESTING_HOLD_COS) return;
+      const opened = o.joints.filter((j) => j.spec.kind === "resting" && !j.st.open);
+      if (opened.length === 0) return;
+      run(() => {
+        for (const j of opened) {
+          j.st.open = true;
+          j.st.openedBy = "break";
+        }
+        solveStructure(o);
+        recomputeGroups(o);
+        detachEvents(o, opened, "break");
+        collapseCheck(o);
+      });
+    };
     const checkDestroyed = (o, src) => {
       if (!o.st.destroyed && o.parts.length > 0 && o.parts.every(isLost)) {
         o.st.destroyed = true;
@@ -23220,7 +23259,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     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 unitsOf2 = (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 cellFragments = (o, p, cells, hitW, dir, speed, mass, tag, inner = false) => {
       const { c, q } = partXf(o, p);
       const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
       const [u, v] = planeAxes(p.thin);
@@ -23244,7 +23283,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           velocity: [dv[0] * k, dv[1] * k + 0.5 * rnd2(), dv[2] * k],
           angularVelocity: [(rnd2() - 0.5) * 8, (rnd2() - 0.5) * 8, (rnd2() - 0.5) * 8],
           mass: mass * faceArea(cell) / total,
-          ...marks.length > 0 ? { marks } : {}
+          ...marks.length > 0 ? { marks } : {},
+          ...inner ? { inner } : {}
         };
       });
     };
@@ -23285,7 +23325,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return cells.some((c) => Math.abs(lp[u] - c.center[u]) <= c.size[u] / 2 && Math.abs(lp[v] - c.center[v]) <= c.size[v] / 2);
     };
     const chipUnits = (o, p, kind, wp, hitEnergy, dir, radius, src) => {
-      var _a, _b;
+      var _a, _b, _c;
       if (!p.spec.units || !p.staged || chipEnergy <= 0 || p.st.stripped || isLost(p) || (p.st.stage ?? 0) >= 2) return;
       const rule = p.mat.hits?.[kind];
       const perKg = rule?.unitJoules ?? chipEnergy;
@@ -23295,7 +23335,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const lp = toLocal(p.pos, p.q, objLocal(o, wp));
       const grid = gridOf(p);
       const worn = (_a = p.rt).chips ?? (_a.chips = {});
+      const cut = (_b = p.rt).craters ?? (_b.craters = {});
       const out = [];
+      const shot = kind === "ballistic";
       for (let i = 0; i < grid.length; i++) {
         const cell = grid[i];
         if (worn[i] === -1) continue;
@@ -23308,18 +23350,39 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           worn[i] = total;
           continue;
         }
-        worn[i] = -1;
-        out.push(cell);
+        if (!shot) {
+          worn[i] = -1;
+          out.push(cell);
+          continue;
+        }
+        const size = [cell.size[0], cell.size[1], cell.size[2]];
+        const center = [cell.center[0], cell.center[1], cell.center[2]];
+        for (const a of [u, v]) {
+          const w = Math.min(cell.size[a], craterAcross(hitEnergy) * (0.85 + 0.3 * rnd2()));
+          const lo = cell.center[a] - cell.size[a] / 2 + w / 2, hi = cell.center[a] + cell.size[a] / 2 - w / 2;
+          size[a] = w;
+          center[a] = clamp2(lp[a], lo, hi);
+        }
+        const taken2 = (cut[i] ?? 0) + size[u] * size[v];
+        if (taken2 >= cell.size[u] * cell.size[v] * CRATER_SPENT) {
+          worn[i] = -1;
+          out.push({ ...cell, crater: true });
+          continue;
+        }
+        worn[i] = 0;
+        cut[i] = taken2;
+        out.push({ center, size, crater: true });
       }
       if (out.length === 0) return;
       const { c, q } = partXf(o, p);
-      const chipped = (_b = p.st).chipped ?? (_b.chipped = []);
+      const chipped = (_c = p.st).chipped ?? (_c.chipped = []);
       const holes = localHolesOf(p);
       for (const cell of out) {
         const mass = Math.min(p.st.mass, p.mat.density * cell.size[0] * cell.size[1] * cell.size[2]);
         const center = toWorld(c, q, cell.center);
         const speed = clamp2(Math.sqrt(2 * energy * 0.05 / Math.max(mass, 0.05)), 0.5, 6);
-        const fragments = cellFragments(o, p, [cell], wp, dir, speed, mass, `c${chipped.length}_`);
+        const tag = `c${chipped.length}_`;
+        const fragments = cell.crater ? craterFragments(o, p, cell, dir, speed, mass, tag) : cellFragments(o, p, [cell], wp, dir, speed, mass, tag, true);
         p.st.holes = p.st.holes.filter((_, k) => marksInBox(cell.center, cell.size, void 0, [holes[k]]).length === 0);
         chipped.push({ center: [cell.center[0], cell.center[1], cell.center[2]], size: [cell.size[0], cell.size[1], cell.size[2]] });
         p.st.mass = Math.max(0, p.st.mass - mass);
@@ -23336,6 +23399,44 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         collapseCheck(o, src);
       }
     };
+    const craterAcross = (energy) => clamp2(0.03 + 12e-4 * Math.sqrt(Math.max(0, energy)), 0.03, 0.14);
+    const craterFragments = (o, p, cell, dir, speed, mass, tag) => {
+      const { c, q } = partXf(o, p);
+      const [u, v] = planeAxes(p.thin);
+      const d = dir ?? rotateVec(q, [p.thin === 0 ? 1 : 0, p.thin === 1 ? 1 : 0, p.thin === 2 ? 1 : 0]);
+      const exitSign = Math.sign(rotateVec(quat.conjugate(q), d)[p.thin]) || 1;
+      const bit = Math.max(0.01, Math.min(cell.size[u], cell.size[v]) / 3);
+      const n = clamp2(Math.round(cell.size[u] * cell.size[v] / (bit * bit * 3)), 4, 10) + Math.floor(rnd2() * 3);
+      const out = [];
+      for (let i = 0; i < n; i++) {
+        const back = i % 3 === 2;
+        const lc = [cell.center[0], cell.center[1], cell.center[2]];
+        lc[u] += (rnd2() - 0.5) * cell.size[u] * 0.7;
+        lc[v] += (rnd2() - 0.5) * cell.size[v] * 0.7;
+        lc[p.thin] += (back ? -exitSign : exitSign) * (p.thickness / 2 + 0.01);
+        const size = [0, 0, 0];
+        size[u] = bit * (0.6 + 0.8 * rnd2());
+        size[v] = bit * (0.5 + 0.7 * rnd2());
+        size[p.thin] = bit * (0.4 + 0.6 * rnd2());
+        const spread3 = [(rnd2() - 0.5) * 0.9, (rnd2() - 0.3) * 0.9, (rnd2() - 0.5) * 0.9];
+        const k = speed * (back ? 0.4 + 0.4 * rnd2() : 0.7 + 0.8 * rnd2());
+        const vdir = vec.normalize(vec.add(back ? vec.scale(d, -1) : d, spread3));
+        out.push({
+          id: `${p.spec.id}#${tag}${i}`,
+          part: p.spec.id,
+          material: p.spec.material,
+          shape: "chunk",
+          center: toWorld(c, q, lc),
+          size,
+          rotation: q,
+          velocity: [vdir[0] * k, vdir[1] * k + 0.5 * rnd2(), vdir[2] * k],
+          angularVelocity: [(rnd2() - 0.5) * 20, (rnd2() - 0.5) * 20, (rnd2() - 0.5) * 20],
+          mass: mass / n,
+          inner: true
+        });
+      }
+      return out;
+    };
     const exposeRebar = (o, p, src) => {
       const r = p.spec.reinforcement;
       if (!r) return;
@@ -23623,7 +23724,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         });
       }
       const patch = [scale * 4, scale * 4, scale * 4];
-      emit2({ ...base(o, src), type: "chip", part: p.spec.id, center: exit ?? entry2, size: patch, rotation: q, fragments });
+      emit2({ ...base(o, src), type: "chip", part: p.spec.id, center: exit ?? entry2, size: patch, rotation: q, fragments, torn: true });
     };
     const ballistic = (o, p, entry2, n, d, E, caliber, pathLen, src, round5 = {}) => {
       const mat = p.mat;
@@ -23682,12 +23783,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       } else if (mat.ductility >= 0.5) {
         addDent(o, p, entry2, 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, entry2, n, crackLen, src);
+        if (!p.spec.units) addCrack(o, p, entry2, n, crackLen, src);
         if (mat.fracture !== "shatter") addHole(o, p, entry2, n, caliber / 1e3, false, void 0, src);
       } else addHole(o, p, entry2, n, caliber / 1e3, false, void 0, src);
       debris2(o, p, mat.hitDebris, entry2, 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, BULLET_JOINT_SPAN);
-      const absorbed = penetrated && mat.ductility >= 0.5 && mat.fracture !== "tear" ? Math.min(E, thr) : E;
+      const hollowTear = mat.fracture === "tear" && p.spec.fill !== void 0 && p.spec.fill < 0.5;
+      const absorbed = penetrated && (mat.ductility >= 0.5 && mat.fracture !== "tear" || hollowTear) ? Math.min(E, thr) : E;
       const dmg = applyDamage(o, p, absorbed * DMG_PER_J * scale, "ballistic", entry2, d, absorbed * 0.1, 12, src);
       if (!isLost(p)) tearAt(o, p, "ballistic", entry2, penetrated ? exitPoint : void 0, d, E, caliber / 1e3, src);
       chipUnits(o, p, "ballistic", entry2, penetrated ? Math.min(E, Math.max(thr, E * 0.5)) : E, d, Math.max(0.05, caliber / 1e3 * 8), src);
@@ -23772,10 +23874,25 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (dist2 <= BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3)) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
       return reach;
     };
+    const blastProbe = { partsTested: 0, partsNear: 0 };
+    const blastCandidates = (o, point, radius) => {
+      const local2 = toLocal(o.st.position, o.st.rotation, point);
+      const near = [];
+      for (const p of o.parts) {
+        const reach = radius + p.bound;
+        const dx = local2[0] - p.pos[0];
+        const dy = local2[1] - p.pos[1];
+        const dz = local2[2] - p.pos[2];
+        if (dx * dx + dy * dy + dz * dz < reach * reach) near.push(p);
+      }
+      blastProbe.partsTested += o.parts.length;
+      blastProbe.partsNear += near.length;
+      return near;
+    };
     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) blastPart(o, p, point, energy, radius, src, res);
+      for (const p of blastCandidates(o, point, radius)) blastPart(o, p, point, energy, radius, src, res);
       res.events = cur.slice(start);
       return res;
     };
@@ -23899,7 +24016,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       let order = 0;
       for (const o of inRange) {
         if (only && only !== o) continue;
-        for (const p of o.parts) {
+        for (const p of blastCandidates(o, point, radius)) {
           if (isLost(p)) continue;
           const dist2 = distToPart(o, p, point);
           if (dist2 < radius) items.push({ dist: dist2, order: order++, o, p });
@@ -24446,6 +24563,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const p = getPart(o, partId);
         p.pos = [position[0], position[1], position[2]];
         p.q = q;
+        poseVersion++;
         updateBound(o);
       },
       remove(id) {
@@ -24464,6 +24582,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const o = getObj(id);
         o.base = { pos: [position[0], position[1], position[2]], rot: [rotation[0], rotation[1], rotation[2], rotation[3]] };
         applySoilPose(o);
+        slideOffResting(o, rotation);
       },
       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`);
@@ -24487,7 +24606,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           if (o.spec.name !== void 0) s.name = o.spec.name;
           if (o.spec.tags) s.tags = [...o.spec.tags];
           if (o.spec.soil !== void 0) s.soil = o.spec.soil;
-          return clone(s);
+          return s;
         };
         const inNew = (pid) => moved.has(pid);
         const inOld = (pid) => !moved.has(pid);
@@ -24514,7 +24633,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const p = getPart(o, partId);
         return whole(() => doHit(o, h, p));
       },
+      blastProbe() {
+        return { ...blastProbe };
+      },
       explode(point, energy, radius, source, blast) {
+        blastProbe.partsTested = 0;
+        blastProbe.partsNear = 0;
         return withCollapses(run(() => blastWorld(point, energy, radius, source, blast)));
       },
       raycast(origin, direction, maxDistance = Infinity) {
@@ -24524,7 +24648,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       sweepBox(box5, direction, distance3, options2 = {}) {
         const d = vec.normalize(direction);
         const ignored = options2.ignore === void 0 ? void 0 : objects.get(options2.ignore);
-        const ignore = ignored ? new Set(ignored.parts.map((p) => `${ignored.id}\0${p.spec.id}`)) : void 0;
+        const hosted = options2.ignore === void 0 || ignored ? void 0 : impls.get(options2.ignore);
+        const ignore = ignored ? new Set(ignored.parts.map((p) => `${ignored.id}\0${p.spec.id}`)) : hosted ? new Set(hosted.impl.describe().parts.map((p) => `${hosted.impl.id}\0${p.id}`)) : void 0;
         let best = null;
         for (const origin of sweepOrigins(box5, d, options2.spacing ?? 0.2)) {
           const r = raycastInternal(origin, d, distance3 + SWEEP_BACK, ignore);
@@ -34127,6 +34252,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   function collapseRange(mesh3, v0, v1) {
     const pos = mesh3.geometry.attributes.position;
     const a = pos.array;
+    const u = mesh3.userData;
+    if (!u._p0) u._p0 = a.slice();
+    const list2 = u.collapsedRanges ?? (u.collapsedRanges = []);
+    if (!list2.some((r) => r[0] === v0 && r[1] === v1)) list2.push([v0, v1]);
     const saved = a.slice(v0 * 3, v1 * 3);
     const x = a[v0 * 3], y = a[v0 * 3 + 1], z = a[v0 * 3 + 2];
     for (let k = v0; k < v1; k++) {
@@ -34141,6 +34270,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const pos = mesh3.geometry.attributes.position;
     pos.array.set(saved, v0 * 3);
     pos.needsUpdate = true;
+    const list2 = mesh3.userData.collapsedRanges;
+    if (list2) mesh3.userData.collapsedRanges = list2.filter((r) => r[0] !== v0);
   }
   function noise2(x, y, cell) {
     const h = (i2, j2) => {
@@ -34155,13 +34286,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var SPALL_MIN = 0.025;
   var SPALL_RAGGED = 0.045;
   var COVER2 = 0.015;
+  var MAX_FLAKES = 64;
   function installDestructionBreach(K, _shared) {
     const { THREE, fragmentMaterial, invalidate, invalidateShadow } = K;
     function createBreachView(opts) {
       const { house, structure } = opts;
       const views = /* @__PURE__ */ new Map();
+      const dirty = /* @__PURE__ */ new Set();
+      const paintBudgetMs = opts.paintBudgetMs ?? Infinity;
+      const dropped = [];
       let lod = 0;
-      const unitMaterial = new THREE.MeshLambertMaterial({ color: 16777215 });
       const unitGeometry = new THREE.BoxGeometry(1, 1, 1);
       const tmp = { m: new THREE.Matrix4(), q: new THREE.Quaternion(), p: new THREE.Vector3(), s: new THREE.Vector3(), c: new THREE.Color() };
       const local2 = (p) => {
@@ -34230,6 +34364,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const mesh3 = new THREE.Mesh(g, material);
         mesh3.name = "breach-shell";
         mesh3.userData.breachMask = mask;
+        mesh3.userData.cutAt = (p) => {
+          const v = local2([p.x, p.y, p.z]);
+          const i = Math.floor(((mask.alongU ? v[0] : v[2]) - mask.start) / mask.len * mask.w), j = Math.floor((v[1] - mask.y0) / mask.height * mask.h);
+          return i >= 0 && i < mask.w && j >= 0 && j < mask.h && mask.data[j * mask.w + i] > 127;
+        };
         mesh3.position.copy(it.mesh.position);
         mesh3.quaternion.copy(it.mesh.quaternion);
         mesh3.scale.copy(it.mesh.scale);
@@ -34245,6 +34384,19 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         toHouse.value.copy(house.matrixWorld).invert().multiply(mesh3.matrixWorld);
         return mesh3;
       }
+      function unitsMaterial(core) {
+        const material = new THREE.MeshLambertMaterial({ color: 16777215, side: THREE.DoubleSide });
+        material.onBeforeCompile = (sh) => {
+          sh.uniforms.uCore = { value: core.texture };
+          sh.uniforms.uCoreRect = { value: core.rect };
+          sh.uniforms.uCoreAlongX = { value: core.alongU ? 1 : 0 };
+          sh.vertexShader = sh.vertexShader.replace("void main() {", "varying vec3 vHousePos;\nvoid main() {").replace("#include <begin_vertex>", "#include <begin_vertex>\n#ifdef USE_INSTANCING\nvHousePos = (instanceMatrix * vec4(transformed, 1.0)).xyz;\n#else\nvHousePos = transformed;\n#endif");
+          sh.fragmentShader = sh.fragmentShader.replace("void main() {", "uniform sampler2D uCore;\nuniform vec4 uCoreRect;\nuniform float uCoreAlongX;\nvarying vec3 vHousePos;\nvoid main() {\n  vec2 cUv = vec2(((uCoreAlongX > 0.5 ? vHousePos.x : vHousePos.z) - uCoreRect.x) / uCoreRect.z, (vHousePos.y - uCoreRect.y) / uCoreRect.w);\n  if (cUv.x >= 0.0 && cUv.x <= 1.0 && cUv.y >= 0.0 && cUv.y <= 1.0 && texture2D(uCore, cUv).r > 0.5) discard;").replace("#include <color_fragment>", "#include <color_fragment>\nif (!gl_FrontFacing) diffuseColor.rgb *= 0.55;");
+        };
+        material.customProgramCacheKey = () => "breachCore";
+        material.userData.breachCore = core;
+        return material;
+      }
       function maskOf(hostId, parts) {
         const host = structure.byId.get(hostId);
         const [u0, v0, u1, v1] = host.aabb;
@@ -34260,41 +34412,73 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return { data, texture, w, h, alongU, start: alongU ? u0 : v0, len, y0, height: y1 - y0, rect: new THREE.Vector4(alongU ? u0 : v0, y0, len, y1 - y0) };
       }
       const boxDistance = (s, y, a, b, c, d) => Math.hypot(Math.max(a - s, 0, s - b), Math.max(c - y, 0, y - d));
+      const ellipseDistance = (s, y, cs, cy, rs, ry) => (Math.hypot((s - cs) / Math.max(rs, 1e-4), (y - cy) / Math.max(ry, 1e-4)) - 1) * Math.min(rs, ry);
+      function covered(c, boxes) {
+        const n = 8;
+        let hit = 0;
+        for (let j = 0; j < n; j++) {
+          const y = c.y0 + (j + 0.5) / n * (c.y1 - c.y0);
+          for (let i = 0; i < n; i++) {
+            const s = c.a + (i + 0.5) / n * (c.b - c.a);
+            if (boxes.some((k) => s >= k.s0 && s <= k.s1 && y >= k.y0 && y <= k.y1)) hit++;
+          }
+        }
+        return hit / (n * n);
+      }
       function paint2(view) {
-        const { mask } = view;
+        const { mask, core } = view;
         const along = (p) => (mask.alongU ? p[0] : p[2]) - mask.start;
         const holes = [];
+        const pits = [];
         const discs = [];
+        const flakes = [];
         const shown = [];
         for (const id of view.parts) {
-          const part = structure.byId.get(id), units2 = specOf(id).units, chips2 = view.chips.get(id), opening = view.openings.get(id);
+          const part = structure.byId.get(id), units2 = specOf(id).units, chips2 = view.chips.get(id), opening = view.openings.get(id), spalls = view.spalls.get(id);
           const all = cells(part, units2);
           const thick = mask.alongU ? part.aabb[3] - part.aabb[1] : part.aabb[2] - part.aabb[0];
           const mid = mask.alongU ? (part.aabb[1] + part.aabb[3]) / 2 : (part.aabb[0] + part.aabb[2]) / 2;
           if (opening) discs.push({ s: along(opening.center), y: opening.center[1], r: opening.radius });
-          const gone = (c) => chips2.some((p) => p[1] >= c.y0 && p[1] <= c.y1 && along(p) >= c.a && along(p) <= c.b) || opening && Math.hypot((c.a + c.b) / 2 - along(opening.center), (c.y0 + c.y1) / 2 - opening.center[1]) < opening.radius;
+          for (const k of spalls) flakes.push({ s: along(k.center), y: k.center[1], r: k.radius });
+          const boxes = chips2.map((k) => ({ s0: along(k.center) - k.along, s1: along(k.center) + k.along, y0: k.center[1] - k.up, y1: k.center[1] + k.up }));
+          const gone = (c) => covered(c, boxes.filter((k) => k.s1 > c.a && k.s0 < c.b && k.y1 > c.y0 && k.y0 < c.y1)) >= 0.9 || opening && Math.hypot((c.a + c.b) / 2 - along(opening.center), (c.y0 + c.y1) / 2 - opening.center[1]) < opening.radius;
           const kept = [];
           for (const c of all) (gone(c) ? holes : kept).push(c);
           for (const c of kept) shown.push({ c, part, units: units2, thick, mid });
+          for (const k of boxes) {
+            if (holes.some((h) => k.s0 >= h.a - 1e-4 && k.s1 <= h.b + 1e-4 && k.y0 >= h.y0 - 1e-4 && k.y1 <= h.y1 + 1e-4)) continue;
+            pits.push({ s: (k.s0 + k.s1) / 2, y: (k.y0 + k.y1) / 2, rs: (k.s1 - k.s0) / 2, ry: (k.y1 - k.y0) / 2 });
+          }
         }
         const reach = SPALL_MIN + SPALL_RAGGED;
+        const ragged = (s, y) => 0.6 * noise2(s, y, 0.03) + 0.4 * noise2(s + 7.3, y - 3.1, 0.011);
         mask.data.fill(0);
-        const stamp = (s0, s1, y0, y1, inside2) => {
-          const i0 = Math.max(0, Math.floor((s0 - reach) / mask.len * mask.w)), i1 = Math.min(mask.w - 1, Math.ceil((s1 + reach) / mask.len * mask.w));
-          const j0 = Math.max(0, Math.floor((y0 - reach - mask.y0) / mask.height * mask.h)), j1 = Math.min(mask.h - 1, Math.ceil((y1 + reach - mask.y0) / mask.height * mask.h));
+        core.data.fill(0);
+        const stamp = (m, s0, s1, y0, y1, inside2) => {
+          const i0 = Math.max(0, Math.floor((s0 - reach) / m.len * m.w)), i1 = Math.min(m.w - 1, Math.ceil((s1 + reach) / m.len * m.w));
+          const j0 = Math.max(0, Math.floor((y0 - reach - m.y0) / m.height * m.h)), j1 = Math.min(m.h - 1, Math.ceil((y1 + reach - m.y0) / m.height * m.h));
           for (let j = j0; j <= j1; j++) {
-            const y = mask.y0 + (j + 0.5) / mask.h * mask.height;
+            const y = m.y0 + (j + 0.5) / m.h * m.height;
             for (let i = i0; i <= i1; i++) {
-              const s = (i + 0.5) / mask.w * mask.len;
-              const edge = SPALL_MIN + SPALL_RAGGED * (0.6 * noise2(s, y, 0.03) + 0.4 * noise2(s + 7.3, y - 3.1, 0.011));
-              if (inside2(s, y) <= edge) mask.data[j * mask.w + i] = 255;
+              const s = (i + 0.5) / m.w * m.len;
+              if (inside2(s, y)) m.data[j * m.w + i] = 255;
             }
           }
         };
-        for (const c of holes) stamp(c.a, c.b, c.y0, c.y1, (s, y) => boxDistance(s, y, c.a, c.b, c.y0, c.y1));
-        for (const d of discs) stamp(d.s - d.r, d.s + d.r, d.y - d.r, d.y + d.r, (s, y) => Math.max(0, Math.hypot(s - d.s, y - d.y) - d.r));
+        const plaster = (d, s, y) => d <= SPALL_MIN + SPALL_RAGGED * ragged(s, y);
+        for (const c of holes) stamp(mask, c.a, c.b, c.y0, c.y1, (s, y) => plaster(boxDistance(s, y, c.a, c.b, c.y0, c.y1), s, y));
+        for (const d of discs) stamp(mask, d.s - d.r, d.s + d.r, d.y - d.r, d.y + d.r, (s, y) => plaster(Math.max(0, Math.hypot(s - d.s, y - d.y) - d.r), s, y));
+        for (const f of flakes) {
+          const rough = (s, y) => Math.hypot(s - f.s, y - f.y) - f.r * (0.65 + 0.7 * ragged(s * 2.3, y * 2.3));
+          stamp(mask, f.s - 2 * f.r, f.s + 2 * f.r, f.y - 2 * f.r, f.y + 2 * f.r, (s, y) => rough(s, y) <= 0);
+        }
+        for (const p of pits) {
+          stamp(mask, p.s - p.rs, p.s + p.rs, p.y - p.ry, p.y + p.ry, (s, y) => plaster(Math.max(0, ellipseDistance(s, y, p.s, p.y, p.rs, p.ry)), s, y));
+          stamp(core, p.s - p.rs, p.s + p.rs, p.y - p.ry, p.y + p.ry, (s, y) => ellipseDistance(s, y, p.s, p.y, p.rs, p.ry) <= -0.35 * Math.min(p.rs, p.ry) * noise2(s * 1.7, y * 1.3, 0.012));
+        }
         mask.texture.needsUpdate = true;
-        const near = (c) => holes.some((h) => boxDistance((c.a + c.b) / 2, (c.y0 + c.y1) / 2, h.a - (c.b - c.a) / 2, h.b + (c.b - c.a) / 2, h.y0 - (c.y1 - c.y0) / 2, h.y1 + (c.y1 - c.y0) / 2) <= reach) || discs.some((d) => boxDistance(d.s, d.y, c.a, c.b, c.y0, c.y1) <= d.r + reach);
+        core.texture.needsUpdate = true;
+        const near = (c) => holes.some((h) => boxDistance((c.a + c.b) / 2, (c.y0 + c.y1) / 2, h.a - (c.b - c.a) / 2, h.b + (c.b - c.a) / 2, h.y0 - (c.y1 - c.y0) / 2, h.y1 + (c.y1 - c.y0) / 2) <= reach) || discs.some((d) => boxDistance(d.s, d.y, c.a, c.b, c.y0, c.y1) <= d.r + reach) || pits.some((p) => boxDistance(p.s, p.y, c.a, c.b, c.y0, c.y1) <= Math.max(p.rs, p.ry) + reach) || flakes.some((f) => boxDistance(f.s, f.y, c.a, c.b, c.y0, c.y1) <= 2 * f.r);
         const list2 = [];
         const tone = (hex2, k) => tmp.c.setHex(hex2).multiplyScalar(k).getHex();
         for (const { c, part, units: units2, thick, mid } of shown) {
@@ -34304,7 +34488,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const base = fragmentMaterial(part.material).color.getHex();
           const n = noise2(centre * 3.1, y * 2.7, 0.07);
           if (units2.mortar === "concrete") {
-            at3(len, h, thick - 2 * COVER2 - 0.03 * n, tone(base, 0.86 + 0.2 * n));
+            at3(len, h, thick - 2 * COVER2, tone(base, 0.9 + 0.04 * n));
           } else {
             at3(len, h, thick - 2 * COVER2 - 0.012, 10327948);
             at3(len - 0.012, h - 0.012, thick - 2 * COVER2, tone(base, 0.8 + 0.35 * n));
@@ -34314,7 +34498,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           view.units.removeFromParent();
           view.units.dispose();
         }
-        const units = new THREE.InstancedMesh(unitGeometry, unitMaterial, Math.max(1, list2.length));
+        const units = new THREE.InstancedMesh(unitGeometry, view.unitMaterial, Math.max(1, list2.length));
         units.name = "breach:" + view.host;
         list2.forEach((u, i) => {
           tmp.m.compose(tmp.p.set(u.x, u.y, u.z), tmp.q.identity(), tmp.s.set(u.sx, u.sy, u.sz));
@@ -34330,6 +34514,19 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         house.add(units);
         view.units = units;
         view.gone = holes.length;
+        view.pits = pits.length;
+        view.flakes = flakes.length;
+      }
+      function chipBox(chip, alongU) {
+        house.updateMatrixWorld(true);
+        const q = tmp.q.set(chip.rotation[0], chip.rotation[1], chip.rotation[2], chip.rotation[3]).premultiply(house.getWorldQuaternion(new THREE.Quaternion()).invert());
+        let a = 0, u = 0;
+        for (let k = 0; k < 3; k++) {
+          const axis2 = tmp.p.set(k === 0 ? 1 : 0, k === 1 ? 1 : 0, k === 2 ? 1 : 0).applyQuaternion(q);
+          a += Math.abs(alongU ? axis2.x : axis2.z) * chip.size[k] / 2;
+          u += Math.abs(axis2.y) * chip.size[k] / 2;
+        }
+        return { center: local2(chip.center), along: a, up: u };
       }
       function draw2(partId, change) {
         if (lod !== 0) return false;
@@ -34341,23 +34538,49 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           if (!items.length) return false;
           const parts = [hostId, ...riders(hostId)].filter((id) => structure.byId.get(id) && specOf(id)?.units);
           if (!parts.includes(partId)) return false;
-          const mask = maskOf(hostId, parts);
-          view = { host: hostId, parts, items, mask, shells: [], saved: null, units: null, gone: 0, chips: new Map(parts.map((id) => [id, []])), openings: /* @__PURE__ */ new Map() };
+          const mask = maskOf(hostId, parts), core = maskOf(hostId, parts);
+          view = {
+            host: hostId,
+            parts,
+            items,
+            mask,
+            core,
+            unitMaterial: unitsMaterial(core),
+            shells: [],
+            saved: null,
+            units: null,
+            gone: 0,
+            pits: 0,
+            chips: new Map(parts.map((id) => [id, []])),
+            spalls: new Map(parts.map((id) => [id, []])),
+            openings: /* @__PURE__ */ new Map(),
+            flakes: 0
+          };
         }
         if (!view.chips.has(partId)) return false;
         if (change.opening) {
           if (view.openings.has(partId)) return false;
           view.openings.set(partId, { center: local2(change.opening.center), radius: change.opening.radius });
         }
-        if (change.chip) view.chips.get(partId).push(local2(change.chip));
+        if (change.chip) view.chips.get(partId).push(chipBox(change.chip, view.mask.alongU));
+        if (change.spall) {
+          const list2 = view.spalls.get(partId);
+          list2.push({ center: local2(change.spall.center), radius: change.spall.radius });
+          if (list2.length > MAX_FLAKES) list2.shift();
+        }
         if (!view.saved) {
           view.shells = view.items.map((it) => shell(it, view.mask));
+          for (const m of view.shells) m.userData.behind = () => view.units;
           view.saved = view.items.map((it) => ({ it, v0: it.v0, data: collapseRange(it.mesh, it.v0, it.v1) }));
         }
-        paint2(view);
         views.set(hostId, view);
-        invalidate();
-        invalidateShadow();
+        if (opts.deferPaint && change.spall) dirty.add(view);
+        else {
+          dirty.delete(view);
+          paint2(view);
+          invalidate();
+          invalidateShadow();
+        }
         return true;
       }
       function plain2(view, shown) {
@@ -34366,24 +34589,70 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           else s.data = collapseRange(s.it.mesh, s.v0, s.it.v1);
         }
       }
+      function flush(budgetMs = paintBudgetMs) {
+        if (dirty.size === 0) return 0;
+        const deadline = performance.now() + budgetMs;
+        for (const view of dirty) {
+          dirty.delete(view);
+          paint2(view);
+          if (performance.now() >= deadline) break;
+        }
+        invalidate();
+        invalidateShadow();
+        return dirty.size;
+      }
       function dispose(view) {
-        view.units.removeFromParent();
-        view.units.dispose();
+        dirty.delete(view);
+        if (view.units) {
+          view.units.removeFromParent();
+          view.units.dispose();
+        }
+        view.unitMaterial.dispose();
         for (const m of view.shells) {
           m.removeFromParent();
           m.geometry.dispose();
           m.material.dispose();
         }
         view.mask.texture.dispose();
+        view.core.texture.dispose();
       }
       return {
         /** Handles a `stage` event of the house's object. Returns true when the wall was cut. */
         stage(event) {
           return event.stage === 2 && !!event.opening ? draw2(event.part, { opening: event.opening }) : false;
         },
-        /** Handles a `chip` event: the unit that came out leaves a hole in the wall where it was. Returns true when the wall was cut. */
+        /**
+         * Handles a `spall` of a wall of units: the coat comes off in a ragged patch and the units show under it, drawn by the house (the destruction
+         * renderer leaves its flat patch out on the meshes `claim` marked). Returns true when the wall was cut.
+         */
+        spall(event) {
+          const r = Math.sqrt(Math.max(0, event.area) / Math.PI);
+          return r > 0 ? draw2(event.part, { spall: { center: event.point, radius: r } }) : false;
+        },
+        /**
+         * Marks the meshes that draw a wall of units as drawing its spalls itself (`userData.drawnSpalls`, the part ids): the destruction renderer then
+         * throws the bits and leaves its patch out. Call it once the spec is known.
+         */
+        claim() {
+          var _a;
+          for (const q of opts.spec()?.parts ?? []) {
+            if (!q.units) continue;
+            const host = hostOf(q.id);
+            if (!host) continue;
+            for (const it of structure.meshesOf(host)) {
+              if (!it.mesh) continue;
+              const list2 = (_a = it.mesh.userData).drawnSpalls ?? (_a.drawnSpalls = []);
+              if (!list2.includes(q.id)) list2.push(q.id);
+            }
+          }
+        },
+        /**
+         * Handles a `chip` event: what came out (a unit, or a crater a shot broke through one) leaves a hole in the wall where it was; a `torn` chip (what a blow
+         * tore off a face) leaves the marks the renderer drew. Returns true when the wall was cut.
+         */
         chip(event) {
-          return draw2(event.part, { chip: event.center });
+          if (event.torn) return false;
+          return draw2(event.part, { chip: { center: event.center, size: event.size ?? [0, 0, 0], rotation: event.rotation ?? [0, 0, 0, 1] } });
         },
         /** The part broke or fell: its damage goes (the plain range stays collapsed, the renderer hides the part). */
         drop(partId) {
@@ -34391,9 +34660,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           if (!v) return;
           dispose(v);
           views.delete(partId);
+          if (v.saved) dropped.push(v);
         },
         /** LOD 0 draws the cut wall; LOD 1 and 2 give the wall its box back. */
         setLod(level) {
+          flush(Infinity);
           const was = lod;
           lod = level;
           if (was === 0 === (level === 0)) return;
@@ -34412,21 +34683,27 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             if (lod === 0) plain2(v, true);
           }
           views.clear();
+          for (const v of dropped) plain2(v, true);
+          dropped.length = 0;
         },
+        flush,
         /** The wall has damage drawn. */
         has(partId) {
           return views.has(partId);
         },
-        /** Walls with damage drawn, units out of them, and units laid bare at the edge of the cuts. */
-        statistics: () => ({
+        /** Walls with damage drawn, units out of them, craters shots broke through units that stay, and units laid bare at the edge of the cuts. */
+        statistics: () => (flush(Infinity), {
           walls: views.size,
           gone: [...views.values()].reduce((n, v) => n + v.gone, 0),
+          craters: [...views.values()].reduce((n, v) => n + v.pits, 0),
+          flakes: [...views.values()].reduce((n, v) => n + v.flakes, 0),
           units: [...views.values()].reduce((n, v) => n + v.units.count, 0)
         })
       };
     }
     Object.assign(K, { createBreachView });
   }
+  var FOLLOW_FLUSH_FALLBACK_MS = 100;
   function installDestructionWorld(K, shared) {
     const { THREE, cfg, invalidateShadow, invalidate, rngString, FRAGMENT_GEO, fragmentMaterial, createBreachView } = K;
     function createHouseDestruction(root, house, structure, parts, colliders, water) {
@@ -34435,7 +34712,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const R = cfg.destructionRenderer || null, listeners = /* @__PURE__ */ new Set();
       D.renderer = R;
       D.spec = null;
-      const breach = createBreachView({ house, structure, spec: () => D.spec });
+      const breach = createBreachView({ house, structure, spec: () => D.spec, deferPaint: true, ...cfg.breachPaintBudgetMs !== void 0 ? { paintBudgetMs: cfg.breachPaintBudgetMs } : {} });
       D.breach = breach;
       D.onEvent = (fn) => {
         listeners.add(fn);
@@ -34620,6 +34897,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           case "chip":
             breach.chip(e);
             break;
+          case "spall":
+            breach.spall(e);
+            break;
           case "collapse":
             for (const id of e.parts) {
               breach.drop(id);
@@ -34661,7 +34941,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         D.specOptions = specOptions || null;
         D.spec = structure.spec(specOptions);
         D.id = D.world.add(D.spec, { id: "house3d:" + ++shared.destructionSeq, position: [p.x, p.y, p.z], rotation: [q.x, q.y, q.z, q.w] });
-        if (R) R.bind(D.id, house, { parts: rangesOf() });
+        breach.claim();
+        if (R) R.bind(D.id, house, { parts: rangesOf(), onFrame: () => breach.flush() });
         off = D.world.on("*", handleEvent);
         D.active = true;
         return D;
@@ -34676,6 +34957,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       };
       D.follow = (world, id, spec) => {
         D.spec = spec;
+        breach.claim();
+        let fallback2 = null;
         const offFollow = world.on("*", (e) => {
           if (e.object !== id) return;
           switch (e.type) {
@@ -34685,6 +34968,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             case "chip":
               breach.chip(e);
               break;
+            case "spall":
+              breach.spall(e);
+              break;
             case "fracture":
               breach.drop(e.part);
               break;
@@ -34694,10 +34980,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             default:
               break;
           }
+          if (!fallback2 && typeof setTimeout === "function") fallback2 = setTimeout(() => {
+            fallback2 = null;
+            breach.flush(Infinity);
+          }, FOLLOW_FLUSH_FALLBACK_MS);
         });
         return { restore: () => breach.restore(), dispose: () => {
           offFollow();
           breach.restore();
+        }, update: () => {
+          breach.flush();
         } };
       };
       D.piece = (id) => D.active ? D.world.part(D.id, id) : null;
@@ -34730,6 +35022,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return r;
       };
       D.animate = (dt) => {
+        breach.flush();
         if (R) return;
         let moved = false;
         for (const [id, list2] of bodies) {
@@ -36752,6 +37045,54 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     store.buffer ?? (store.buffer = bufferOf(context, [samples], context.sampleRate * seconds));
     return store.buffer;
   }
+  var nowMs = () => typeof performance === "undefined" ? Date.now() : performance.now();
+  function scheduleTask(task) {
+    if (typeof MessageChannel === "undefined") {
+      setTimeout(task, 0);
+      return;
+    }
+    const channel = new MessageChannel();
+    channel.port1.onmessage = () => {
+      channel.port1.close();
+      task();
+    };
+    channel.port2.postMessage(0);
+  }
+  function createStartQueue(options = {}) {
+    const budgetMs = options.budgetMs ?? 2;
+    const maxLatencyMs = options.maxLatencyMs ?? 250;
+    let jobs = [];
+    let scheduled = false;
+    const drain = () => {
+      scheduled = false;
+      const began = nowMs();
+      while (jobs.length > 0) {
+        const job = jobs.shift();
+        if (nowMs() - job.queuedAt > maxLatencyMs) job.drop();
+        else job.run();
+        if (nowMs() - began >= budgetMs) break;
+      }
+      if (jobs.length > 0) schedule();
+    };
+    const schedule = () => {
+      if (scheduled) return;
+      scheduled = true;
+      scheduleTask(drain);
+    };
+    return {
+      push(job) {
+        jobs.push({ ...job, queuedAt: nowMs() });
+        schedule();
+      },
+      clear() {
+        for (const job of jobs) job.drop();
+        jobs = [];
+      },
+      get size() {
+        return jobs.length;
+      }
+    };
+  }
   var end = (layer2, start) => start + layer2.duration + layer2.tail;
   var firstFilter = (layer2) => layer2.filters?.bank[0];
   var offsetOf = (layer2) => layer2.source.kind === "noise" ? layer2.source.offset : 0;
@@ -37192,15 +37533,43 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ...playOptions.params ? { params: playOptions.params } : {},
       ...options.occlusion && playOptions.position && recipe.falloff?.model !== "none" ? { occlusion: options.occlusion(playOptions.position) } : {}
     });
-    const start = (plan, store, voiceId, delay = 0) => {
+    const startQueue = options.deferredStart ? createStartQueue(options.deferredStart) : null;
+    const build = (plan, store, delay) => {
       const audio = context;
-      const realized = realize(plan, {
+      return realize(plan, {
         context: audio,
         output: outputFor(plan.bus),
         ...chain?.wet ? { wet: chain.wet } : {},
         noise: () => noiseBuffer(store, audio, mix3.noise.seconds),
         time: audio.currentTime + delay
       });
+    };
+    const deferVoice = (plan, store, voiceId, delay) => {
+      let built = null;
+      let cancelled = false;
+      const pending = {
+        get sources() {
+          return built?.sources ?? [];
+        },
+        stop() {
+          cancelled = true;
+          built?.stop();
+        }
+      };
+      startQueue.push({
+        run() {
+          if (!cancelled && context) built = build(plan, store, delay);
+        },
+        drop() {
+          if (voiceId === void 0) return;
+          voices.release(voiceId);
+          active.delete(voiceId);
+        }
+      });
+      return pending;
+    };
+    const start = (plan, store, voiceId, delay = 0) => {
+      const realized = startQueue ? deferVoice(plan, store, voiceId, delay) : build(plan, store, delay);
       if (voiceId === void 0) return null;
       voices.setLength(voiceId, plan.length + delay);
       active.set(voiceId, realized);
@@ -37316,6 +37685,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const audio = ready();
         if (audio) unlockContext(audio);
       },
+      warmUp() {
+        const audio = ready();
+        if (!audio) return false;
+        noiseBuffer(shared, audio, mix3.noise.seconds);
+        return true;
+      },
       level(bus) {
         watched.add(bus);
         ensureBus(bus);
@@ -37339,6 +37714,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         };
       },
       dispose() {
+        startQueue?.clear();
         for (const id of active.keys()) voices.release(id);
         for (const loop of [...loops]) loop.stop();
         active.clear();
@@ -38574,6 +38950,83 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
   };
 
+  // src/fx/body-hold.ts
+  var BODY_HOLD = {
+    /** With no body to lend the frame: the pocket of the right shoulder from the eye, in the eye's yaw frame (right, up, back). */
+    eyeToPocket: [0.2, -0.275, 0.17],
+    /** A shouldered gun's bore runs this far above the shoulder pocket (the cheek on the comb). */
+    boreAbove: 0.05,
+    /** A handgun's (or a short two-hand gun's) grip: toward the middle of the chest, a little low, at the reach of bent arms. */
+    handgunGrip: [-0.15, -0.04, -0.42],
+    /** A one-hand tool's grip: low in front of the body, the elbow bent. */
+    toolGrip: [0.02, -0.34, -0.3],
+    /** A tool at least this long, held by two hands, is shouldered (its stock in the pocket). */
+    shoulderedFrom: 0.55,
+    /** The farthest a shouldered gun's grip sits ahead of the pocket; a launcher whose grip is farther slides back, its tube behind the shoulder. */
+    shoulderGripMax: 0.42,
+    /** The nearest a shouldered gun's grip sits ahead of the pocket; a gun with no stock (a pistol grip at its rear) slides forward, its grip not behind the eye. */
+    shoulderGripMin: 0.25,
+    /** Where such a grip is brought to, ahead of the pocket. */
+    shoulderGripTo: 0.34,
+    /** The farthest apart two hands hold a long gun (a support hand past it slides back along the gun, toward the grip). */
+    supportSpan: 0.5,
+    /** How much of the aim's pitch a tool held low in one hand follows. */
+    toolPitch: 0.5
+  };
+  var scratch = { a: null, b: null, euler: null };
+  var placeOnBody = (placement) => {
+    const { THREE, hand, holder, frame: frame2 } = placement;
+    scratch.a ?? (scratch.a = new THREE.Vector3());
+    scratch.b ?? (scratch.b = new THREE.Vector3());
+    holder.scale.setScalar(1);
+    hand.position.set(...frame2.position);
+    hand.quaternion.set(...frame2.quaternion);
+    const shouldered = !placement.handgun && placement.left !== null && placement.lengthMetres >= BODY_HOLD.shoulderedFrom;
+    if (shouldered) {
+      holder.position.set(0, BODY_HOLD.boreAbove, placement.rear);
+      hand.updateMatrixWorld(true);
+      if (!placement.right) return;
+      const grip2 = hand.worldToLocal(placement.right.part.localToWorld(scratch.a.copy(placement.right.offset)));
+      if (-grip2.z <= BODY_HOLD.shoulderGripMax && -grip2.z >= BODY_HOLD.shoulderGripMin) return;
+      holder.position.z += -grip2.z - BODY_HOLD.shoulderGripTo;
+      hand.updateMatrixWorld(true);
+      return;
+    }
+    scratch.euler ?? (scratch.euler = new THREE.Euler());
+    const turn2 = scratch.euler.setFromQuaternion(hand.quaternion, "YXZ");
+    hand.quaternion.setFromEuler(turn2.set(turn2.x * BODY_HOLD.toolPitch, turn2.y, 0, "YXZ"));
+    holder.position.set(0, 0, 0);
+    hand.updateMatrixWorld(true);
+    if (!placement.right) return;
+    const grip = placement.handgun || placement.left ? BODY_HOLD.handgunGrip : BODY_HOLD.toolGrip;
+    const want = scratch.a.set(grip[0], grip[1], grip[2]).applyQuaternion(hand.quaternion).add(hand.position);
+    const now = placement.right.part.localToWorld(scratch.b.copy(placement.right.offset));
+    hand.position.add(want.sub(now));
+    hand.updateMatrixWorld(true);
+  };
+  var limitSupportSpan = (targets) => {
+    const right = targets.R?.position;
+    const left = targets.L?.position;
+    if (!right || !left || !targets.L) return targets;
+    const span = Math.hypot(left[0] - right[0], left[1] - right[1], left[2] - right[2]);
+    if (span <= BODY_HOLD.supportSpan) return targets;
+    const k = BODY_HOLD.supportSpan / span;
+    const position = [right[0] + (left[0] - right[0]) * k, right[1] + (left[1] - right[1]) * k, right[2] + (left[2] - right[2]) * k];
+    return { ...targets, L: { ...targets.L, position } };
+  };
+  var createEyeFrame = (THREE, camera2) => {
+    const frame2 = { position: [0, 0, 0], quaternion: [0, 0, 0, 1] };
+    const turn2 = new THREE.Euler(0, 0, 0, "YXZ");
+    const pocket = new THREE.Vector3();
+    return () => {
+      turn2.setFromQuaternion(camera2.quaternion, "YXZ");
+      pocket.set(...BODY_HOLD.eyeToPocket).applyEuler(turn2.set(0, turn2.y, 0)).add(camera2.position);
+      frame2.position = [pocket.x, pocket.y, pocket.z];
+      frame2.quaternion = [camera2.quaternion.x, camera2.quaternion.y, camera2.quaternion.z, camera2.quaternion.w];
+      return frame2;
+    };
+  };
+
   // src/fx/hand-hold.ts
   var HAND_HOLD = {
     /** Half the width of a pistol grip, the palm sits this far (plus the palm) off its middle. */
@@ -38602,9 +39055,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     /** How far the shooting hand slides on its grip so the thumb reaches the safety lever. */
     thumbReach: 0.02,
     /** How fast the supporting hand goes to the magazine and back, per second. */
-    magRate: 7,
-    /** The hands shrink with the tool: a tool drawn at scale `s` takes hands at `s ** handScaleExponent`. */
-    handScaleExponent: 0.55
+    magRate: 7
   };
   var handFrame = (THREE, x, y) => {
     const ax = x.clone().normalize();
@@ -38694,7 +39145,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       right,
       left,
       leftMagazine,
-      scale: holderScale ** HAND_HOLD.handScaleExponent,
+      // the hands at the tool's scale: a tool drawn smaller than the hands looks like a toy in them
+      scale: holderScale,
       grip: HAND_HOLD.closed,
       gripLeft: HAND_HOLD.forend
     };
@@ -38709,7 +39161,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const long = head && ["smg", "carbine", "rifle", "sniper", "shotgun", "crossbow", "flame"].includes(category);
     const headSize = head ? size(head) : null;
     const left = long && head && headSize ? { part: group, offset: head.position.clone().add(V(THREE, -headSize.x * 0.15, -headSize.y / 2 - HAND_HOLD.palm, 0)), quaternion: forendFrame(THREE) } : null;
-    return { right, left, leftMagazine: null, scale: scale ** HAND_HOLD.handScaleExponent, grip: HAND_HOLD.closed, gripLeft: HAND_HOLD.forend };
+    return { right, left, leftMagazine: null, scale, grip: HAND_HOLD.closed, gripLeft: HAND_HOLD.forend };
   }
 
   // ../game-fluids/dist/index.js
@@ -39847,6 +40299,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         liquid: "honey",
         fill: 0.9
       }
+    },
+    shapes: {
+      box: {
+        hollow: true,
+        welded: true
+      }
     }
   };
   var DESTRUCTION_MATERIAL_BY_TAG = {
@@ -39860,6 +40318,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   };
   var FAMILIES = destruction_default.families;
   var CONTENTS = destruction_default.contents;
+  var SHAPES2 = destruction_default.shapes;
+  var shapeDestruction = (shapeId) => SHAPES2[shapeId];
   var FAMILY_OF_MODEL = new Map(Object.entries(FAMILIES).flatMap(([family, entry2]) => entry2.models.map((model) => [model, family])));
   var itemDestruction = (modelId) => {
     const family = FAMILY_OF_MODEL.get(modelId);
@@ -39973,9 +40433,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     root.userData.tessellationTriangles = added;
   }
   function tagForDestruction(root, options = {}) {
-    const { modelId, weight, size, three } = options;
+    const { modelId, shapeId, weight, size, powder, three } = options;
     if (weight !== void 0 && weight > 0) root.userData.destructionMass = weight;
-    const rule = modelId === void 0 ? void 0 : itemDestruction(modelId);
+    const rule = modelId !== void 0 ? itemDestruction(modelId) : shapeId !== void 0 ? shapeDestruction(shapeId) : void 0;
     if (rule?.tessellate) tessellateShapes(root, rule.tessellate, three);
     const solid2 = [];
     root.traverse((object2) => {
@@ -39990,6 +40450,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return;
       }
       if (rule?.hollow) mesh3.userData.hollow = true;
+      if (powder) mesh3.userData.destructionPowder = { color: powder.color };
       solid2.push(mesh3);
     });
     if (!rule?.welded || solid2.length < 2) return;
@@ -42467,10 +42928,41 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const m = metal2(9277590);
     return G(mesh3(cyl(0.32, 0.32, 0.52), m), mesh3(cyl(0.326, 0.326, 0.34, 14), food(10172964)), mesh3(cyl(0.33, 0.33, 0.06), paper2(14861162), [0, 0.02, 0]), mesh3(torus2(0.31, 0.025), m, [0, 0.26, 0], [Math.PI / 2, 0, 0]), mesh3(torus2(0.31, 0.025), m, [0, -0.26, 0], [Math.PI / 2, 0, 0]));
   };
-  var waterBottle = ({ mesh: mesh3, cyl, lathe: lathe2, G, plastic, paper: paper2, glass }) => G(mesh3(lathe2([[0, -0.6], [0.2, -0.6], [0.22, -0.5], [0.22, 0.2], [0.19, 0.32], [0.09, 0.45], [0.08, 0.55], [0, 0.55]]), glass(9421788, 0.55)), mesh3(cyl(0.085, 0.085, 0.1, 12), plastic(2907530), [0, 0.6, 0]), mesh3(cyl(0.225, 0.225, 0.22, 16), paper2(15330543), [0, -0.15, 0]), mesh3(cyl(0.226, 0.226, 0.05, 16), plastic(3831976), [0, -0.12, 0]));
+  var opening_default = {
+    families: {
+      drink_can: { style: "pull_tab" },
+      food_tin: { style: "cut_lid" }
+    },
+    models: {
+      empty_can: { style: "none" },
+      canned_beans: { food: "#7a2e1c" },
+      canned_corn_and_peas: { food: "#c7b03c" },
+      canned_sausages: { food: "#c98d5c" },
+      canned_sardines: { style: "peel_lid", food: "#8e979c" },
+      condensed_milk: { food: "#e3cf9c" },
+      energy_drink: { style: "pull_tab" },
+      honey_jar: { style: "screw_cap", food: "#d99a1c" },
+      home_preserves: { style: "screw_cap", food: "#8e1f3a" },
+      cooking_oil: { style: "screw_cap", food: "#e3b830" },
+      water_bottle: { style: "screw_cap" },
+      water_jug_5l: { style: "screw_cap" },
+      dirty_water: { style: "screw_cap" },
+      sports_drink: { style: "screw_cap" },
+      coconut_water: { style: "screw_cap" },
+      cachaca: { style: "screw_cap" },
+      communion_wine: { style: "screw_cap" }
+    }
+  };
+  var FAMILIES2 = opening_default.families;
+  var MODELS = opening_default.models;
+  var asLid = (mesh3) => {
+    mesh3.userData.itemLid = true;
+    return mesh3;
+  };
+  var waterBottle = ({ mesh: mesh3, cyl, lathe: lathe2, G, plastic, paper: paper2, glass }) => G(mesh3(lathe2([[0, -0.6], [0.2, -0.6], [0.22, -0.5], [0.22, 0.2], [0.19, 0.32], [0.09, 0.45], [0.08, 0.55], [0, 0.55]]), glass(9421788, 0.55)), asLid(mesh3(cyl(0.085, 0.085, 0.1, 12), plastic(2907530), [0, 0.6, 0])), mesh3(cyl(0.225, 0.225, 0.22, 16), paper2(15330543), [0, -0.15, 0]), mesh3(cyl(0.226, 0.226, 0.05, 16), plastic(3831976), [0, -0.12, 0]));
   var rice = ({ mesh: mesh3, bx, G, paper: paper2, food }) => G(mesh3(bx(0.7, 0.95, 0.28), paper2(15129792)), mesh3(bx(0.72, 0.12, 0.1), paper2(14010792), [0, 0.52, 0]), mesh3(bx(0.5, 0.3, 0.02), food(11883039), [0, 0.05, 0.15]), mesh3(bx(0.3, 0.1, 0.02), paper2(4160069), [0, -0.25, 0.15]));
   var militaryRation = ({ mesh: mesh3, bx, G, plastic, paper: paper2 }) => G(mesh3(bx(0.75, 1, 0.22), plastic(5923142)), mesh3(bx(0.77, 0.1, 0.23), plastic(4672823), [0, 0.48, 0]), mesh3(bx(0.5, 0.14, 0.01), paper2(2237727), [0, 0.18, 0.115]), mesh3(bx(0.36, 0.06, 0.01), paper2(2237727), [0, -0.02, 0.115]));
-  var cachaca = ({ mesh: mesh3, cyl, lathe: lathe2, G, wood, paper: paper2, food, glass }) => G(mesh3(lathe2([[0, -0.6], [0.25, -0.6], [0.27, -0.52], [0.27, 0.1], [0.2, 0.25], [0.09, 0.35], [0.09, 0.58], [0, 0.58]]), glass(12749354, 0.78)), mesh3(cyl(0.08, 0.07, 0.14, 10), wood(9071172), [0, 0.64, 0]), mesh3(cyl(0.275, 0.275, 0.34, 16), paper2(15327692), [0, -0.25, 0]), mesh3(cyl(0.276, 0.276, 0.06, 16), food(8007455), [0, -0.15, 0]));
+  var cachaca = ({ mesh: mesh3, cyl, lathe: lathe2, G, wood, paper: paper2, food, glass }) => G(mesh3(lathe2([[0, -0.6], [0.25, -0.6], [0.27, -0.52], [0.27, 0.1], [0.2, 0.25], [0.09, 0.35], [0.09, 0.58], [0, 0.58]]), glass(12749354, 0.78)), asLid(mesh3(cyl(0.08, 0.07, 0.14, 10), wood(9071172), [0, 0.64, 0])), mesh3(cyl(0.275, 0.275, 0.34, 16), paper2(15327692), [0, -0.25, 0]), mesh3(cyl(0.276, 0.276, 0.06, 16), food(8007455), [0, -0.15, 0]));
   var firstAidKit = ({ mesh: mesh3, bx, torus: torus2, G, plastic }) => {
     const r = plastic(11680300);
     return G(mesh3(bx(1.05, 0.72, 0.38), plastic(15131608)), mesh3(bx(1.07, 0.06, 0.4), plastic(12433578), [0, 0, 0]), mesh3(bx(0.36, 0.1, 0.02), r, [0, 0.1, 0.2]), mesh3(bx(0.1, 0.36, 0.02), r, [0, 0.1, 0.2]), mesh3(torus2(0.16, 0.035, Math.PI), plastic(5591884), [0, 0.36, 0]));
@@ -42630,7 +43122,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     mesh3(cyl(0.41, 0.41, 0.86, 12), food(9314106), [0, -0.2, 0]),
     mesh3(cyl(0.34, 0.445, 0.12, 12), glass(13625070, 0.5), [0, 0.39, 0]),
     mesh3(cyl(0.34, 0.34, 0.05, 12), glass(13625070, 0.5), [0, 0.475, 0]),
-    mesh3(cyl(0.38, 0.38, 0.15, 12), metal2(12163644), [0, 0.575, 0]),
+    asLid(mesh3(cyl(0.38, 0.38, 0.15, 12), metal2(12163644), [0, 0.575, 0])),
     mesh3(cyl(0.45, 0.45, 0.4, 12), paper2(15327172), [0, -0.2, 0]),
     mesh3(cyl(0.452, 0.452, 0.08, 12), cloth2(10172986), [0, -0.2, 0])
   );
@@ -42805,7 +43297,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     mesh3(cyl(0.395, 0.395, 0.68, 12), glass(14925936, 0.55), [0, -0.16, 0]),
     mesh3(cyl(0.37, 0.37, 0.6, 12), food(14260764), [0, -0.2, 0]),
     mesh3(cyl(0.3, 0.395, 0.14, 12), glass(14925936, 0.55), [0, 0.25, 0]),
-    mesh3(cyl(0.3, 0.3, 0.18, 12), metal2(7031324), [0, 0.41, 0]),
+    asLid(mesh3(cyl(0.3, 0.3, 0.18, 12), metal2(7031324), [0, 0.41, 0])),
     mesh3(cyl(0.4, 0.4, 0.34, 12), paper2(15853512), [0, -0.2, 0]),
     mesh3(cyl(0.402, 0.402, 0.05, 12), paper2(9067028), [0, -0.1, 0]),
     mesh3(cyl(0.402, 0.402, 0.05, 12), paper2(9067028), [0, -0.3, 0])
@@ -42891,7 +43383,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     mesh3(cyl(0.345, 0.345, 1.7, 12), glass(14923824, 0.65), [0, -0.45, 0]),
     mesh3(cyl(0.12, 0.345, 0.5, 12), glass(14923824, 0.65), [0, 0.65, 0]),
     mesh3(cyl(0.12, 0.12, 0.25, 12), glass(14923824, 0.65), [0, 1.025, 0]),
-    mesh3(cyl(0.14, 0.14, 0.15, 12), plastic(4160042), [0, 1.225, 0]),
+    asLid(mesh3(cyl(0.14, 0.14, 0.15, 12), plastic(4160042), [0, 1.225, 0])),
     mesh3(cyl(0.35, 0.35, 0.8, 12), paper2(15853512), [0, -0.5, 0]),
     mesh3(cyl(0.352, 0.352, 0.2, 12), paper2(4160042), [0, -0.5, 0])
   );
@@ -42923,7 +43415,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const body = mesh3(bx(1.5, 2.3, 1.5), glass(10473710, 0.75), [0, -0.5, 0]);
     const shoulder = mesh3(bx(1.2, 0.45, 1.2), glass(10473710, 0.75), [0, 0.875, 0]);
     const neck = mesh3(cyl(0.34, 0.34, 0.3, 12), dark, [0, 1.25, 0]);
-    const cap = mesh3(cyl(0.4, 0.4, 0.25, 12), dark, [0, 1.525, 0]);
+    const cap = asLid(mesh3(cyl(0.4, 0.4, 0.25, 12), dark, [0, 1.525, 0]));
     const grip = mesh3(bx(0.16, 0.9, 0.3), dark, [1.07, 0.6, 0]);
     const upperBar = mesh3(bx(0.45, 0.16, 0.3), dark, [0.925, 0.97, 0]);
     const lowerBar = mesh3(bx(0.45, 0.16, 0.3), dark, [0.925, 0.23, 0]);
@@ -42936,7 +43428,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const label = mesh3(cyl(0.332, 0.332, 0.7, 12), paper2(1448738), [0, -0.12, 0]);
     const stripe = mesh3(cyl(0.332, 0.332, 0.1, 12), paper2(15753232), [0, 0.28, 0]);
     const collar = mesh3(cyl(0.2, 0.2, 0.04, 12), plastic(15263976), [0, 0.705, 0]);
-    const cap = mesh3(cyl(0.19, 0.19, 0.2, 12), plastic(15753232), [0, 0.815, 0]);
+    const cap = asLid(mesh3(cyl(0.19, 0.19, 0.2, 12), plastic(15753232), [0, 0.815, 0]));
     return G(bottle2, label, stripe, collar, cap);
   };
   var milkCarton = ({ mesh: mesh3, bx, cyl, extrude: extrude2, G, paper: paper2, plastic }) => {
@@ -42975,7 +43467,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const goldBand = mesh3(cyl(0.382, 0.382, 0.05, 12), metal2(11896880), [0, 0.075, 0]);
     const crossUpright = mesh3(bx(0.06, 0.26, 0.02), paper2(8003371), [0, -0.35, 0.375]);
     const crossArm = mesh3(bx(0.18, 0.06, 0.02), paper2(8003371), [0, -0.3, 0.375]);
-    const foil = mesh3(cyl(0.15, 0.15, 0.46, 12), metal2(11896880), [0, 1.27, 0]);
+    const foil = asLid(mesh3(cyl(0.15, 0.15, 0.46, 12), metal2(11896880), [0, 1.27, 0]));
     return G(bottle2, label, goldBand, crossUpright, crossArm, foil);
   };
   var coconutWater = ({ mesh: mesh3, bx, cyl, lathe: lathe2, G, plastic, paper: paper2 }) => {
@@ -42984,7 +43476,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const nut = mesh3(cyl(0.11, 0.11, 0.03, 10), paper2(7031339), [0, -0.12, 0.285], [Math.PI / 2, 0, 0]);
     const leafLeft = mesh3(bx(0.2, 0.05, 0.01), paper2(15135448), [-0.12, 0.08, 0.292], [0, 0, 0.5]);
     const leafRight = mesh3(bx(0.2, 0.05, 0.01), paper2(15135448), [0.12, 0.08, 0.292], [0, 0, -0.5]);
-    const cap = mesh3(cyl(0.14, 0.14, 0.2, 12), plastic(4165450), [0, 0.75, 0]);
+    const cap = asLid(mesh3(cyl(0.14, 0.14, 0.2, 12), plastic(4165450), [0, 0.75, 0]));
     return G(bottle2, label, nut, leafLeft, leafRight, cap);
   };
   var dirtyWater = ({ mesh: mesh3, cyl, lathe: lathe2, G, plastic, paper: paper2, glass, food }) => {
@@ -42992,7 +43484,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const murk = mesh3(lathe2([[0, -0.89], [0.27, -0.89], [0.315, -0.84], [0.315, 0.1], [0, 0.1]], 12), food(7035444));
     const sediment = mesh3(cyl(0.31, 0.27, 0.12, 8), food(4865314), [0, -0.82, 0]);
     const label = mesh3(cyl(0.332, 0.332, 0.22, 12), paper2(13617588), [0, 0.38, 0]);
-    const cap = mesh3(cyl(0.19, 0.19, 0.2, 8), plastic(5922920), [0, 0.815, 0]);
+    const cap = asLid(mesh3(cyl(0.19, 0.19, 0.2, 8), plastic(5922920), [0, 0.815, 0]));
     return G(bottle2, murk, sediment, label, cap);
   };
   var painkillers = ({ mesh: mesh3, bx, cyl, G, paper: paper2, metal: metal2, glass }) => {
@@ -45608,7 +46100,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const materials = kit.materials.slice(first);
     if (options.wear) setWear(materials, options.wear);
     root.userData.wear = options.wear ?? 0;
-    if (options.destructible) tagForDestruction(root, { ...kind === "model" && item.model !== void 0 ? { modelId: item.model } : {}, ...item.weight === void 0 ? {} : { weight: item.weight }, size: item.size, three: T2 });
+    if (options.destructible) tagForDestruction(root, { ...kind === "model" && item.model !== void 0 ? { modelId: item.model } : {}, ...shape === void 0 ? {} : { shapeId: shape }, ...item.weight === void 0 ? {} : { weight: item.weight }, size: item.size, ...item.powder ? { powder: item.powder } : {}, three: T2 });
     markKitOrigin(root, { owner: "game-items-three", kind: "item", id: item.id, ...kind === "shape" ? { standIn: true } : {} });
     return { root, kind, ...shape ? { shape } : {}, size: item.size, materials };
   }
@@ -48895,7 +49387,6 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var MAX_CASINGS = 120;
   var MAX_MAGAZINES = 12;
   var LIFETIME_S = 25;
-  var HAND_OFFSET = [0.2, -0.2, -0.42];
   var GRAVITY2 = 9.81;
   function createBoxFx(options) {
     const { THREE, scene, camera: camera2, arsenal, groundAt } = options;
@@ -48917,6 +49408,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     let dip = 0;
     let reloading = false;
     const v = new THREE.Vector3();
+    const v2 = new THREE.Vector3();
+    const eyeFrame = createEyeFrame(THREE, camera2);
+    let rear = 0;
+    let lengthMetres = 0;
     const q = new THREE.Quaternion();
     const q2 = new THREE.Quaternion();
     const pointForward = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI / 2);
@@ -48928,13 +49423,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (!def || BODY_ACTIONS.has(def.id)) return;
       model = buildWeaponModel(THREE, def);
       const length2 = new THREE.Box3().setFromObject(model).getSize(v).x;
-      model.scale.setScalar(length2 > 0.8 ? 0.55 : length2 > 0.4 ? 0.75 : 1);
+      rear = new THREE.Box3().setFromObject(model).min.x;
+      lengthMetres = length2;
       model.quaternion.copy(pointForward);
       hand.add(model);
       inHand = def.id;
-      hold = holdOfProp(THREE, model, def.category, model.scale.x);
+      hold = holdOfProp(THREE, model, def.category, 1);
+    };
+    const handPoint = (x, y, z, out) => {
+      if (!model) return out.set(x, y, z).applyQuaternion(camera2.quaternion).add(camera2.position);
+      return out.set(x, y, z).applyQuaternion(camera2.quaternion).add(model.getWorldPosition(v2));
     };
-    const handPoint = (x, y, z, out) => out.set(HAND_OFFSET[0] + x, HAND_OFFSET[1] + y, HAND_OFFSET[2] + z).applyQuaternion(camera2.quaternion).add(camera2.position);
     const throwBody = (kind, mesh3, from, velocity, radius) => {
       if (!(kind === "casing" ? layers.casings : layers.magazines)) {
         mesh3.geometry.dispose();
@@ -49045,10 +49544,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       update(dt) {
         kick *= Math.exp(-dt * 14);
         dip += ((reloading ? 1 : 0) - dip) * Math.min(1, dt * 8);
-        if (inHand) {
-          handPoint(0, -0.12 * dip, 0.05 * kick, hand.position);
+        if (inHand && model) {
+          const handgun = def?.category === "pistol" || def?.category === "revolver";
+          placeOnBody({ THREE, hand, holder: model, frame: options.bodyHold?.() ?? eyeFrame(), rear, lengthMetres, handgun, right: hold?.right ?? null, left: hold?.left ?? null });
+          hand.position.add(v.set(0, -0.12 * dip, 0.05 * kick).applyQuaternion(camera2.quaternion));
           q.setFromEuler(new THREE.Euler(0.14 * kick - 0.25 * dip, 0, 0.6 * dip));
-          hand.quaternion.copy(camera2.quaternion).multiply(q);
+          hand.quaternion.multiply(q);
         }
         for (const body of [...bodies]) {
           stepBody(body, dt);
@@ -57769,6 +58270,11 @@ void main(){
   var MAX_CONFORM_STEPS = 48;
   var MIN_CONFORM_STEPS = 16;
   var BLOOD_GROW_RATE = 1.2;
+  var BLOOD_START_GROWTH = 0.05;
+  var DEFAULT_MAX_GROUND_MARKS = 64;
+  var DEFAULT_MAX_ROCKS = 512;
+  var DEFAULT_MAX_BLOOD = 256;
+  var MAX_SPARE_GROUND_GEOMETRIES = 16;
   function createMarkLayer(THREE, options) {
     const group = new THREE.Group();
     const textures = createMarkTextures(THREE, options.createCanvas);
@@ -57792,110 +58298,168 @@ void main(){
     const bloodMaterial = new THREE.MeshStandardMaterial({ color: 6031882, roughness: 0.15, metalness: 0.1, polygonOffset: true, polygonOffsetFactor: -3, polygonOffsetUnits: -3 });
     const bloodGeometry = new THREE.CircleGeometry(0.5, 9).rotateX(-Math.PI / 2);
     owned.push(bloodMaterial, bloodGeometry);
-    const rockMaterials = /* @__PURE__ */ new Map();
-    const blood = [];
-    let meshCount = 0;
-    function rockMaterial(color2) {
-      let material = rockMaterials.get(color2);
-      if (!material) {
-        material = new THREE.MeshStandardMaterial({ color: color2, roughness: 0.9, metalness: 0, flatShading: true });
-        rockMaterials.set(color2, material);
-        owned.push(material);
+    const maxGroundMarks = options.maxGroundMarks ?? DEFAULT_MAX_GROUND_MARKS;
+    const instanced = {};
+    function rockMaterial() {
+      if (!instanced.rockMaterial) {
+        instanced.rockMaterial = new THREE.MeshStandardMaterial({ color: 16777215, roughness: 0.9, metalness: 0, flatShading: true });
+        owned.push(instanced.rockMaterial);
       }
-      return material;
+      return instanced.rockMaterial;
+    }
+    function bloodMesh() {
+      return instanced.blood ?? (instanced.blood = attach(createInstanced(bloodGeometry, bloodMaterial, options.maxBlood ?? DEFAULT_MAX_BLOOD)));
+    }
+    function rockMesh() {
+      return instanced.rock ?? (instanced.rock = attach(createInstanced(options.rockGeometry, rockMaterial(), options.maxRocks ?? DEFAULT_MAX_ROCKS), true));
+    }
+    function plateMesh() {
+      return instanced.plate ?? (instanced.plate = attach(createInstanced(options.plateGeometry, rockMaterial(), options.maxRocks ?? DEFAULT_MAX_ROCKS), true));
+    }
+    function attach(mesh3, castShadow = false) {
+      mesh3.castShadow = castShadow;
+      group.add(mesh3);
+      return mesh3;
+    }
+    const groundMarks = [];
+    const spareGeometries = [];
+    const blood = [];
+    const placed = { blood: 0, rock: 0, plate: 0 };
+    const matrix = new THREE.Matrix4();
+    const position = new THREE.Vector3();
+    const quaternion2 = new THREE.Quaternion();
+    const euler = new THREE.Euler();
+    const scale = new THREE.Vector3();
+    const color2 = new THREE.Color();
+    const up = new THREE.Vector3(0, 1, 0);
+    function createInstanced(geometry, material, capacity) {
+      const mesh3 = new THREE.InstancedMesh(geometry, material, capacity);
+      mesh3.count = 0;
+      mesh3.frustumCulled = false;
+      mesh3.receiveShadow = true;
+      return mesh3;
+    }
+    function takeSpare(vertexCount) {
+      const found = spareGeometries.findIndex((geometry) => geometry.getAttribute("position").count === vertexCount);
+      return found < 0 ? void 0 : spareGeometries.splice(found, 1)[0];
+    }
+    function evictOldestGroundMark() {
+      const oldest = groundMarks.shift();
+      group.remove(oldest.mesh);
+      spareGeometries.push(oldest.mesh.geometry);
+      if (spareGeometries.length > MAX_SPARE_GROUND_GEOMETRIES) spareGeometries.shift().dispose();
     }
     function conform(mark, material) {
       const radius = mark.radius;
       const steps = Math.max(MIN_CONFORM_STEPS, Math.min(MAX_CONFORM_STEPS, Math.round(radius * 8)));
-      const geometry = new THREE.PlaneGeometry(2, 2, steps, steps).rotateX(-Math.PI / 2);
-      const position = geometry.attributes.position;
+      if (groundMarks.length >= maxGroundMarks) evictOldestGroundMark();
+      const geometry = takeSpare((steps + 1) * (steps + 1)) ?? new THREE.PlaneGeometry(2, 2, steps, steps).rotateX(-Math.PI / 2);
+      const grid = geometry.attributes.position;
+      const cell = 2 / steps;
       const cos2 = Math.cos(mark.rotation);
       const sin2 = Math.sin(mark.rotation);
-      for (let index = 0; index < position.count; index++) {
-        const localX = position.getX(index) * radius;
-        const localZ = position.getZ(index) * radius;
+      for (let index = 0; index < grid.count; index++) {
+        const localX = Math.fround(index % (steps + 1) * cell - 1) * radius;
+        const localZ = Math.fround(Math.floor(index / (steps + 1)) * cell - 1) * radius;
         const worldX = mark.x + localX * cos2 - localZ * sin2;
         const worldZ = mark.z + localX * sin2 + localZ * cos2;
-        position.setXYZ(index, worldX, (options.ground?.heightAt(worldX, worldZ) ?? 0) + mark.lift, worldZ);
+        grid.setXYZ(index, worldX, (options.ground?.heightAt(worldX, worldZ) ?? 0) + mark.lift, worldZ);
       }
+      grid.needsUpdate = true;
       geometry.computeVertexNormals();
+      geometry.attributes.normal.needsUpdate = true;
+      geometry.boundingSphere = null;
+      geometry.boundingBox = null;
       const mesh3 = new THREE.Mesh(geometry, material);
       mesh3.receiveShadow = true;
-      return mesh3;
+      group.add(mesh3);
+      groundMarks.push({ mesh: mesh3, steps });
     }
     function addRock(mark) {
-      const mesh3 = new THREE.Mesh(mark.plate ? options.plateGeometry : options.rockGeometry, rockMaterial(mark.color));
-      mesh3.position.set(mark.x, mark.y, mark.z);
-      mesh3.scale.set(mark.scale[0], mark.scale[1], mark.scale[2]);
-      mesh3.rotation.set(mark.rotation[0], mark.rotation[1], mark.rotation[2]);
-      mesh3.castShadow = true;
-      mesh3.receiveShadow = true;
-      return mesh3;
+      const mesh3 = mark.plate ? plateMesh() : rockMesh();
+      const slot = mark.plate ? "plate" : "rock";
+      const index = placed[slot]++ % mesh3.instanceMatrix.count;
+      quaternion2.setFromEuler(euler.set(mark.rotation[0], mark.rotation[1], mark.rotation[2]));
+      mesh3.setMatrixAt(index, matrix.compose(position.set(mark.x, mark.y, mark.z), quaternion2, scale.set(mark.scale[0], mark.scale[1], mark.scale[2])));
+      mesh3.setColorAt(index, color2.set(mark.color));
+      mesh3.count = Math.min(placed[slot], mesh3.instanceMatrix.count);
+      mesh3.instanceMatrix.needsUpdate = true;
+      mesh3.instanceColor.needsUpdate = true;
+    }
+    function writeBlood(index, drawn, growth) {
+      quaternion2.setFromAxisAngle(up, drawn.rotation);
+      const mesh3 = bloodMesh();
+      mesh3.setMatrixAt(index, matrix.compose(position.set(drawn.position[0], drawn.position[1], drawn.position[2]), quaternion2, scale.set(drawn.scaleX * growth, 1, drawn.scaleZ * growth)));
+      mesh3.instanceMatrix.needsUpdate = true;
     }
     function addBlood(mark) {
-      const mesh3 = new THREE.Mesh(bloodGeometry, bloodMaterial);
-      mesh3.position.set(mark.x, mark.y, mark.z);
-      mesh3.scale.set(mark.scaleX, 1, mark.scaleZ);
-      mesh3.rotation.y = mark.rotation;
-      mesh3.receiveShadow = true;
-      mesh3.scale.multiplyScalar(0.05);
-      blood.push({ mesh: mesh3, scaleX: mark.scaleX, scaleZ: mark.scaleZ, age: 0 });
-      return mesh3;
+      const index = placed.blood++ % bloodMesh().instanceMatrix.count;
+      const drawn = { position: [mark.x, mark.y, mark.z], rotation: mark.rotation, scaleX: mark.scaleX, scaleZ: mark.scaleZ, age: 0 };
+      blood[index] = drawn;
+      writeBlood(index, drawn, BLOOD_START_GROWTH);
+      bloodMesh().count = Math.min(placed.blood, bloodMesh().instanceMatrix.count);
     }
     function build(mark) {
-      if (mark.kind === "scorch") return conform(mark, scorchMaterials[mark.variant]);
-      if (mark.kind === "dirt") return conform(mark, dirtMaterial);
-      if (mark.kind === "rock") return addRock(mark);
-      return addBlood(mark);
-    }
-    function clearMeshes() {
-      for (const child of [...group.children]) {
-        group.remove(child);
-        const geometry = child.geometry;
-        if (geometry !== options.rockGeometry && geometry !== options.plateGeometry && geometry !== bloodGeometry) geometry.dispose();
-      }
+      if (mark.kind === "scorch") conform(mark, scorchMaterials[mark.variant]);
+      else if (mark.kind === "dirt") conform(mark, dirtMaterial);
+      else if (mark.kind === "rock") addRock(mark);
+      else addBlood(mark);
+    }
+    function clearMarks() {
+      for (const drawn of groundMarks) group.remove(drawn.mesh);
+      for (const drawn of groundMarks) drawn.mesh.geometry.dispose();
+      groundMarks.length = 0;
+      for (const geometry of spareGeometries) geometry.dispose();
+      spareGeometries.length = 0;
       blood.length = 0;
-      meshCount = 0;
+      placed.blood = placed.rock = placed.plate = 0;
+      for (const mesh3 of [instanced.blood, instanced.rock, instanced.plate]) if (mesh3) mesh3.count = 0;
     }
     return {
       group,
       handle(event) {
-        if (event.type === "clear") {
-          clearMeshes();
-          return;
-        }
-        group.add(build(event.mark));
-        meshCount++;
+        if (event.type === "clear") clearMarks();
+        else build(event.mark);
+      },
+      prepare() {
+        bloodMesh();
+        rockMesh();
+        plateMesh();
       },
       update(dt) {
-        for (const drawn of blood) {
-          if (drawn.age > 1) continue;
+        for (let index = 0; index < blood.length; index++) {
+          const drawn = blood[index];
+          if (!drawn || drawn.age > 1) continue;
           drawn.age += dt * BLOOD_GROW_RATE;
-          const ease3 = 1 - Math.pow(1 - Math.min(1, drawn.age), 2.5);
-          drawn.mesh.scale.set(drawn.scaleX * Math.max(0.05, ease3), 1, drawn.scaleZ * Math.max(0.05, ease3));
+          writeBlood(index, drawn, Math.max(BLOOD_START_GROWTH, 1 - Math.pow(1 - Math.min(1, drawn.age), 2.5)));
         }
       },
-      count: () => meshCount,
+      count: () => groundMarks.length + [instanced.blood, instanced.rock, instanced.plate].filter((mesh3) => mesh3 && mesh3.count > 0).length,
       dispose() {
-        clearMeshes();
+        clearMarks();
+        for (const mesh3 of [instanced.blood, instanced.rock, instanced.plate]) mesh3?.dispose();
         for (const item of owned) item.dispose();
       }
     };
   }
   var SPHERE_DEFAULT_WIDTH = 8;
   var SPHERE_DEFAULT_HEIGHT = 6;
+  var MAX_PARKED_MESHES_PER_KIND = 256;
   function geometryOf(THREE, particle) {
     switch (particle.shape) {
       case "cone":
-        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, false);
+        return new THREE.ConeGeometry(1, 1, particle.segments || void 0, particle.segments2 || 1, false);
       case "cone_open":
-        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, true);
+        return new THREE.ConeGeometry(1, 1, particle.segments || void 0, particle.segments2 || 1, true);
       case "sphere":
-        return new THREE.SphereGeometry(particle.radius, particle.segments || SPHERE_DEFAULT_WIDTH, particle.segments2 || SPHERE_DEFAULT_HEIGHT);
+        return new THREE.SphereGeometry(1, particle.segments || SPHERE_DEFAULT_WIDTH, particle.segments2 || SPHERE_DEFAULT_HEIGHT);
       case "icosahedron":
-        return new THREE.IcosahedronGeometry(particle.radius, particle.segments);
+        return new THREE.IcosahedronGeometry(1, particle.segments);
     }
   }
+  function isCone(particle) {
+    return particle.shape === "cone" || particle.shape === "cone_open";
+  }
   function materialOf(THREE, particle) {
     if (particle.lit) return new THREE.MeshStandardMaterial({ color: particle.color, roughness: 1, metalness: 0, transparent: true, opacity: particle.opacity, depthWrite: false });
     return new THREE.MeshBasicMaterial({ color: particle.color, transparent: true, opacity: particle.opacity, depthWrite: false, ...particle.additive ? { blending: THREE.AdditiveBlending } : {} });
@@ -57906,51 +58470,82 @@ void main(){
       (kind) => new THREE.Mesh(geometry, materialOf(THREE, { ...kind, color: 8421504, opacity: 0.5 }))
     );
   }
+  function geometryKeyOf(particle) {
+    return `${particle.shape}:${particle.segments}:${particle.segments2}`;
+  }
   function createMeshLayer(THREE, pool) {
     const group = new THREE.Group();
     group.name = "workshop-meshes";
     const drawn = /* @__PURE__ */ new Map();
+    const geometries = /* @__PURE__ */ new Map();
+    const parked = /* @__PURE__ */ new Map();
     const frame2 = new THREE.Quaternion();
     const euler = new THREE.Euler();
     const turn2 = new THREE.Quaternion();
     const offset = new THREE.Vector3();
-    function release(mesh3) {
-      mesh3.removeFromParent();
-      mesh3.geometry.dispose();
-      mesh3.material.dispose();
+    let stamp = 0;
+    function geometryFor(particle) {
+      const key2 = geometryKeyOf(particle);
+      let geometry = geometries.get(key2);
+      if (!geometry) {
+        geometry = geometryOf(THREE, particle);
+        geometries.set(key2, geometry);
+      }
+      return geometry;
+    }
+    function acquire(particle) {
+      const parkingKey = `${geometryKeyOf(particle)}|${particle.lit}|${particle.additive}`;
+      const mesh3 = parked.get(parkingKey)?.pop() ?? new THREE.Mesh(geometryFor(particle), materialOf(THREE, particle));
+      mesh3.material.color.set(particle.color);
+      mesh3.frustumCulled = false;
+      mesh3.renderOrder = particle.additive ? 5 : 3;
+      group.add(mesh3);
+      return { mesh: mesh3, parkingKey, stamp };
+    }
+    function park(entry2) {
+      entry2.mesh.removeFromParent();
+      let free = parked.get(entry2.parkingKey);
+      if (!free) {
+        free = [];
+        parked.set(entry2.parkingKey, free);
+      }
+      if (free.length < MAX_PARKED_MESHES_PER_KIND) free.push(entry2.mesh);
+      else entry2.mesh.material.dispose();
     }
     return {
       group,
       sync() {
-        const live = /* @__PURE__ */ new Set();
+        stamp++;
         for (const particle of pool.particles) {
-          live.add(particle.id);
-          let mesh3 = drawn.get(particle.id);
-          if (!mesh3) {
-            mesh3 = new THREE.Mesh(geometryOf(THREE, particle), materialOf(THREE, particle));
-            mesh3.frustumCulled = false;
-            mesh3.renderOrder = particle.additive ? 5 : 3;
-            drawn.set(particle.id, mesh3);
-            group.add(mesh3);
+          let entry2 = drawn.get(particle.id);
+          if (!entry2) {
+            entry2 = acquire(particle);
+            drawn.set(particle.id, entry2);
           }
+          entry2.stamp = stamp;
+          const mesh3 = entry2.mesh;
           frame2.set(particle.frame[0], particle.frame[1], particle.frame[2], particle.frame[3]);
           offset.set(particle.at[0], particle.at[1], particle.at[2]).multiplyScalar(particle.scale).applyQuaternion(frame2);
           mesh3.position.set(particle.x + offset.x, particle.y + offset.y, particle.z + offset.z);
           turn2.setFromEuler(euler.set(particle.rx, particle.ry, particle.rz));
           mesh3.quaternion.copy(frame2).multiply(turn2);
-          mesh3.scale.setScalar(particle.scale);
+          mesh3.scale.set(particle.radius * particle.scale, (isCone(particle) ? particle.height : particle.radius) * particle.scale, particle.radius * particle.scale);
           mesh3.material.opacity = particle.opacity;
         }
-        for (const [id, mesh3] of drawn) {
-          if (live.has(id)) continue;
-          release(mesh3);
+        for (const [id, entry2] of drawn) {
+          if (entry2.stamp === stamp) continue;
+          park(entry2);
           drawn.delete(id);
         }
         return pool.count;
       },
       dispose() {
-        for (const mesh3 of drawn.values()) release(mesh3);
+        for (const entry2 of drawn.values()) park(entry2);
         drawn.clear();
+        for (const free of parked.values()) for (const mesh3 of free) mesh3.material.dispose();
+        parked.clear();
+        for (const geometry of geometries.values()) geometry.dispose();
+        geometries.clear();
         group.removeFromParent();
       }
     };
@@ -58518,7 +59113,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const shocks = createShockLayer(THREE, pools.shocks);
     const sprites = createSpriteLayer(THREE, world.sprites(), options.pointScale ?? 700);
     const lights = createLightLayer(THREE, pools.lights, options.lightScale ?? Math.PI);
-    const marks = createMarkLayer(THREE, { ground: pools.ground, createCanvas: options.createCanvas, rockGeometry, plateGeometry });
+    const marks = createMarkLayer(THREE, { ground: pools.ground, createCanvas: options.createCanvas, rockGeometry, plateGeometry, ...options.markLimits });
     root.add(puffs.mesh, sparks.mesh, glows.mesh, chunks.rocks, chunks.plates, shocks.group, lights.group, sprites.additive, sprites.normal, marks.group);
     const stopMarks = world.onMarks((event) => marks.handle(event));
     const overlay = options.overlay ? createScreenOverlay(options.overlay) : void 0;
@@ -58544,6 +59139,16 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       const position = options.camera.position;
       world.setCamera([position.x, position.y, position.z]);
     }
+    function attachWorkshopLayers() {
+      const engine = world.peekWorkshop();
+      if (!engine || engine === workshopEngine) return;
+      workshopLayers?.dispose();
+      if (workshopLayers) root.remove(workshopLayers.group);
+      workshopEngine = engine;
+      workshopLayers = createWorkshopLayers(THREE, engine, options.pointScale ?? 700, 1);
+      root.add(workshopLayers.group);
+      applyLayers();
+    }
     function syncAll() {
       lastDrawn.puffs = puffs.sync();
       lastDrawn.sparks = sparks.sync();
@@ -58552,15 +59157,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       lastDrawn.shocks = shocks.sync();
       lastDrawn.sprites = sprites.sync();
       lights.sync();
-      const engine = world.peekWorkshop();
-      if (engine && engine !== workshopEngine) {
-        workshopLayers?.dispose();
-        if (workshopLayers) root.remove(workshopLayers.group);
-        workshopEngine = engine;
-        workshopLayers = createWorkshopLayers(THREE, engine, options.pointScale ?? 700, 1);
-        root.add(workshopLayers.group);
-        applyLayers();
-      }
+      attachWorkshopLayers();
       const workshopCalls = workshopLayers?.sync() ?? 0;
       const glow = pools.lights.glow;
       uniforms.uGlowPos.value.set(glow.x, glow.y, glow.z);
@@ -58613,6 +59210,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       },
       warmUpProbes() {
         releaseAnchors();
+        marks.prepare();
+        world.workshop();
+        attachWorkshopLayers();
         const meshes = createMeshLayerProbes(THREE);
         for (const mesh3 of meshes) mesh3.frustumCulled = false;
         const group = new THREE.Group();
@@ -58679,6 +59279,14 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
 
   // src/fx/heavy.ts
   var PI14 = Math.PI;
+  var ROCKET_LIGHT_NAME = "rocket-light";
+  var rocketsInFlight = /* @__PURE__ */ new WeakMap();
+  function createRocketLight(THREE) {
+    const light = new THREE.PointLight(16751168, 0, 2.5);
+    light.name = ROCKET_LIGHT_NAME;
+    light.position.set(0, -50, 0);
+    return light;
+  }
   var flameMaterials = (kit) => {
     const { THREE } = kit;
     return [
@@ -58708,8 +59316,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     exhaust.rotation.z = PI14 / 2;
     exhaust.position.x = -0.08;
     rocket.add(exhaust);
-    const light = new THREE.PointLight(16751168, 3, 2.5);
-    rocket.add(light);
+    const light = context.rocketLight;
+    light.intensity = 3;
+    rocketsInFlight.set(light, (rocketsInFlight.get(light) ?? 0) + 1);
     context.every(
       1.6,
       (progress, dt) => {
@@ -58717,6 +59326,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const distance3 = 1.2 * flight + (flight > 0.25 ? 9 * (flight - 0.25) ** 2 : 0);
         rocket.position.copy(muzzle2).addScaledVector(forward, distance3);
         rocket.rotation.x += 0.25 * dt * 60;
+        light.position.copy(rocket.position);
         exhaust.scale.set(1, 0.6 + random() * 0.8, 1);
         if (random() < 0.9) context.effects.smoke(rocket.position.clone().addScaledVector(forward, -0.12), new THREE.Vector3((random() - 0.5) * 0.1, 0.05, (random() - 0.5) * 0.1), 0.02 + random() * 0.015, 2.2, 0.5);
       },
@@ -58724,7 +59334,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         rocket.removeFromParent();
         exhaust.geometry.dispose();
         exhaust.material.dispose();
-        light.dispose();
+        const remaining = (rocketsInFlight.get(light) ?? 1) - 1;
+        rocketsInFlight.set(light, remaining);
+        if (remaining > 0) return;
+        light.intensity = 0;
+        light.position.set(0, -50, 0);
       }
     );
   }
@@ -59539,11 +60153,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
 
   // src/fx/viewmodel.ts
   var PI16 = Math.PI;
-  var HAND_OFFSET2 = [0.2, -0.2, -0.42];
-  var HANDGUN_OFFSET = [0.1, -0.12, -0.44];
   var HEAT_DISPLAY_MAX_FALLBACK = 120;
-  var WALL_PULL = { margin: 0.03, max: 0.7, rate: 14, probe: 3 };
-  var HAND_IN_VIEW = { floor: -0.88, max: 0.18, rate: 10 };
+  var WALL_PULL = { margin: 0.03, max: 1.2, rate: 14, probe: 3 };
+  var HAND_IN_VIEW = { floor: -0.88, max: 0.3, rate: 10 };
   var LAUNCH_VOLUME = 0.6;
   var fittedOf2 = (parts) => parts.map((part) => ({ id: part.id, mount: part.mount, ...part.integral ? { integral: true } : {}, ...part.on === void 0 ? {} : { on: part.on } }));
   var collapsedStockPose = (move2) => {
@@ -59573,6 +60185,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const hand = new THREE.Group();
     hand.name = VIEWMODEL_NODE_NAME;
     scene.add(hand);
+    const rocketLight = createRocketLight(THREE);
+    scene.add(rocketLight);
     const holder = new THREE.Group();
     holder.quaternion.setFromAxisAngle(new THREE.Vector3(0, 1, 0), PI16 / 2);
     hand.add(holder);
@@ -59629,7 +60243,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       positionOf: (part) => worldPositionOf(current, part, new THREE.Vector3()),
       orientation: () => current.model.root.getWorldQuaternion(new THREE.Quaternion()),
       every: (seconds, step, done) => void tasks.push({ delay: 0, seconds, elapsed: 0, step, done }),
-      groundAt
+      groundAt,
+      rocketLight
     });
     const equip = (weapon) => {
       const def = arsenal.weapons.get(weapon);
@@ -59642,14 +60257,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       reach = 0;
       pull = 0;
       lift = 0;
-      handHeight = 0;
-      handDepth = 0;
       rigStock(THREE, model, def);
       rigUnderbarrel(THREE, model, def);
-      const length2 = new THREE.Box3().setFromObject(model.root).getSize(new THREE.Vector3()).x;
-      const scale = length2 > 0.8 ? 0.55 : length2 > 0.4 ? 0.75 : 1;
-      holder.scale.setScalar(scale);
-      holder.position.set(0, 0, Math.min(0.25, 0.25 * length2 * scale));
+      const modelBox = new THREE.Box3().setFromObject(model.root);
+      const length2 = modelBox.getSize(new THREE.Vector3()).x;
+      modelRear = modelBox.min.x;
       holder.add(model.root);
       const caliber = caliberOf(arsenal, def);
       const dims = caliber?.cartridge;
@@ -59661,7 +60273,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         def,
         caliber,
         model,
-        holderScale: scale,
+        holderScale: 1,
         lengthMetres: length2,
         caseType: caliber?.caseType ?? "rifle",
         soundProfile: soundProfileOf(weapon, model.parts.family),
@@ -59691,7 +60303,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       applyCondition(kit, model, condition);
       lastAmmo = options.tool?.().ammo ?? 0;
       hand.updateMatrixWorld(true);
-      hold = holdOfModel(THREE, model, scale);
+      hold = holdOfModel(THREE, model, 1);
       hold = { ...hold, works: handWorkOf(THREE, model, weapon, hold.right) };
       triggerRest = model.parts.trigger?.rotation.z ?? 0;
       lastShot = -Infinity;
@@ -59711,8 +60323,6 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     let reach = 0;
     let pull = 0;
     let lift = 0;
-    let handHeight = 0;
-    let handDepth = 0;
     const ahead = new THREE.Vector3();
     const up = new THREE.Vector3();
     const seen = new THREE.Vector3();
@@ -59725,23 +60335,35 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       for (const x of [bounds.min.x, bounds.max.x]) for (const y of [bounds.min.y, bounds.max.y]) for (const z of [bounds.min.z, bounds.max.z]) farthest = Math.max(farthest, corner.set(x, y, z).sub(camera2.position).dot(ahead));
       return farthest;
     };
+    let modelRear = 0;
+    const eyeFrame = createEyeFrame(THREE, camera2);
+    const liftToKeepInView = () => {
+      if (!hold || !session || !("fov" in camera2)) return 0;
+      const tanHalf = Math.tan((camera2.fov ?? 70) * PI16 / 360);
+      eyeTurn.copy(camera2.quaternion).invert();
+      const rest2 = targetsOf(THREE, hold, session.model.root.getWorldQuaternion(rootQuaternion), 0);
+      let needed = 0;
+      for (const [anchor, pose] of [[hold.right, rest2.R], [hold.left, rest2.L]]) {
+        if (!anchor || !pose || anchor.part !== session.model.root) continue;
+        seen.set(...pose.position).sub(camera2.position).applyQuaternion(eyeTurn);
+        if (-seen.z > 0.05) needed = Math.max(needed, HAND_IN_VIEW.floor * -seen.z * tanHalf - seen.y);
+      }
+      return Math.max(0, Math.min(HAND_IN_VIEW.max, needed));
+    };
     const place = (dt = 0) => {
-      const family = session?.model.parts.family;
-      const [x, y, z] = family === "pistol" || family === "revolver" ? HANDGUN_OFFSET : HAND_OFFSET2;
-      hand.position.set(x, y, z).applyQuaternion(camera2.quaternion).add(camera2.position);
-      hand.quaternion.copy(camera2.quaternion);
-      if (session && handDepth > 0.05 && "fov" in camera2) {
-        const tanHalf = Math.tan((camera2.fov ?? 70) * PI16 / 360);
-        const want2 = Math.max(0, Math.min(HAND_IN_VIEW.max, lift + (HAND_IN_VIEW.floor - handHeight) * tanHalf * handDepth));
-        lift += (want2 - lift) * Math.min(1, dt * HAND_IN_VIEW.rate);
-        if (lift > 1e-4) hand.position.addScaledVector(up.set(0, 1, 0).applyQuaternion(camera2.quaternion), lift);
-      }
+      if (!session) return;
+      const family = session.model.parts.family;
+      session.holderScale = 1;
+      placeOnBody({ THREE, hand, holder, frame: options.bodyHold?.() ?? eyeFrame(), rear: modelRear, lengthMetres: session.lengthMetres, handgun: family === "pistol" || family === "revolver", right: hold?.right ?? null, left: hold?.left ?? null });
       hand.updateMatrixWorld(true);
-      if (!options.contact || !session) return;
+      lift += (liftToKeepInView() - lift) * Math.min(1, dt * HAND_IN_VIEW.rate);
+      if (lift > 1e-4) hand.position.addScaledVector(up.set(0, 1, 0).applyQuaternion(camera2.quaternion), lift);
+      hand.updateMatrixWorld(true);
+      if (!options.contact) return;
       ahead.set(0, 0, -1).applyQuaternion(camera2.quaternion);
       if (reach === 0) reach = Math.max(0.01, measureReach(session));
       const free = options.contact(camera2.position, ahead, WALL_PULL.probe);
-      const want = free === null ? 0 : Math.max(0, Math.min(WALL_PULL.max, reach + WALL_PULL.margin - free));
+      const want = free === null ? 0 : Math.max(0, Math.min(Math.max(WALL_PULL.max, session.lengthMetres * session.holderScale), reach + WALL_PULL.margin - free));
       pull += (want - pull) * Math.min(1, dt * WALL_PULL.rate);
       if (pull < 1e-4) return;
       hand.position.addScaledVector(ahead, -pull);
@@ -59851,12 +60473,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         const targets = targetsOf(THREE, hold, session.model.root.getWorldQuaternion(rootQuaternion), magazineHand, hold.works ? workWeights(hold.works, player?.running ?? []) : void 0);
         const trigger = session.model.parts.trigger;
         if (trigger) targets.fingers = { index: indexCurl(trigger.rotation.z - triggerRest, clock - lastShot) };
-        if (targets.R && "fov" in camera2) {
-          seen.set(...targets.R.position).sub(camera2.position).applyQuaternion(eyeTurn.copy(camera2.quaternion).invert());
-          handDepth = -seen.z;
-          handHeight = handDepth > 0.05 ? seen.y / handDepth / Math.tan((camera2.fov ?? 70) * PI16 / 360) : 0;
-        }
-        return targets;
+        return limitSupportSpan(targets);
       },
       get inHand() {
         return session?.id ?? null;
@@ -59875,6 +60492,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         particles.dispose();
         ownVfx?.dispose();
         hand.removeFromParent();
+        rocketLight.removeFromParent();
+        rocketLight.dispose();
       }
     };
   }
@@ -59899,6 +60518,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       ...options.attachmentModels ? { attachmentModels: options.attachmentModels } : {},
       ...options.raycast ? { raycast: options.raycast } : {},
       ...options.contact ? { contact: options.contact } : {},
+      ...options.bodyHold ? { bodyHold: options.bodyHold } : {},
       ...options.effects ? { effects: options.effects } : {},
       ...options.flyRocket === void 0 ? {} : { flyRocket: options.flyRocket }
     });
@@ -60674,7 +61294,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var P13_VALVE_MESH = "valve";
   var P13_VALVE_COLOR = 12095802;
   var P13_WALL = 25e-4;
-  var SHAPES2 = {
+  var SHAPES3 = {
     fuel_barrel: { shape: { kind: "cylinder", radius: 0.3, height: 0.9 }, position: [0, 0.45, 0], color: 3104666 },
     propane_p13: {
       shape: { kind: "cylinder", radius: 0.176, height: 0.49 },
@@ -60685,7 +61305,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     },
     car_fuel_tank: { shape: { kind: "box", size: [0.9, 0.25, 0.5] }, position: [0, 0.4, 0], color: 4935509 }
   };
-  var WORLD_EXPLOSIVE_IDS = Object.keys(SHAPES2);
+  var WORLD_EXPLOSIVE_IDS = Object.keys(SHAPES3);
   var SHELL = { thickness: 1e-3, fill: 0.03 };
   var explosivePart = (def, shape, scale) => ({
     id: "tank",
@@ -60731,7 +61351,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     return [centre.x, centre.y, centre.z];
   };
   var worldExplosiveShell = (THREE, defId) => {
-    const shape = SHAPES2[defId];
+    const shape = SHAPES3[defId];
     const model = shape ? modelOf(THREE, shape, 2) : void 0;
     if (!model) return void 0;
     model.traverse((node) => {
@@ -60744,7 +61364,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     return model;
   };
   var worldExplosiveItem = (def, name, options = {}) => {
-    const shape = SHAPES2[def.id];
+    const shape = SHAPES3[def.id];
     if (!shape) return void 0;
     const scale = () => options.scale?.() ?? 1;
     const spec = () => ({ name, parts: [explosivePart(def, shape, scale())], joints: [], tags: ["explosive"] });
@@ -61179,6 +61799,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           raycast: createLaserRaycast(lent.THREE, lent.scene, lent.camera),
           // the weapon against a wall asks as often as the laser, on the clock of the simulation (so a fast-forwarded room measures as often per frame)
           contact: createLaserRaycast(lent.THREE, lent.scene, lent.camera, { now: () => simulatedMs }),
+          ...lent.holdFrame ? { bodyHold: () => lent.holdFrame?.() ?? null } : {},
           ...lent.effects ? { effects: lent.effects } : {},
           ...options.attachmentModels ? { attachmentModels: options.attachmentModels } : {},
           ...options.condition ? { condition: options.condition } : {},
@@ -61991,7 +62612,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         };
         for (const { kind, item } of PUSH_KINDS) PUSH_LAYOUT[kind].forEach(([distance3, degrees]) => lay(kind, item, bearing(centre, distance3, degrees)));
         if (mode === "grenade") {
-          lay("zombie", "zombie_walker", bearing(centre, 3.4, -34));
+          lay("zombie", "zombie_walker", bearing(centre, 3.4, -130));
           lay("survivor", "person_police_officer", bearing(centre, 7.5, 78));
           lay("camp_table", "camp_table", bearing(centre, 3, 90));
         }
@@ -62034,7 +62655,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const outward = ((now[0] - from[0]) * (from[0] - blast.point[0]) + (now[2] - from[2]) * (from[2] - blast.point[2])) / away;
           return { ...body, distance: distance3, outward, moved: flat(now, from) };
         });
-        const torn = (row) => PUSH_KINDS.some((entry2) => entry2.kind === row.kind) && partsOf(row.objectId) < (partsBefore.get(row.objectId) ?? 0);
+        const torn = (row) => (PUSH_KINDS.some((entry2) => entry2.kind === row.kind) || HEAVY_ITEMS.includes(row.kind)) && partsOf(row.objectId) < (partsBefore.get(row.objectId) ?? 0);
         const reached = rows.filter((row) => row.distance < blast.radius * 0.85 && !torn(row));
         const movedAway = reached.filter((row) => row.outward >= MOVED);
         const least = reached.length === 0 ? 0 : Math.min(...reached.map((row) => row.outward));
@@ -62047,9 +62668,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           expect(near.outward > far.outward, fillText2(text.push_falloff, { what: things[kind] ?? kind, near: near.outward.toFixed(2), nearDistance: near.distance.toFixed(1), far: far.outward.toFixed(2), farDistance: far.distance.toFixed(1) }), { near: near.outward, far: far.outward });
         }
         for (const row of reached.filter((entry2) => entry2.kind === "zombie" || entry2.kind === "survivor")) {
-          expect(row.outward >= MOVED, fillText2(text.push_person, { who: things[row.kind] ?? row.kind, distance: row.distance.toFixed(1), moved: row.outward.toFixed(2) }), { row });
+          expect(row.outward >= MOVED, fillText2(text.push_person, { who: things[row.kind] ?? row.kind, distance: row.distance.toFixed(1), moved: row.outward.toFixed(2) }), { row: { kind: row.kind, distance: row.distance, outward: row.outward } });
         }
-        const table = reached.find((row) => HEAVY_ITEMS.includes(row.kind));
+        const table = rows.find((row) => HEAVY_ITEMS.includes(row.kind) && row.distance < blast.radius * 0.85);
         if (table) expect(table.moved >= MOVED, fillText2(text.push_heavy, { what: things[table.itemId] ?? table.itemId, moved: table.moved.toFixed(2) }), { table });
       }
     };