@adatechnology/game-weapons-three 0.14.1 → 0.15.0

package/dist/index.global.js

@@ -32,6 +32,7 @@ var GameWeaponsThree = (() => {
     DEFAULT_THUMBNAIL_BASE: () => DEFAULT_THUMBNAIL_BASE,
     EXPLOSIVES_AREA_ID: () => EXPLOSIVES_AREA_ID,
     EXPLOSIVES_TEXT: () => EXPLOSIVES_TEXT,
+    EXPLOSIVE_MODEL_IDS: () => EXPLOSIVE_MODEL_IDS,
     GAME_DISTANCE_CURVE: () => GAME_DISTANCE_CURVE,
     GAME_SOUND_CLASSES: () => GAME_SOUND_CLASSES,
     GUNSHOT_PROFILES: () => GUNSHOT_PROFILES,
@@ -52,10 +53,12 @@ var GameWeaponsThree = (() => {
     applyCondition: () => applyCondition,
     buildCartridge: () => buildCartridge,
     buildCasing: () => buildCasing,
+    buildExplosiveModel: () => buildExplosiveModel,
     buildItemWeaponModel: () => buildItemWeaponModel,
     buildModeledProp: () => buildModeledProp,
     buildProp: () => buildProp,
     buildRound: () => buildRound,
+    buildThrowableModel: () => buildThrowableModel,
     buildToolClips: () => buildToolClips,
     buildTripodMountedProp: () => buildTripodMountedProp,
     buildWeaponModel: () => buildWeaponModel,
@@ -75,6 +78,8 @@ var GameWeaponsThree = (() => {
     deriveFrames: () => deriveFrames,
     explosivesTextOf: () => explosivesTextOf,
     fitAttachmentModels: () => fitAttachmentModels,
+    hasExplosiveModel: () => hasExplosiveModel,
+    hasThrowableModel: () => hasThrowableModel,
     hasWeaponModel: () => hasWeaponModel,
     itemModelOfWeapon: () => itemModelOfWeapon,
     mechanicalSoundOf: () => mechanicalSoundOf,
@@ -5951,7 +5956,10 @@ var GameWeaponsThree = (() => {
           ]
         }
       ],
-      fitted: []
+      fitted: [],
+      tags: [
+        "pdw"
+      ]
     },
     {
       id: "kriss_vector",
@@ -10410,7 +10418,9 @@ var GameWeaponsThree = (() => {
         "arsenal",
         "reference",
         "derived"
-      ]
+      ],
+      mounts: [],
+      fitted: []
     },
     {
       id: "hk_mp5sd3",
@@ -11169,7 +11179,10 @@ var GameWeaponsThree = (() => {
       fitted: [],
       stock: {
         kind: "retract"
-      }
+      },
+      tags: [
+        "pdw"
+      ]
     },
     {
       id: "hk_g36",
@@ -12870,7 +12883,8 @@ var GameWeaponsThree = (() => {
     dmr: "marksman rifle",
     hunting: "hunting rifle",
     machine_gun: "machine gun",
-    launcher: "launcher"
+    launcher: "launcher",
+    pdw: "PDW (personal defence weapon)"
   };
   var faultsEn = { misfire: "misfire", stovepipe: "stovepipe", double_feed: "double feed", failure_to_extract: "failure to extract" };
   var conditionsEn = { new: "new", used: "used", worn: "worn", rusty: "rusty" };
@@ -12923,7 +12937,27 @@ var GameWeaponsThree = (() => {
         hunting_rifle_30_06: ".30-06 hunting rifle",
         m2_flamethrower: "M2 flamethrower",
         improvised_flamethrower: "Improvised flamethrower",
-        m79: "M79 grenade launcher"
+        m79: "M79 grenade launcher",
+        m203: "M203 grenade launcher",
+        gp_25: "GP-25 grenade launcher",
+        ag36: "AG36 grenade launcher",
+        flashbang: "Flashbang",
+        dynamite: "Dynamite",
+        c4: "C4 charge",
+        claymore: "Claymore mine",
+        tactical_knife: "Tactical knife",
+        meat_cleaver: "Meat cleaver",
+        hatchet: "Hatchet",
+        nail_bat: "Nail bat",
+        iron_pipe: "Iron pipe",
+        pickaxe: "Pickaxe",
+        sickle: "Sickle",
+        police_baton: "Police baton",
+        cast_iron_skillet: "Cast iron skillet",
+        improvised_spear: "Improvised spear",
+        chainsaw: "Chainsaw",
+        recurve_bow: "Recurve bow",
+        m134: "M134 Minigun"
       },
       modes: modesEn,
       categories: categoriesEn,
@@ -12997,7 +13031,27 @@ var GameWeaponsThree = (() => {
         hunting_rifle_30_06: "Rifle de ca\xE7a .30-06",
         m2_flamethrower: "Lan\xE7a-chamas M2",
         improvised_flamethrower: "Lan\xE7a-chamas caseiro",
-        m79: "Lan\xE7a-granadas M79"
+        m79: "Lan\xE7a-granadas M79",
+        m203: "Lan\xE7a-granadas M203",
+        gp_25: "Lan\xE7a-granadas GP-25",
+        ag36: "Lan\xE7a-granadas AG36",
+        flashbang: "granada de luz",
+        dynamite: "dinamite",
+        c4: "C4 com detonador",
+        claymore: "mina Claymore",
+        tactical_knife: "faca t\xE1tica",
+        meat_cleaver: "cutelo",
+        hatchet: "machadinha",
+        nail_bat: "taco com pregos",
+        iron_pipe: "cano de ferro",
+        pickaxe: "picareta",
+        sickle: "foice",
+        police_baton: "cassetete",
+        cast_iron_skillet: "frigideira de ferro",
+        improvised_spear: "lan\xE7a improvisada",
+        chainsaw: "motosserra",
+        recurve_bow: "arco recurvo",
+        m134: "Minigun M134"
       },
       modes: { single: "tiro \xFAnico", semi: "semiautom\xE1tico", burst: "rajada", auto: "autom\xE1tico", pump: "repeti\xE7\xE3o", bolt: "ferrolho", lever: "alavanca", break: "basculante", volley: "salva" },
       categories: {
@@ -13021,7 +13075,8 @@ var GameWeaponsThree = (() => {
         dmr: "fuzil de precis\xE3o semiautom\xE1tico",
         hunting: "arma de ca\xE7a",
         machine_gun: "metralhadora",
-        launcher: "lan\xE7ador"
+        launcher: "lan\xE7ador",
+        pdw: "PDW (arma de defesa pessoal)"
       },
       explosives: {
         m67: "Granada M67",
@@ -13114,7 +13169,13 @@ var GameWeaponsThree = (() => {
     // Arsenal §11: montar e desmontar exige chave de fenda ou bancada; 2/15/30 s e a troca do lança-granadas (0,8 s) são padrões aprovados pelo dono (2026-10-24)
     attachments: { fitSeconds: { field: 2, tool: 15, bench: 30 }, switchSeconds: 0.8, speedOfSound: 343 },
     // Arsenal §08: tempo de mira = 0,15 s + 0,05 s por kg. O quadril do Arsenal é ×6 (o ZombiAdA liga isso por configuração); o SDK é neutro (1)
-    aim: { base: 0.15, perKg: 0.05, hipSpread: 1 },
+    aim: {
+      base: 0.15,
+      perKg: 0.05,
+      hipSpread: 1,
+      // the iron sights close the view in a little: more for a long gun, whose sights sit farther from the eye, than for a handgun
+      ironSightZoom: { pistol: 1.1, revolver: 1.1, smg: 1.2, carbine: 1.25, shotgun: 1.15, rifle: 1.3, hunting: 1.35, dmr: 1.4, sniper: 1.4, machine_gun: 1.2, launcher: 1.15, bow: 1.15, crossbow: 1.25 }
+    },
     // Arsenal §08/§11: coronha retrátil saca mais rápido, mais recuo; os números são padrões aprovados pelo dono (2026-10-24)
     stock: {
       seconds: 0.6,
@@ -14713,6 +14774,26 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     const id = caliber?.propellant === "black_powder" ? "black_powder" : caliber?.propellant === "none" ? "none" : "smokeless";
     return MUZZLE_SMOKE[id];
   }
+  function aimZoomOf(arsenal, weaponId, attachments = arsenal.weapons.get(weaponId)?.fitted?.map((part) => part.id) ?? []) {
+    const def = arsenal.weapons.get(weaponId);
+    if (!def) return 1;
+    const optic = attachments.map((id) => arsenal.attachments.get(id)?.optic).find((entry2) => entry2 !== void 0);
+    if (optic) return optic.zoom[0];
+    return arsenal.rules.aim.ironSightZoom[def.category] ?? 1;
+  }
+  var isGenericKind = (kind, category) => kind === "firearm" && category !== "bow" && category !== "crossbow" || kind === "flame";
+  function genericWeapons(arsenal) {
+    const archetypes = new Set(ARCHETYPE_IDS);
+    const generics = /* @__PURE__ */ new Map();
+    for (const def of arsenal.weapons.values()) if (archetypes.has(def.id) && isGenericKind(def.action.kind, def.category) && !def.maker) generics.set(def.id, void 0);
+    for (const def of [...arsenal.weapons.values()].sort((a, b) => a.id < b.id ? -1 : 1)) {
+      const { archetype } = def;
+      if (!archetype || archetypes.has(def.id) || !generics.has(archetype) || generics.get(archetype)) continue;
+      if (arsenal.weapons.get(archetype)?.action.kind === def.action.kind) generics.set(archetype, def.id);
+    }
+    for (const [id, brand] of generics) if (!brand && arsenal.weapons.get(id)?.action.kind === "flame") generics.delete(id);
+    return generics;
+  }
 
   // ../game-render-three/dist/index.js
   var DEFAULT_ANGLE = Math.PI / 3;
@@ -15964,8 +16045,8 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
         const face = faces[i];
         f3(face[2] + offset, face[1] + offset, face[0] + offset);
       }
-      const layer2 = steps + bevelSegments * 2;
-      offset = vlen * layer2;
+      const layer3 = steps + bevelSegments * 2;
+      offset = vlen * layer3;
       for (let i = 0; i < flen; i++) {
         const face = faces[i];
         f3(face[0] + offset, face[1] + offset, face[2] + offset);
@@ -17392,11 +17473,11 @@ ${problems.map((problem) => `  - ${problem}`).join("\n")}`);
     B.open_suitcases = (M, a) => {
       const K = kit(M, a), cs = [K.main(11549236), 2767450], rs = [13156520, 4876938, 14736592, 11028538];
       const suitcase = (x, z, ww, dd, c, ry, al) => {
-        const lx = x, hz = z - dd / 2;
+        const lx = x, hz2 = z - dd / 2;
         K.box("plain", lx, 0, z, ww, 0.16, dd, c, ry);
         K.box("fabric", lx, 0.12, z, ww - 0.06, 0.05, dd - 0.06, 14209216, ry);
         for (let i = 0; i < 5; i++) K.box("fabric", lx + (K.rnd() - 0.5) * (ww - 0.2), 0.16, z + (K.rnd() - 0.5) * (dd - 0.2), 0.14 + K.rnd() * 0.1, 0.04 + K.rnd() * 0.04, 0.12 + K.rnd() * 0.1, rs[i % 4], K.rnd() * 3);
-        K.ramp("plain", lx, 0.16, hz, ww, 0.07, dd, c, al);
+        K.ramp("plain", lx, 0.16, hz2, ww, 0.07, dd, c, al);
         K.box("metal", lx + ww * 0.3, 0.1, z + dd / 2, 0.04, 0.03, 0.01, 12632256);
       };
       suitcase(-0.4, 0, 0.75, 0.5, cs[0], 0.15, 1.35);
@@ -19582,26 +19663,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 scratch2 = null;
+      let scratch3 = null;
       function probe(e, hinge, setback, blockedAt) {
-        if (!scratch2) scratch2 = GI.createWorld({ locale, strings: hh.strings, items: hh.items, loot: hh.loot, grid: false });
+        if (!scratch3) scratch3 = GI.createWorld({ locale, strings: hh.strings, items: hh.items, loot: hh.loot, grid: false });
         const it = at(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({}, e.item, { hinge }), recorderApi());
-        scratch2.add("__probe", spec, { x, y: e.floorY, z, ry: it.ry });
+        scratch3.add("__probe", spec, { x, y: e.floorY, z, ry: it.ry });
         const blocks = (px, pz) => blockedAt(px, pz, e.floor);
         let sum2 = 0;
         let min2 = 1;
         let n = 0;
         for (const p of spec.parts || []) {
           if (!p.motion || p.motion.kind !== "hinge" || !(p.bounds || p.sweep)) continue;
-          const t = scratch2.fitSweep("__probe", p.id, blocks);
+          const t = scratch3.fitSweep("__probe", p.id, blocks);
           sum2 += t;
           min2 = Math.min(min2, t);
           n++;
         }
-        scratch2.remove("__probe");
+        scratch3.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;
@@ -19926,26 +20007,26 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return { point: [p[0], sign2 * hh, p[2]], normal: [0, sign2, 0] };
   };
   var aabbOf = (s, center, q) => {
-    let hx, hy, hz;
+    let hx, hy, hz2;
     if (s.kind === "sphere") {
-      hx = hy = hz = s.radius;
+      hx = hy = hz2 = s.radius;
     } else {
       const m = quat.toMatrix(q);
       if (s.kind === "box") {
         const a = s.size[0] / 2, b = s.size[1] / 2, c = s.size[2] / 2;
         hx = Math.abs(m[0]) * a + Math.abs(m[1]) * b + Math.abs(m[2]) * c;
         hy = Math.abs(m[3]) * a + Math.abs(m[4]) * b + Math.abs(m[5]) * c;
-        hz = Math.abs(m[6]) * a + Math.abs(m[7]) * b + Math.abs(m[8]) * c;
+        hz2 = Math.abs(m[6]) * a + Math.abs(m[7]) * b + Math.abs(m[8]) * c;
       } else {
         const ax = [m[1], m[4], m[7]];
         const hh = s.height / 2;
         const e = (i) => s.radius * Math.sqrt(Math.max(0, 1 - ax[i] * ax[i])) + hh * Math.abs(ax[i]);
         hx = e(0);
         hy = e(1);
-        hz = e(2);
+        hz2 = e(2);
       }
     }
-    return { min: [center[0] - hx, center[1] - hy, center[2] - hz], max: [center[0] + hx, center[1] + hy, center[2] + hz] };
+    return { min: [center[0] - hx, center[1] - hy, center[2] - hz2], max: [center[0] + hx, center[1] + hy, center[2] + hz2] };
   };
   var createRng2 = (seed) => {
     let s = seed | 0;
@@ -20001,6 +20082,22 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return angle === 0 ? q : quat.mul(q, quat.fromAxisAngle([0, 0, 1], angle));
   };
   var clamp = (v, a, b) => Math.max(a, Math.min(b, v));
+  var splitAlong = (box5, count, axis2, rnd2) => {
+    const shares = Array.from({ length: count }, () => 0.25 + 1.5 * rnd2());
+    const total = shares.reduce((sum2, share) => sum2 + share, 0);
+    const out = [];
+    let from = box5.c[axis2] - box5.s[axis2] / 2;
+    for (const share of shares) {
+      const length2 = box5.s[axis2] * share / total;
+      const c = [box5.c[0], box5.c[1], box5.c[2]];
+      const size = [box5.s[0], box5.s[1], box5.s[2]];
+      c[axis2] = from + length2 / 2;
+      size[axis2] = length2;
+      out.push({ c, s: size });
+      from += length2;
+    }
+    return out;
+  };
   var splinterBox = (inp, box5, limit = inp.maxFragments) => {
     const { rnd: rnd2 } = inp;
     const dims = box5.s;
@@ -20010,35 +20107,81 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const w = Math.max(fmin * 1.5, 0.01);
     const c = clamp(Math.round(dims[a] * dims[b] / (w * w)), 3, Math.max(3, Math.floor(limit / 2)));
     const maxLen = fmax * 4;
-    const cells = bsp(box5, c, [a, b], rnd2);
+    const cells = [];
+    for (const cell of bsp(box5, c, [a, b], rnd2)) {
+      const wide2 = cell.s[a] >= cell.s[b] ? a : b;
+      if (rnd2() < 0.4 && cell.s[wide2] > fmin * 0.5) for (const part of splitAlong(cell, 2, wide2, rnd2)) cells.push(part);
+      else cells.push(cell);
+    }
     const pieces = [];
     for (const cell of cells) {
-      const extra = rnd2() < 0.4 ? 1 : 0;
+      const extra = Math.floor(rnd2() * 3);
       const k = Math.max(1, Math.ceil(dims[g] / maxLen)) + extra;
-      for (const p of bsp(cell, k, [g], rnd2)) pieces.push(p);
+      for (const p of splitAlong(cell, k, g, rnd2)) pieces.push(p);
     }
     return pieces.slice(0, limit).map((p) => ({ center: p.c, size: [p.s[g], p.s[a], p.s[b]], q: frame(g, a, b), shape: "splinter", weight: p.s[0] * p.s[1] * p.s[2] }));
   };
+  var PLY = 3e-3;
+  var PLY_GAP = 0.6;
+  var PLY_SHEET = 0.012;
+  var plyBreak = (inp, root, limit) => {
+    const { rnd: rnd2 } = inp;
+    const dims = root.s;
+    const sorted = [0, 1, 2].sort((x, y) => dims[x] - dims[y]);
+    const t = sorted[0];
+    const [u, v] = [sorted[1], sorted[2]].sort((x, y) => x - y);
+    const along = dims[u] >= dims[v] ? u : v;
+    const across2 = along === u ? v : u;
+    const layers = clamp(Math.round(dims[t] / PLY / 2), 2, 3);
+    const pitch = dims[t] / layers;
+    const th = Math.min(pitch, PLY_SHEET);
+    const per = Math.max(2, Math.floor(limit / layers));
+    const out = [];
+    for (let k = 0; k < layers; k++) {
+      const layer3 = { c: [root.c[0], root.c[1], root.c[2]], s: [dims[0], dims[1], dims[2]] };
+      layer3.c[t] = root.c[t] + (-dims[t] / 2 + (k + 0.5) * pitch) * (pitch > PLY_SHEET ? 1 : 1 + PLY_GAP);
+      layer3.s[t] = th;
+      for (const cell of bsp(layer3, per, [u, v], rnd2)) {
+        if (out.length >= limit) return out;
+        if (rnd2() < 0.35) {
+          const strand = cell.s[across2] * (0.15 + 0.2 * rnd2());
+          out.push({ center: cell.c, size: [cell.s[along], strand, th * 0.7], q: frame(along, across2, t), shape: "splinter", weight: cell.s[along] * strand * th });
+        } else {
+          out.push({ center: cell.c, size: [cell.s[u], cell.s[v], th], q: frame(u, v, t, (rnd2() - 0.5) * 0.5), shape: "scrap", weight: cell.s[u] * cell.s[v] * th });
+        }
+      }
+    }
+    return out;
+  };
+  var granules = (inp, box5, count) => bsp(box5, count, [0, 1, 2], inp.rnd).map((b) => ({ center: b.c, size: b.s, q: quat.identity(), shape: "chunk", weight: b.s[0] * b.s[1] * b.s[2] }));
+  var CRUMBS = 6;
   var severAt = (inp, root, at3, gap) => {
     const dims = root.s;
     const L = [0, 1, 2].sort((x, y) => dims[y] - dims[x])[0];
     const half = dims[L] / 2;
     const lo = clamp(at3 - gap / 2, -half, half), hi = clamp(at3 + gap / 2, -half, half);
     const out = [];
-    const stub = (from, to) => {
+    const fibrous = inp.form === "slivers" || inp.form === "plies";
+    const [a, b] = [0, 1, 2].filter((i) => i !== L);
+    const stub = (from, to, breakAtEnd) => {
       if (to - from < 0.02) return;
       const c = [root.c[0], root.c[1], root.c[2]], sz = [dims[0], dims[1], dims[2]];
       c[L] = (from + to) / 2;
       sz[L] = to - from;
-      out.push({ center: c, size: sz, q: quat.identity(), shape: "slab", weight: sz[0] * sz[1] * sz[2] });
+      const weight = sz[0] * sz[1] * sz[2];
+      if (fibrous) out.push({ center: c, size: [sz[L], sz[a], sz[b]], q: frame(L, a, b, breakAtEnd ? 0 : Math.PI), shape: "slab", weight });
+      else out.push({ center: c, size: sz, q: quat.identity(), shape: "slab", weight });
     };
-    stub(-half, lo);
-    stub(hi, half);
+    stub(-half, lo, true);
+    stub(hi, half, false);
     const band = { c: [root.c[0], root.c[1], root.c[2]], s: [dims[0], dims[1], dims[2]] };
     band.c[L] = (lo + hi) / 2;
     band.s[L] = Math.max(hi - lo, 0.01);
-    if (inp.style === "snap") {
-      for (const b of bsp(band, Math.max(3, Math.min(6, inp.maxFragments - out.length)), [0, 1, 2], inp.rnd)) out.push({ center: b.c, size: b.s, q: quat.identity(), shape: "chunk", weight: b.s[0] * b.s[1] * b.s[2] });
+    const room = inp.maxFragments - out.length;
+    if (inp.style === "snap" && inp.form === "plies") for (const p of plyBreak(inp, band, Math.max(3, room))) out.push(p);
+    else if (inp.style === "snap" && inp.form === "granules") for (const p of granules(inp, band, clamp(room, 3, 12))) out.push(p);
+    else if (inp.style === "snap") {
+      for (const b2 of bsp(band, Math.max(3, Math.min(6, room)), [0, 1, 2], inp.rnd)) out.push({ center: b2.c, size: b2.s, q: quat.identity(), shape: "chunk", weight: b2.s[0] * b2.s[1] * b2.s[2] });
     } else for (const p of splinterBox(inp, band, Math.max(3, inp.maxFragments - out.length))) out.push(p);
     return out;
   };
@@ -20071,8 +20214,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const [u, v] = [sorted[1], sorted[2]].sort((a, b) => a - b);
     if (style === "snap") {
       if (inp.cut) return severAt(inp, root, inp.cut.at, inp.cut.gap);
+      if (inp.form === "plies") return plyBreak(inp, root, maxFragments);
       const n2 = Math.min(maxFragments, 2 + Math.floor(rnd2() * 3));
       for (const b of bsp(root, n2, [0, 1, 2], rnd2)) out.push({ center: b.c, size: b.s, q: idq, shape: "slab", weight: b.s[0] * b.s[1] * b.s[2] });
+      if (inp.form !== "granules") return out;
+      const crumbs = Math.min(CRUMBS, maxFragments - out.length);
+      if (crumbs <= 0) return out;
+      const band = { c: [0, 0, 0], s: [0, 0, 0] };
+      for (let i = 0; i < 3; i++) {
+        band.s[i] = Math.min(dims[i], Math.max(fmin, dims[i] * 0.2));
+        band.c[i] = clamp(inp.hit[i], -dims[i] / 2 + band.s[i] / 2, dims[i] / 2 - band.s[i] / 2);
+      }
+      for (const p of granules(inp, band, crumbs)) out.push({ ...p, weight: p.weight * 0.5 });
       return out;
     }
     if (style === "crumble" || style === "none") {
@@ -20179,13 +20332,95 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     return marks;
   };
+  var JOINT_GAP = 1e-4;
+  var MIN_BEARING_SHARE = 0.25;
+  var unsupportedCells = (cells, thin, dims, standing) => {
+    if (thin === 1) return [];
+    const [u, v] = planeAxes(thin);
+    const bottom = -dims[v] / 2;
+    const rowOf = (y) => Math.round((y - bottom) * 1e4);
+    const rows = /* @__PURE__ */ new Map();
+    for (let i = 0; i < cells.length; i++) {
+      if (!standing(i)) continue;
+      const cell = cells[i];
+      const key2 = rowOf(cell.center[v] - cell.size[v] / 2);
+      const row = rows.get(key2);
+      if (row) row.push(i);
+      else rows.set(key2, [i]);
+    }
+    const held = /* @__PURE__ */ new Set();
+    const queue = [];
+    for (const i of rows.get(0) ?? []) {
+      held.add(i);
+      queue.push(i);
+    }
+    const overlap = (a, b) => Math.min(a.center[u] + a.size[u] / 2, b.center[u] + b.size[u] / 2) - Math.max(a.center[u] - a.size[u] / 2, b.center[u] - b.size[u] / 2);
+    const climb = () => {
+      while (queue.length > 0) {
+        const cell = cells[queue.pop()];
+        for (const j of rows.get(rowOf(cell.center[v] + cell.size[v] / 2)) ?? []) {
+          const other = cells[j];
+          if (held.has(j) || overlap(cell, other) <= Math.max(JOINT_GAP, MIN_BEARING_SHARE * Math.min(cell.size[u], other.size[u]))) continue;
+          held.add(j);
+          queue.push(j);
+        }
+      }
+    };
+    for (const row of rows.values()) row.sort((a, b) => cells[a].center[u] - cells[b].center[u]);
+    const touching = (a, b) => Math.abs(a.center[u] + a.size[u] / 2 - (b.center[u] - b.size[u] / 2)) <= 1e-3;
+    for (let wedged = true; wedged; ) {
+      climb();
+      wedged = false;
+      for (const row of rows.values()) {
+        for (let k = 1; k < row.length - 1; k++) {
+          const i = row[k];
+          if (held.has(i) || !held.has(row[k - 1]) || !held.has(row[k + 1])) continue;
+          if (!touching(cells[row[k - 1]], cells[i]) || !touching(cells[i], cells[row[k + 1]])) continue;
+          held.add(i);
+          queue.push(i);
+          wedged = true;
+        }
+      }
+    }
+    const loose = [];
+    for (const row of rows.values()) for (const i of row) if (!held.has(i)) loose.push(i);
+    return loose;
+  };
+  var clumpCells = (cells, thin, cap) => {
+    if (cells.length <= cap) return [...cells];
+    const [u, v] = planeAxes(thin);
+    let lo0 = Infinity, lo1 = Infinity, hi0 = -Infinity, hi1 = -Infinity;
+    for (const cell of cells) {
+      lo0 = Math.min(lo0, cell.center[u] - cell.size[u] / 2);
+      hi0 = Math.max(hi0, cell.center[u] + cell.size[u] / 2);
+      lo1 = Math.min(lo1, cell.center[v] - cell.size[v] / 2);
+      hi1 = Math.max(hi1, cell.center[v] + cell.size[v] / 2);
+    }
+    let side = Math.sqrt((hi0 - lo0) * (hi1 - lo1) / cap);
+    for (; ; ) {
+      const bins = /* @__PURE__ */ new Map();
+      for (const cell of cells) {
+        const key2 = `${Math.floor((cell.center[u] - lo0) / side)}:${Math.floor((cell.center[v] - lo1) / side)}`;
+        const bin = bins.get(key2) ?? { lo: [Infinity, Infinity, Infinity], hi: [-Infinity, -Infinity, -Infinity] };
+        for (let k = 0; k < 3; k++) {
+          bin.lo[k] = Math.min(bin.lo[k], cell.center[k] - cell.size[k] / 2);
+          bin.hi[k] = Math.max(bin.hi[k], cell.center[k] + cell.size[k] / 2);
+        }
+        bins.set(key2, bin);
+      }
+      if (bins.size <= cap) {
+        return [...bins.values()].map(({ lo, hi }) => ({ center: [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2], size: [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]] }));
+      }
+      side *= 1.25;
+    }
+  };
   var MAX_SPALLS = 64;
   var thinAxisOf = (dims) => dims[0] <= dims[1] && dims[0] <= dims[2] ? 0 : dims[1] <= dims[2] ? 1 : 2;
   var resolveLayer = (def, index, mat) => ({ index, def, mat, energy: mat.penetration * def.thickness * 1e3 });
-  var onFace = (layer2, face) => layer2.def.faces === "both" || layer2.def.faces === (face > 0 ? "+" : "-");
-  var isSpalled = (spalls, layer2, face, point) => {
+  var onFace = (layer3, face) => layer3.def.faces === "both" || layer3.def.faces === (face > 0 ? "+" : "-");
+  var isSpalled = (spalls, layer3, face, point) => {
     for (const s of spalls ?? []) {
-      if (s[0] !== layer2 || s[1] !== face) continue;
+      if (s[0] !== layer3 || s[1] !== face) continue;
       const dx = s[2] - point[0], dy = s[3] - point[1], dz = s[4] - point[2];
       if (dx * dx + dy * dy + dz * dz <= s[5] * s[5]) return true;
     }
@@ -20771,12 +21006,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const [dx, dz] = c.direction;
     const along = (p) => {
       const cx = (p.min[0] + p.max[0]) / 2, cz = (p.min[2] + p.max[2]) / 2;
-      const hx = (p.max[0] - p.min[0]) / 2, hz = (p.max[2] - p.min[2]) / 2;
+      const hx = (p.max[0] - p.min[0]) / 2, hz2 = (p.max[2] - p.min[2]) / 2;
       return {
         u: cx * dx + cz * dz,
         v: -cx * dz + cz * dx,
-        du: 2 * (Math.abs(dx) * hx + Math.abs(dz) * hz),
-        dv: 2 * (Math.abs(dz) * hx + Math.abs(dx) * hz)
+        du: 2 * (Math.abs(dx) * hx + Math.abs(dz) * hz2),
+        dv: 2 * (Math.abs(dz) * hx + Math.abs(dx) * hz2)
       };
     };
     const g = parts.map(along);
@@ -20871,9 +21106,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       for (const b of p.beams ?? []) {
         const q = parts[b];
         if (!q?.elasticPa) continue;
-        const hx = q.max[0] - q.min[0], hz = q.max[2] - q.min[2];
-        const long = Math.max(hx, hz), short = Math.min(hx, hz);
-        const cos2 = hx >= hz ? Math.abs(dx) : Math.abs(dz);
+        const hx = q.max[0] - q.min[0], hz2 = q.max[2] - q.min[2];
+        const long = Math.max(hx, hz2), short = Math.min(hx, hz2);
+        const cos2 = hx >= hz2 ? Math.abs(dx) : Math.abs(dz);
         const depth = q.max[1] - q.min[1];
         const inertia = tBeamInertia(short, depth, short + 2 * c.flange * long, q.slab ?? 0);
         beams += cos2 * cos2 * q.elasticPa * c.beamFactor * inertia / Math.max(long, 1e-6);
@@ -21158,6 +21393,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "wood_soft",
+      splitForm: "slivers",
       density: 500,
       hpPerKg: 90,
       penetration: 9,
@@ -21203,6 +21439,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "wood_hard",
+      splitForm: "slivers",
       density: 750,
       hpPerKg: 140,
       penetration: 14,
@@ -21247,6 +21484,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "plywood",
+      splitForm: "plies",
       density: 600,
       hpPerKg: 70,
       penetration: 7,
@@ -21294,6 +21532,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "mdf",
+      splitForm: "granules",
       density: 750,
       hpPerKg: 45,
       penetration: 6,
@@ -21805,6 +22044,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "green_wood",
+      splitForm: "slivers",
       density: 650,
       hpPerKg: 5,
       penetration: 10,
@@ -22085,6 +22325,125 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         "brittle"
       ],
       compressive: 1e5
+    },
+    {
+      id: "mud",
+      density: 1700,
+      hpPerKg: 1,
+      penetration: 5,
+      ductility: 0.8,
+      fracture: "crumble",
+      fragmentSize: [
+        0.02,
+        0.08
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.5,
+        heatCapacity: 3.2
+      },
+      tags: [
+        "soil",
+        "wet"
+      ],
+      compressive: 5e3
+    },
+    {
+      id: "clay",
+      density: 1800,
+      hpPerKg: 5,
+      penetration: 7,
+      ductility: 0.05,
+      fracture: "crumble",
+      fragmentSize: [
+        0.02,
+        0.1
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.2
+      },
+      tags: [
+        "soil",
+        "brittle"
+      ],
+      compressive: 6e4
+    },
+    {
+      id: "snow",
+      density: 300,
+      hpPerKg: 1,
+      penetration: 3,
+      ductility: 0.6,
+      fracture: "crumble",
+      fragmentSize: [
+        0.01,
+        0.05
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2.1
+      },
+      tags: [
+        "soil",
+        "frozen"
+      ],
+      compressive: 1e3
+    },
+    {
+      id: "cobble",
+      density: 2650,
+      hpPerKg: 25,
+      penetration: 25,
+      penetrationClass: "concrete",
+      penetrationScale: 0.9,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.05,
+        0.15
+      ],
+      hitDebris: "chips",
+      breakDebris: "chips",
+      thermal: {
+        conductivity: 0.2,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 3e5
+    },
+    {
+      id: "paver",
+      density: 2300,
+      hpPerKg: 14,
+      penetration: 18,
+      penetrationClass: "concrete",
+      penetrationScale: 1,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.04,
+        0.12
+      ],
+      hitDebris: "chips",
+      breakDebris: "chips",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 35e4
     }
   ];
   var material_hints_default = {
@@ -22297,6 +22656,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var BREACH_BLAST_FACTOR = 6;
   var BREACH_AREA = 0.25;
   var BREACH_BLAST_REACH = 0.12;
+  var MEMBER_CUT_REACH = 0.5;
+  var BLAST_REFERENCE_RESISTANCE = 200 * 1900 * 0.13;
+  var BLAST_EDGE_RAGGED = 0.3;
+  var BLAST_EDGE_LOOSE = 1.35;
+  var BLAST_EDGE_WEAR = 0.6;
   var RESIDUAL_CAPACITY = 0.15;
   var SEVER_BAND = 0.1;
   var SEVER_ASPECT = 3;
@@ -23549,7 +23913,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (j.st.open) continue;
         if (j.spec.kind === "rebar" && (isReinforced(o.parts[j.ia].spec) || isReinforced(o.parts[j.ib].spec))) continue;
         if (near && jointReach(o, j, near) > Math.max(radius, jointReachLimit(o, j))) continue;
-        j.st.hp -= span === void 0 ? amount : amount * Math.min(1, span / Math.max(jointLength(o, j), 1e-6));
+        j.st.hp -= span === void 0 ? amount : Math.min(amount, j.st.maxHp) * Math.min(1, span / Math.max(jointLength(o, j), 1e-6));
         if (j.st.hp <= 0) {
           j.st.hp = 0;
           j.st.open = true;
@@ -23571,14 +23935,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       var _a;
       if (p.layers.length === 0) return;
       const lp = objLocal(o, wp);
-      const layer2 = outerLayer(p.layers, p.rt.spalls, face, lp);
-      if (!layer2) return;
+      const layer3 = outerLayer(p.layers, p.rt.spalls, face, lp);
+      if (!layer3) return;
       const spalls = (_a = p.rt).spalls ?? (_a.spalls = []);
-      spalls.push([layer2.index, face, lp[0], lp[1], lp[2], radius]);
+      spalls.push([layer3.index, face, lp[0], lp[1], lp[2], radius]);
       if (spalls.length > MAX_SPALLS) spalls.shift();
       markDamaged(p);
-      emit2({ ...base(o, src), type: "spall", part: p.spec.id, layer: layer2.index, point: wp, area: Math.PI * radius * radius });
-      debris2(o, p, layer2.mat.hitDebris, wp, normal, 5, 2, src, layer2.mat.id);
+      emit2({ ...base(o, src), type: "spall", part: p.spec.id, layer: layer3.index, point: wp, area: Math.PI * radius * radius });
+      debris2(o, p, layer3.mat.hitDebris, wp, normal, 5, 2, src, layer3.mat.id);
       setStage(o, p, 1, {}, src);
     };
     const crater = (o, p, wp, normal, radius, src) => {
@@ -23677,6 +24041,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const worn = (_a = p.rt).chips ?? (_a.chips = {});
       const cut = (_b = p.rt).craters ?? (_b.craters = {});
       const out = [];
+      const wholeBefore = Object.values(worn).filter((w) => w === -1).length;
       const shot = kind === "ballistic";
       for (let i = 0; i < grid.length; i++) {
         const cell = grid[i];
@@ -23735,6 +24100,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         emit2({ ...base(o, src), type: "chip", part: p.spec.id, center, size: [cell.size[0], cell.size[1], cell.size[2]], rotation: q, fragments });
         debris2(o, p, p.mat.breakDebris, center, vec.scale(dir ?? [0, 1, 0], -1), 6, 2, src);
       }
+      if (Object.values(worn).filter((w) => w === -1).length > wholeBefore) dropUnsupported(o, p, src);
       if (p.spec.reinforcement) exposeRebar(o, p, src);
       for (const cell of out) addBreach(o, p, toWorld(c, q, cell.center), cell.size[u] * cell.size[v], energy, dir, src);
       if (p.structural && !isLost(p)) {
@@ -23838,10 +24204,122 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       setStage(o, p, 1, {}, src);
       setStage(o, p, 2, { opening: { center: worldCenter, radius }, fragments }, src);
       debris2(o, p, p.mat.breakDebris, worldCenter, vec.scale(dir ?? [0, 1, 0], -1), 14, 3, src);
+      dropUnsupported(o, p, src);
       const reinforcement = p.spec.reinforcement;
       if (reinforcement) exposeRebar(o, p, src);
       if (p.structural) solveStructure(o);
     };
+    const blastReachOf = (p, energy) => {
+      const perKg = p.mat.hits?.blunt?.unitJoules ?? chipEnergy;
+      const resistance = Math.max(1, perKg * p.mat.density * p.thickness);
+      return BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3) * clamp2(Math.cbrt(BLAST_REFERENCE_RESISTANCE / resistance), 0.3, 2);
+    };
+    const blastUnits = (o, p, wp, energy, dist2, src) => {
+      var _a, _b;
+      if (!p.staged || p.st.stripped || isLost(p) || chipEnergy <= 0) return false;
+      const reach = blastReachOf(p, energy);
+      if (dist2 >= reach) return false;
+      const radius = Math.sqrt(reach * reach - dist2 * dist2);
+      const [u, v] = planeAxes(p.thin);
+      const lp = toLocal(p.pos, p.q, objLocal(o, wp));
+      const op = p.st.opening ? toLocal(p.pos, p.q, p.st.opening.center) : null;
+      const grid = gridOf(p);
+      const worn = (_a = p.rt).chips ?? (_a.chips = {});
+      const perKg = p.mat.hits?.blunt?.unitJoules ?? chipEnergy;
+      const lobes = [rnd2() * 2 * Math.PI, rnd2() * 2 * Math.PI];
+      const out = [];
+      for (let i = 0; i < grid.length; i++) {
+        const cell = grid[i];
+        if (worn[i] === -1) continue;
+        if (op && p.st.opening && Math.hypot(cell.center[u] - op[u], cell.center[v] - op[v]) <= p.st.opening.radius) continue;
+        const du = cell.center[u] - lp[u], dv = cell.center[v] - lp[v];
+        const angle = Math.atan2(dv, du);
+        const edge = radius * (1 + BLAST_EDGE_RAGGED * (0.5 * Math.sin(3 * angle + lobes[0]) + 0.3 * Math.sin(5 * angle + lobes[1]) + 0.4 * (rnd2() - 0.5)));
+        const d = Math.hypot(du, dv);
+        if (d <= edge) {
+          worn[i] = -1;
+          out.push(i);
+        } else if (d <= edge * BLAST_EDGE_LOOSE) {
+          const mass = p.mat.density * cell.size[0] * cell.size[1] * cell.size[2];
+          worn[i] = Math.max(worn[i] ?? 0, perKg * mass * BLAST_EDGE_WEAR);
+        }
+      }
+      if (out.length === 0) return false;
+      const loose = unsupportedCells(grid, p.thin, p.dims, (i) => worn[i] !== -1 && !(op && p.st.opening && Math.hypot(grid[i].center[u] - op[u], grid[i].center[v] - op[v]) <= p.st.opening.radius));
+      for (const i of loose) worn[i] = -1;
+      const blown = out.map((i) => grid[i]), fallen = loose.map((i) => grid[i]);
+      const volume = (cells2) => cells2.reduce((sum2, cell) => sum2 + cell.size[0] * cell.size[1] * cell.size[2], 0);
+      const blownMass = Math.min(p.st.mass, p.mat.density * volume(blown));
+      const fallenMass = Math.min(p.st.mass - blownMass, p.mat.density * volume(fallen));
+      const speed = clamp2(Math.sqrt(2 * energy * 0.02 / Math.max(blownMass, 0.05)), 1, 12);
+      const { c, q } = partXf(o, p);
+      const chipped = (_b = p.st).chipped ?? (_b.chipped = []);
+      const tag = `x${chipped.length}_`;
+      const fragments = [
+        ...cellFragments(o, p, clumpCells(blown, p.thin, maxFragments), wp, null, speed, blownMass, tag, true),
+        ...fallen.length > 0 ? cellFragments(o, p, clumpCells(fallen, p.thin, Math.max(2, Math.round(maxFragments / 4))), wp, null, 0.3, fallenMass, `${tag}f`, true) : []
+      ];
+      const cells = [...blown, ...fallen];
+      const holes = localHolesOf(p);
+      p.st.holes = p.st.holes.filter((_, k) => !cells.some((cell) => marksInBox(cell.center, cell.size, void 0, [holes[k]]).length > 0));
+      const lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+      for (const cell of cells) {
+        chipped.push({ center: [cell.center[0], cell.center[1], cell.center[2]], size: [cell.size[0], cell.size[1], cell.size[2]] });
+        for (let k = 0; k < 3; k++) {
+          lo[k] = Math.min(lo[k], cell.center[k] - cell.size[k] / 2);
+          hi[k] = Math.max(hi[k], cell.center[k] + cell.size[k] / 2);
+        }
+      }
+      p.st.mass = Math.max(0, p.st.mass - blownMass - fallenMass);
+      p.rt.removed = (p.rt.removed ?? 0) + blownMass + fallenMass;
+      markDamaged(p);
+      setStage(o, p, 1, {}, src);
+      const center = toWorld(c, q, [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2]);
+      const units = cells.map((cell) => ({ center: toWorld(c, q, cell.center), size: [cell.size[0], cell.size[1], cell.size[2]] }));
+      emit2({ ...base(o, src), type: "chip", part: p.spec.id, center, size: [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]], rotation: q, fragments, units });
+      debris2(o, p, p.mat.breakDebris, center, vec.normalize(vec.sub(center, wp), [0, 1, 0]), 14, 3, src);
+      if (p.spec.reinforcement) exposeRebar(o, p, src);
+      if (p.structural && !isLost(p)) {
+        solveStructure(o);
+        collapseCheck(o, src);
+      }
+      return true;
+    };
+    const dropUnsupported = (o, p, src) => {
+      var _a, _b;
+      if (!p.spec.units || p.spec.units.mortar === p.spec.material || p.st.stripped || isLost(p)) return 0;
+      const [u, v] = planeAxes(p.thin);
+      const grid = gridOf(p);
+      const worn = (_a = p.rt).chips ?? (_a.chips = {});
+      const op = p.st.opening ? toLocal(p.pos, p.q, p.st.opening.center) : null;
+      const opened = (cell) => !!op && !!p.st.opening && Math.hypot(cell.center[u] - op[u], cell.center[v] - op[v]) <= p.st.opening.radius;
+      const loose = unsupportedCells(grid, p.thin, p.dims, (i) => worn[i] !== -1 && !opened(grid[i]));
+      if (loose.length === 0) return 0;
+      for (const i of loose) worn[i] = -1;
+      const fallen = loose.map((i) => grid[i]);
+      const mass = Math.min(p.st.mass, p.mat.density * fallen.reduce((sum2, cell) => sum2 + cell.size[0] * cell.size[1] * cell.size[2], 0));
+      const { c, q } = partXf(o, p);
+      const chipped = (_b = p.st).chipped ?? (_b.chipped = []);
+      const lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+      for (const cell of fallen) {
+        for (let k = 0; k < 3; k++) {
+          lo[k] = Math.min(lo[k], cell.center[k] - cell.size[k] / 2);
+          hi[k] = Math.max(hi[k], cell.center[k] + cell.size[k] / 2);
+        }
+      }
+      const center = toWorld(c, q, [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2]);
+      const fragments = cellFragments(o, p, clumpCells(fallen, p.thin, Math.max(2, Math.round(maxFragments / 4))), vec.add(center, [0, 1, 0]), null, 0.3, mass, `u${chipped.length}_`, true);
+      const holes = localHolesOf(p);
+      p.st.holes = p.st.holes.filter((_, k) => !fallen.some((cell) => marksInBox(cell.center, cell.size, void 0, [holes[k]]).length > 0));
+      for (const cell of fallen) 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);
+      p.rt.removed = (p.rt.removed ?? 0) + mass;
+      markDamaged(p);
+      const units = fallen.map((cell) => ({ center: toWorld(c, q, cell.center), size: [cell.size[0], cell.size[1], cell.size[2]] }));
+      emit2({ ...base(o, src), type: "chip", part: p.spec.id, center, size: [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]], rotation: q, fragments, units });
+      debris2(o, p, p.mat.breakDebris, center, [0, -1, 0], 6, 1, src);
+      return loose.length;
+    };
     const stripPart = (o, p, reinforcement, src) => {
       const bars = rebarBars(p.dims, p.thin, reinforcement.spacing);
       p.st.stripped = true;
@@ -23908,6 +24386,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const unitPlan = p.spec.units ? unitFragmentPlan(p, maxFragments * UNIT_FRAGMENT_FACTOR) : [];
       const axis2 = style === "splinter" || style === "snap" ? severAxis(p) : -1;
       const cutAt2 = axis2 < 0 ? void 0 : p.rt.cutAt ?? (origin ? hitLocal[axis2] : void 0);
+      const planRnd = p.mat.splitForm ? splitStream(o.id, p.spec.id, hitLocal) : rnd2;
       const plan = unitPlan.length > 0 ? unitPlan : planFragments({
         style,
         dims: p.dims,
@@ -23916,8 +24395,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         hit: hitLocal,
         fragmentSize: p.mat.fragmentSize ?? [0.04, 0.2],
         maxFragments,
-        rnd: rnd2,
+        rnd: planRnd,
         sheet: p.mat.sheet,
+        ...p.mat.splitForm ? { form: p.mat.splitForm } : {},
         ...cutAt2 !== void 0 ? { cut: { at: cutAt2, gap: SEVER_BAND } } : {}
       });
       const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
@@ -24056,7 +24536,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const fragments = [];
       for (let i = 0; i < n; i++) {
         const back = !exit || i % 3 === 2;
-        const len = scale * (fibre ? 1.2 + 1.2 * rnd2() : 3 + 4 * rnd2()), w = scale * (0.8 + 0.8 * rnd2()), t = scale * (fibre ? 0.7 + 0.6 * rnd2() : 0.4 + 0.4 * rnd2());
+        const plies = p.mat.splitForm === "plies";
+        const len = scale * (fibre ? 1.2 + 1.2 * rnd2() : 3 + 4 * rnd2()), w = scale * (0.8 + 0.8 * rnd2()), t = scale * (fibre ? 0.7 + 0.6 * rnd2() : plies ? 0.15 + 0.15 * rnd2() : 0.4 + 0.4 * rnd2());
         const size = [w, w, w];
         size[along] = len;
         size[(along + 1) % 3] = w;
@@ -24217,7 +24698,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           checkIgnite(o, p, src);
         }
       }
-      wearJoints(o, p, Ein * 0.5, void 0, 0, src);
+      wearJoints(o, p, Ein * 0.5, void 0, 0, src, false, 2 * BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3));
       const amount = Ein * DMG_PER_J * (mat.damageScale?.explosive ?? 1);
       if (blastFrontSpeed > 0 && dist2 > 0 && mat.tags?.includes("glass")) {
         frontQueue.push({ o, p, due: time + dist2 / blastFrontSpeed, amount, fragEnergy: Ein * 0.3, point, ...src !== void 0 ? { src } : {} });
@@ -24227,7 +24708,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const dealt = applyDamage(o, p, amount, "explosive", point, null, Ein * 0.3, 40, src);
       res.damage += dealt;
       if (p.bend && flexure.enabled) bendByBlast(o, p, point, energy, radius, reach, src);
-      if (dist2 <= BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3)) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
+      const breachReach = BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3);
+      if (p.spec.units && p.spec.units.mortar !== p.spec.material) blastUnits(o, p, wp, energy, dist2, src);
+      else if (p.spec.reinforcement && p.spec.units && dist2 > MEMBER_CUT_REACH * breachReach) blastUnits(o, p, wp, energy, dist2, src);
+      else if (dist2 <= breachReach) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
       return reach;
     };
     const blastProbe = { partsTested: 0, partsNear: 0 };
@@ -24473,6 +24957,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       return h | 0;
     };
+    const splitStream = (objectId, partId, hit) => {
+      const codes = Array.from(`${objectId}|${partId}`, (char) => char.charCodeAt(0) / 1e3);
+      const stream = createRng2(seedOf2(rng2.state() / 1e3, ...codes, hit[0], hit[1], hit[2]));
+      return () => stream.next();
+    };
     const throwFragment = (frag, objectId, from, g, centre, index, src, shields, results, reports, mult) => {
       const v = frag.velocity;
       const speed = Math.hypot(v[0], v[1], v[2]);
@@ -25420,7 +25909,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var defaultSet;
   var defaultAssemblies = () => defaultSet ?? (defaultSet = assembliesOver(ASSEMBLIES));
   var getAssembly = (id) => defaultAssemblies().get(id);
-  var faceCount = (layer2) => layer2.faces === "both" ? 2 : 1;
+  var faceCount = (layer3) => layer3.faces === "both" ? 2 : 1;
   var assemblyDepth = (def) => def.depth ?? def.core.thickness + (def.layers ?? []).reduce((sum2, l) => sum2 + l.thickness * faceCount(l), 0);
   var buildAssemblyPart = (def, assemblyId, options) => {
     if (!def) throw new Error(`unknown assembly "${assemblyId}"`);
@@ -25768,7 +26257,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var DEFAULT_DENSITY = 500;
   var densityOf = (material) => DENSITY[material] ?? DEFAULT_DENSITY;
   var OPEN_ROOM_TYPES = ["balcony", "terrace", "porch"];
+  var WALL_PILLAR_SIDE = 0.2;
+  var HALF = WALL_PILLAR_SIDE / 2;
   var CLOSED_ONLY = [...OPEN_ROOM_TYPES, "void"];
+  var HALF_PILLAR = WALL_PILLAR_SIDE / 2;
   var entry = (itemId, min2, max2, group, pickable, weight) => ({ itemId, min: min2, max: max2, group, pickable, weight });
   var FRIDGE = [
     entry("water_bottle", 1, 3, "water", true, 3),
@@ -26503,6 +26995,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   var LINTEL_DEPTH2 = 0.2;
   var LINTEL_BEARING2 = 0.2;
+  var SILL_BEAM_DEPTH = 0.1;
+  var LINTEL_SPAN_RATIO = 10;
   var MIN_PIECE = 0.05;
   var frameOf = (wall) => {
     const alongU = wall.aabb[2] - wall.aabb[0] >= wall.aabb[3] - wall.aabb[1];
@@ -26516,6 +27010,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const drafts = [];
     const piers = [];
     const lintels = [];
+    const sillBeams = [];
     const spandrels = [];
     const height = wall.y1 - wall.y0;
     let cursor = frame2.from;
@@ -26526,23 +27021,26 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
     own.forEach((opening2, k) => {
       addPier(Math.max(cursor, opening2.from));
-      const lintelTop = Math.min(wall.y1, opening2.y1 + Math.max(LINTEL_DEPTH2, style.lintelDepth?.(opening2.to - opening2.from) ?? 0));
+      const span = opening2.to - opening2.from;
+      const lintelTop = Math.min(wall.y1, opening2.y1 + Math.max(LINTEL_DEPTH2, style.lintelDepth?.(span) ?? 0, (span + LINTEL_BEARING2) / LINTEL_SPAN_RATIO));
       const lintelFrom = Math.max(frame2.from, opening2.from - LINTEL_BEARING2);
       const lintelTo = Math.min(frame2.to, opening2.to + LINTEL_BEARING2);
       const lintelHeight = lintelTop - opening2.y1;
-      if (opening2.y0 - wall.y0 > MIN_PIECE) drafts.push({ id: `${wall.id}_sill_${k}`, role: "partition", material: wall.material, from: opening2.from, to: opening2.to, y0: wall.y0, y1: opening2.y0, volume: (opening2.to - opening2.from) * (opening2.y0 - wall.y0) });
+      const sillTop = style.sillBeam && opening2.y0 - wall.y0 > SILL_BEAM_DEPTH + MIN_PIECE ? opening2.y0 - SILL_BEAM_DEPTH : opening2.y0;
+      if (sillTop - wall.y0 > MIN_PIECE) drafts.push({ id: `${wall.id}_sill_${k}`, role: "partition", material: wall.material, from: opening2.from, to: opening2.to, y0: wall.y0, y1: sillTop, volume: (opening2.to - opening2.from) * (sillTop - wall.y0) });
+      if (sillTop < opening2.y0) sillBeams.push({ id: `${wall.id}_sillbeam_${k}`, role: "beam", material: style.lintelMaterial, from: lintelFrom, to: lintelTo, y0: sillTop, y1: opening2.y0, volume: (lintelTo - lintelFrom) * SILL_BEAM_DEPTH });
       lintels.push({ id: `${wall.id}_lintel_${k}`, role: "beam", material: style.lintelMaterial, from: lintelFrom, to: lintelTo, y0: opening2.y1, y1: lintelTop, volume: (lintelTo - lintelFrom) * lintelHeight });
       spandrels.push(wall.y1 - lintelTop > MIN_PIECE ? { id: `${wall.id}_spandrel_${k}`, role: roleOf2, material: wall.material, from: opening2.from, to: opening2.to, y0: lintelTop, y1: wall.y1, volume: (opening2.to - opening2.from) * (wall.y1 - lintelTop) } : void 0);
       cursor = opening2.to;
     });
     addPier(frame2.to);
     for (const pier of piers) {
-      for (const lintel of lintels) {
+      for (const lintel of [...lintels, ...sillBeams]) {
         const overlap = Math.max(0, Math.min(pier.to, lintel.to) - Math.max(pier.from, lintel.from));
         pier.volume -= overlap * (lintel.y1 - lintel.y0);
       }
     }
-    const all = [...piers, ...drafts, ...lintels, ...spandrels.filter((d) => d !== void 0)];
+    const all = [...piers, ...drafts, ...sillBeams, ...lintels, ...spandrels.filter((d) => d !== void 0)];
     const total = all.reduce((sum2, d) => sum2 + d.volume, 0);
     const pieces = all.map((d) => ({
       id: d.id,
@@ -26557,6 +27055,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ...d.role === "beam" ? style.lintelAssembly ? { assembly: style.lintelAssembly } : {} : wall.assembly ? { assembly: wall.assembly } : {}
     }));
     const internal = [];
+    for (const beam of sillBeams) {
+      const sill = drafts.find((d) => d.id === beam.id.replace("_sillbeam_", "_sill_"));
+      if (sill) internal.push({ part: beam.id, on: sill.id, joint: style.lintelJoint });
+      for (const pier of piers) if (Math.min(pier.to, beam.to) - Math.max(pier.from, beam.from) > 0) internal.push({ part: beam.id, on: pier.id, joint: style.lintelJoint });
+    }
     lintels.forEach((lintel, k) => {
       for (const pier of piers) if (Math.min(pier.to, lintel.to) - Math.max(pier.from, lintel.from) > 0) internal.push({ part: lintel.id, on: pier.id, joint: style.lintelJoint });
       const spandrel = spandrels[k];
@@ -26586,7 +27089,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         ...system.timber ? {} : { lintelAssembly: "reinforced_concrete" },
         lintelJoint: system.joints.beam,
         wallJoint: system.joints.wall,
-        ...lintelDepth && !system.timber ? { lintelDepth } : {}
+        ...lintelDepth && !system.timber ? { lintelDepth } : {},
+        ...construction.system === "masonry" ? { sillBeam: true } : {}
       });
       if (split.pieces.length > 1) splits.set(part.id, split);
     }
@@ -26594,7 +27098,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   function applyPanels(input, structure, detail, lintelDepth) {
     if (detail === "coarse") return input;
-    return applySplits(input, panelSplits(input, structure, lintelDepth));
+    return onJambPillars(applySplits(input, panelSplits(input, structure, lintelDepth)));
+  }
+  var OPENING_BEAM = /_(lintel|sillbeam)_\d+$/;
+  var overlaps2 = (a, b) => a[0] < b[2] && a[2] > b[0] && a[1] < b[3] && a[3] > b[1];
+  function onJambPillars(split) {
+    const pillars = split.parts.filter((part) => part.role === "column" && part.material === "concrete");
+    const extra = [];
+    for (const beam of split.parts) {
+      if (beam.role !== "beam" || !OPENING_BEAM.test(beam.id)) continue;
+      for (const pillar of pillars) if (pillar.floor === beam.floor && overlaps2(pillar.aabb, beam.aabb) && pillar.y0 <= beam.y0 && pillar.y1 >= beam.y1 - 0.01) extra.push({ part: beam.id, on: pillar.id, joint: "rebar" });
+    }
+    return extra.length ? { parts: split.parts, supports: [...split.supports, ...extra] } : split;
   }
   function applyUnits(input, structure) {
     const splits = /* @__PURE__ */ new Map();
@@ -26656,21 +27171,35 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   };
   var MEMBER_CAGE = { spacing: 0.1, diameter: 8e-3, unit: 0.1 };
   var CAGED_ROLES = /* @__PURE__ */ new Set(["beam", "column"]);
+  var CAGE_COVER = 0.03;
+  var CAGE_BUCKLING_SHARE = 0.5;
+  var DEFAULT_RESIDUAL = 0.15;
+  function cageResidualCapacity(size, reinforcement, capacity) {
+    const [a = 0, b = 0] = [...size].sort((x, y) => x - y);
+    const perSide = (w) => Math.max(2, Math.floor(Math.max(0, w - 2 * CAGE_COVER) / reinforcement.spacing) + 1);
+    const bars = 2 * perSide(a) + 2 * perSide(b) - 4;
+    const steel = MATERIALS2.find((m) => m.id === reinforcement.material)?.compressive ?? 0;
+    const carries2 = bars * Math.PI * (reinforcement.diameter / 2) ** 2 * steel * CAGE_BUCKLING_SHARE;
+    if (!capacity || capacity <= 0 || carries2 <= 0) return DEFAULT_RESIDUAL;
+    return Math.min(1, Math.max(DEFAULT_RESIDUAL, carries2 / capacity));
+  }
   var caged = (spec, part, rebar2) => {
     if (!rebar2 || part.material !== "concrete" || !CAGED_ROLES.has(part.role) || spec.reinforcement) return spec;
     const size = spec.shape.kind === "box" ? spec.shape.size : null;
     if (!size) return spec;
     const thin = Math.min(...size);
+    const reinforcement = { material: rebar2, spacing: MEMBER_CAGE.spacing, diameter: MEMBER_CAGE.diameter };
     return {
       ...spec,
-      reinforcement: { material: rebar2, spacing: MEMBER_CAGE.spacing, diameter: MEMBER_CAGE.diameter },
+      reinforcement: part.role === "column" ? { ...reinforcement, residualCapacity: cageResidualCapacity(size, reinforcement, spec.structure?.capacity) } : reinforcement,
       units: { size: [MEMBER_CAGE.unit, MEMBER_CAGE.unit, thin], bond: "stack", mortar: "concrete" }
     };
   };
   var partSpecOf = (part, capacity, detailed, rebar2) => {
     if (detailed && part.assembly) return assemblySpec(part, capacity);
     const spec = boxSpec(part, capacity);
-    return detailed ? caged(spec, part, rebar2) : spec;
+    const out = detailed ? caged(spec, part, rebar2) : spec;
+    return part.beamKind === "ground_beam" ? { ...out, anchored: true, structure: { role: "foundation" } } : out;
   };
   function toDestructibleSpec(structure, options = {}) {
     const { safety = 0.65, redundancy = 0.97, safetyOthers = 0.45 } = options;
@@ -26686,7 +27215,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const walled = applyPanels(slabbed, structure, detail, slabOptions && structure.construction.frame.rebar ? (span) => beamDepthFor(span, slabOptions) : void 0);
     const panels = slabOptions && detail !== "coarse" ? deepenBondBeams(walled, structure, slabOptions) : walled;
     const sizing = { safety, redundancy, safetyOthers };
-    const sized = { ...panels, capacities: options.sized === false ? /* @__PURE__ */ new Map() : sizeCapacities(panels.parts, panels.supports, sizing) };
+    const foundation = new Set(panels.parts.filter((part) => part.beamKind === "ground_beam").map((part) => part.id));
+    const onFoundation = foundation.size ? panels.supports.filter((s) => !foundation.has(s.part)).map((s) => foundation.has(s.on) ? { ...s, on: GROUND } : s) : panels.supports;
+    const sized = { ...panels, capacities: options.sized === false ? /* @__PURE__ */ new Map() : sizeCapacities(panels.parts.filter((part) => !foundation.has(part.id)), onFoundation, sizing) };
     const { parts, supports, capacities } = detail === "units" ? applyUnits(sized, structure) : sized;
     const specs = parts.map((part) => partSpecOf(part, capacities.get(part.id), detail !== "coarse", structure.construction.frame.rebar));
     const margin = options.terrainMargin ?? TERRAIN_MARGIN;
@@ -26751,6 +27282,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     out.parts = out.parts.map((p, i) => i === ground ? raft2 : p);
     return out;
   }
+  var LOW_WINDOW = SILL_BEAM_DEPTH + 0.05;
   var slabId = (g, f) => f === g.floors - 1 && g.roof ? "roof" : `slab_${f}`;
   var storeyBase = (g, f) => f * (g.height + g.slab);
   var slabHalf = (g) => [(g.spanX + g.columnSize + 0.2) / 2, (g.spanZ + g.columnSize + 0.2) / 2];
@@ -26856,13 +27388,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const c = { ...CURTAIN_DEFAULTS, ...options };
     const parts = [...spec.parts];
     const joints = [...spec.joints ?? []];
-    const [hx, hz] = slabHalf(g);
+    const [hx, hz2] = slabHalf(g);
     const h = g.height + g.slab;
     const sides = [
-      { name: "n", along: 0, length: 2 * hx, fixed: hz + c.offset, axis: 2 },
-      { name: "s", along: 0, length: 2 * hx, fixed: -hz - c.offset, axis: 2 },
-      { name: "e", along: 2, length: 2 * hz, fixed: hx + c.offset, axis: 0 },
-      { name: "w", along: 2, length: 2 * hz, fixed: -hx - c.offset, axis: 0 }
+      { name: "n", along: 0, length: 2 * hx, fixed: hz2 + c.offset, axis: 2 },
+      { name: "s", along: 0, length: 2 * hx, fixed: -hz2 - c.offset, axis: 2 },
+      { name: "e", along: 2, length: 2 * hz2, fixed: hx + c.offset, axis: 0 },
+      { name: "w", along: 2, length: 2 * hz2, fixed: -hx - c.offset, axis: 0 }
     ];
     for (let f = 0; f < g.floors; f++) {
       if (c.skip?.(f)) continue;
@@ -26909,7 +27441,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         parts.push({ id, material: c.material, shape: box2(size), position, structure: { role: "partition" }, tags: ["infill"] });
         for (const o of on) rests(joints, id, o, "mortar");
       };
-      const bay = (side, k, along, centre, fixed2, length2, c1, c2) => {
+      const bay = (side, k, along, centre2, fixed2, length2, c1, c2) => {
         const clear = length2 - g.columnSize;
         const win = clear * c.window;
         const pier = (clear - win) / 2;
@@ -26920,11 +27452,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           wall(`infill_${f}_${side}_${k}_${name}`, size(u, h), [p[0], y, p[2]], on);
         };
         const id = (name) => `infill_${f}_${side}_${k}_${name}`;
-        put("sill", clear, sill, yb + sill / 2, centre, [c1, c2]);
-        put("pl", pier, head - sill, yb + sill + (head - sill) / 2, centre - clear / 2 + pier / 2, [c1, id("sill")]);
-        put("pr", pier, head - sill, yb + sill + (head - sill) / 2, centre + clear / 2 - pier / 2, [c2, id("sill")]);
-        put("head", clear, room - head, yb + head + (room - head) / 2, centre, [c1, c2]);
-        const gp = at23(centre);
+        put("sill", clear, sill, yb + sill / 2, centre2, [c1, c2]);
+        put("pl", pier, head - sill, yb + sill + (head - sill) / 2, centre2 - clear / 2 + pier / 2, [c1, id("sill")]);
+        put("pr", pier, head - sill, yb + sill + (head - sill) / 2, centre2 + clear / 2 - pier / 2, [c2, id("sill")]);
+        put("head", clear, room - head, yb + head + (room - head) / 2, centre2, [c1, c2]);
+        const gp = at23(centre2);
         const gid = `glass_${f}_${side}_${k}`;
         parts.push({
           id: gid,
@@ -27391,7 +27923,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   var towerLocales = { en: { labels: en_default.labels }, "pt-BR": { labels: pt_BR_default.labels } };
 
-  // ../game-floorplan-three/dist/chunk-QUVGWVEC.js
+  // ../game-floorplan-three/dist/chunk-7XVCZF6H.js
   var en2 = {
     "prompt.open": "E: open {what}",
     "prompt.close": "E: close {what}",
@@ -28133,6 +28665,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   function installHouseWalls(K, shared2) {
     const { EPS: EPS6, Y0, boxC, bx, cursor, effectiveHeight, pieceRecord, structurePiece, wallColor } = K;
+    const sh = (color2, factor) => K.sh(color2, factor);
     function wallBox(alongU, L, a, b, ya, yb, th, cL, cH, mL, mH) {
       if (yb - ya < 1e-4 || b - a < 1e-4) return;
       if (alongU) {
@@ -28176,6 +28709,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function walls() {
       const R = shared2.ctx.r, cut = shared2.ctx.cut, nA = R.floors.length, vMin = Math.min(...R.walls.map((w) => w.axis === "u" ? w.v0 : Math.min(w.v0, w.v1)));
       const corners = /* @__PURE__ */ new Map();
+      const looks = /* @__PURE__ */ new Map();
       for (const w of R.walls) {
         const f = w.floor;
         cursor.group = "f" + f;
@@ -28185,6 +28719,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const hh = cut ? Math.min(h, 1.2) : h, L = alongU ? w.v0 : w.u0, s0 = Math.min(alongU ? w.u0 : w.v0, alongU ? w.u1 : w.v1), s1 = Math.max(alongU ? w.u0 : w.v0, alongU ? w.u1 : w.v1);
         const front = alongU && Math.abs(L - vMin) < 0.05;
         const sideL = sideOf(w.sides[0], front), sideH = sideOf(w.sides[1], front);
+        if (w.id) {
+          const face = sideL.exterior ? sideL : sideH;
+          looks.set(w.id, { mat: face.mat, color: face.color, top: y0 + hh });
+        }
         shared2.ctx.colliders.push({ type: "wall", piece: w.id, f, x0: alongU ? s0 : L - th / 2, z0: alongU ? L - th / 2 : s0, x1: alongU ? s1 : L + th / 2, z1: alongU ? L + th / 2 : s1 });
         if (w.type === "railing") {
           const c0 = shared2.ctx.colors.metal != null ? shared2.ctx.colors.metal : 9080466;
@@ -28231,8 +28769,27 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         cursor.group = "f" + e.f;
         bx(e.color.mat, e.pu - e.th / 2, e.y0, e.pv - e.th / 2, e.pu + e.th / 2, e.y0 + e.hh, e.pv + e.th / 2, e.color.color);
       }
+      if (shared2.ctx.showPillars) wallPillars(looks);
+    }
+    const PILLAR_IN_WALL = /^(wall_column_|column_\d|jamb_column_)/;
+    const wallOf = (pillar, parts) => {
+      const u = (pillar.aabb[0] + pillar.aabb[2]) / 2, v = (pillar.aabb[1] + pillar.aabb[3]) / 2;
+      return parts.find((q) => (q.role === "wall" || q.role === "partition") && q.assembly !== void 0 && q.floor === pillar.floor && u >= q.aabb[0] - 1e-3 && u <= q.aabb[2] + 1e-3 && v >= q.aabb[1] - 1e-3 && v <= q.aabb[3] + 1e-3);
+    };
+    function wallPillars(looks) {
+      const parts = Object.values(shared2.ctx.structureIndex);
+      for (const e of parts) {
+        if (e.role !== "column" || !PILLAR_IN_WALL.test(e.id)) continue;
+        const host = wallOf(e, parts);
+        const look = host && looks.get(host.id);
+        if (!host || !look) continue;
+        cursor.group = "f" + e.floor;
+        cursor.pc = structurePiece(host.id);
+        bx(look.mat, e.aabb[0], e.y0, e.aabb[1], e.aabb[2], Math.min(e.y1, look.top), e.aabb[3], sh(look.color != null ? look.color : 15262420, 0.93));
+      }
+      cursor.pc = null;
     }
-    Object.assign(K, { wallBox, sideOf, pieceOf, nearestWall, walls });
+    Object.assign(K, { wallBox, sideOf, pieceOf, nearestWall, walls, wallPillars });
   }
   function installHouseDoors(K, shared2) {
     const seedKey = (id) => K.seedKey(id);
@@ -33604,7 +34161,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             if (!pc || pc.unit) return sp;
             if (pc.role !== "wall" && pc.role !== "partition") {
               const def = getAssembly(pc.assembly || (pc.material === "concrete" && ["slab", "beam", "column", "stair"].includes(pc.role) ? "reinforced_concrete" : ""));
-              const out = def && def.reinforcement && !sp.reinforcement ? { ...sp, reinforcement: { ...def.reinforcement } } : sp;
+              const cage = def && def.reinforcement ? pc.role === "column" && sp.shape.kind === "box" ? { ...def.reinforcement, residualCapacity: cageResidualCapacity(sp.shape.size, def.reinforcement, sp.structure?.capacity) } : { ...def.reinforcement } : null;
+              const out = cage && !sp.reinforcement ? { ...sp, reinforcement: cage } : sp;
               if (out.reinforcement && !out.units && pc.material === "concrete" && (pc.role === "beam" || pc.role === "column") && sp.shape.kind === "box") {
                 return { ...out, units: { size: [MEMBER_CAGE.unit, MEMBER_CAGE.unit, Math.min(...sp.shape.size)], bond: "stack", mortar: "concrete" } };
               }
@@ -33630,6 +34188,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const a = pos.array;
     const u = mesh3.userData;
     if (!u._p0) u._p0 = a.slice();
+    if (!u.plainPositions) Object.defineProperty(u, "plainPositions", { value: u._p0, enumerable: false, configurable: true, writable: true });
     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);
@@ -33713,10 +34272,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const v = house.worldToLocal(tmp.p.set(p[0], p[1], p[2]));
         return [v.x, v.y, v.z];
       };
-      function cells(part, units) {
+      function cells(part, units, mask) {
         const [u0, v0, u1, v1] = part.aabb;
-        const alongU = u1 - u0 >= v1 - v0;
+        const alongU = mask.alongU;
         const len = alongU ? u1 - u0 : v1 - v0;
+        const offset = (alongU ? u0 : v0) - mask.start;
         const [ul, uh] = units.size;
         const rows = Math.max(1, Math.round((part.y1 - part.y0) / uh));
         const rowH = (part.y1 - part.y0) / rows;
@@ -33727,7 +34287,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const shift = units.bond === "running" && r & 1 ? w / 2 : 0;
           for (let i = 0; i < per + (shift ? 1 : 0); i++) {
             const a = Math.max(0, i * w - shift), b = Math.min(len, i * w - shift + w);
-            if (b - a > 1e-3) out.push({ a, b, y0: part.y0 + r * rowH, y1: part.y0 + (r + 1) * rowH, r, i });
+            if (b - a > 1e-3) out.push({ a: offset + a, b: offset + b, y0: part.y0 + r * rowH, y1: part.y0 + (r + 1) * rowH, r, i });
           }
         }
         return out;
@@ -33741,8 +34301,21 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const q of structure.parts) {
           if (q.id !== partId && same(q.aabb, part.aabb) && Math.abs(q.y1 - part.y0) < 0.01 && structure.meshesOf(q.id).some((it) => it.mesh)) return q.id;
         }
+        return part.role === "column" ? wallAround(part) : null;
+      }
+      function wallAround(part) {
+        const cu = (part.aabb[0] + part.aabb[2]) / 2, cv = (part.aabb[1] + part.aabb[3]) / 2;
+        for (const q of structure.parts) {
+          if (q.id === part.id || q.role !== "wall" && q.role !== "partition" || !structure.meshesOf(q.id).some((it) => it.mesh)) continue;
+          const inside2 = cu >= q.aabb[0] - 1e-3 && cu <= q.aabb[2] + 1e-3 && cv >= q.aabb[1] - 1e-3 && cv <= q.aabb[3] + 1e-3;
+          if (inside2 && Math.min(q.y1, part.y1) - Math.max(q.y0, part.y0) > 0.5) return q.id;
+        }
         return null;
       }
+      const pillarSpans = (view) => structure.parts.filter((q) => q.role === "column" && wallAround(q) === view.host).map((q) => {
+        const a = (view.mask.alongU ? q.aabb[0] : q.aabb[1]) - view.mask.start, b = (view.mask.alongU ? q.aabb[2] : q.aabb[3]) - view.mask.start;
+        return { a, b, y0: q.y0, y1: q.y1 };
+      });
       const riders = (hostId) => structure.parts.filter((q) => q.id !== hostId && specOf(q.id)?.units && hostOf(q.id) === hostId && !structure.meshesOf(q.id).some((it) => it.mesh)).map((q) => q.id);
       function shell(it, mask) {
         const g0 = it.mesh.geometry, g = new THREE.BufferGeometry();
@@ -33831,6 +34404,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         texture.needsUpdate = true;
         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) };
       }
+      function besidePillars(c, pillars) {
+        let { a, b } = c;
+        for (const k of pillars) {
+          if (c.y1 <= k.y0 || c.y0 >= k.y1 || b <= k.a || a >= k.b) continue;
+          const centre = (a + b) / 2;
+          if (centre > k.a && centre < k.b) return [];
+          if (centre <= k.a) b = Math.min(b, k.a);
+          else a = Math.max(a, k.b);
+        }
+        return b - a > 1e-3 ? [{ ...c, a, b }] : [];
+      }
       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) {
@@ -33853,9 +34437,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const discs = [];
         const flakes = [];
         const shown = [];
+        const pillars = pillarSpans(view);
         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), spalls = view.spalls.get(id);
-          const all = cells(part, units2);
+          const own = cells(part, units2, mask);
+          const all = id === view.host ? own.flatMap((c) => besidePillars(c, pillars)) : own;
+          if (view.fallen.has(id)) {
+            holes.push(...all);
+            continue;
+          }
           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 });
@@ -33951,52 +34541,55 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         return { center: local2(chip.center), along: a, up: u };
       }
+      function newView(hostId) {
+        const items = structure.meshesOf(hostId).filter((it) => it.mesh);
+        if (!items.length) return null;
+        const parts = [hostId, ...riders(hostId)].filter((id) => structure.byId.get(id) && specOf(id)?.units);
+        const mask = maskOf(hostId, parts), core = maskOf(hostId, parts);
+        return {
+          host: hostId,
+          parts,
+          items,
+          mask,
+          core,
+          unitMaterial: unitsMaterial(core),
+          shells: [],
+          saved: null,
+          units: null,
+          gone: 0,
+          pits: 0,
+          bounds: drawnBounds(items),
+          chips: new Map(parts.map((id) => [id, []])),
+          spalls: new Map(parts.map((id) => [id, []])),
+          openings: /* @__PURE__ */ new Map(),
+          flakes: 0,
+          fallen: /* @__PURE__ */ new Set()
+        };
+      }
+      function cut(view) {
+        if (view.saved) return;
+        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) }));
+      }
       function draw2(partId, change) {
         if (lod !== 0) return false;
         const hostId = hostOf(partId);
         if (!hostId || !specOf(partId)?.units) return false;
-        let view = views.get(hostId);
-        if (!view) {
-          const items = structure.meshesOf(hostId).filter((it) => it.mesh);
-          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), core = maskOf(hostId, parts);
-          view = {
-            host: hostId,
-            parts,
-            items,
-            mask,
-            core,
-            unitMaterial: unitsMaterial(core),
-            shells: [],
-            saved: null,
-            units: null,
-            gone: 0,
-            pits: 0,
-            bounds: drawnBounds(items),
-            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;
+        const view = views.get(hostId) ?? newView(hostId);
+        if (!view || !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(chipBox(change.chip, view.mask.alongU));
+        for (const chip of change.chips ?? []) view.chips.get(partId).push(chipBox(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) }));
-        }
+        cut(view);
         views.set(hostId, view);
         if (opts.deferPaint && change.spall) dirty.add(view);
         else {
@@ -34107,14 +34700,32 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
          */
         chip(event) {
           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] } });
+          const rotation2 = event.rotation ?? [0, 0, 0, 1];
+          if (event.units?.length) return draw2(event.part, { chips: event.units.map((unit) => ({ center: unit.center, size: unit.size, rotation: rotation2 })) });
+          return draw2(event.part, { chip: { center: event.center, size: event.size ?? [0, 0, 0], rotation: rotation2 } });
         },
         /** The part broke or fell: its damage goes (the plain range stays collapsed, the renderer hides the part). */
         drop(partId) {
-          const v = views.get(partId);
-          if (!v) return;
+          let host = views.get(partId) ?? [...views.values()].find((view) => view.parts.includes(partId));
+          if (!host && lod === 0 && riders(partId).length > 0) {
+            host = newView(partId);
+            if (host) {
+              cut(host);
+              views.set(partId, host);
+            }
+          }
+          if (!host) return;
+          host.fallen.add(partId);
+          if (host.parts.some((id) => !host.fallen.has(id))) {
+            dirty.delete(host);
+            paint2(host);
+            invalidate();
+            invalidateShadow();
+            return;
+          }
+          const v = host;
           dispose(v);
-          views.delete(partId);
+          views.delete(v.host);
           if (v.saved) dropped.push(v);
         },
         /** LOD 0 draws the cut wall; LOD 1 and 2 give the wall its box back. */
@@ -34589,6 +35200,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       shared2.ctx.noPiece = false;
       cursor.separate = opts.pieces === "meshes";
       cursor.pc = null;
+      shared2.ctx.showPillars = opts.pillars !== "hidden";
       shared2.ctx.apartment = r.template === "apartment_modern";
       shared2.ctx.pa = Math.max(3, Math.min(20, pr.floors != null ? pr.floors : 5));
       shared2.ctx.pf = Math.max(1, Math.min(shared2.ctx.pa, pr.floor != null ? pr.floor : 3));
@@ -36723,11 +37335,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       else return false;
       return true;
     };
-    const zoomOf = (tool2) => {
-      const optic = (tool2.attachments ?? []).map((part) => arsenal.attachments.get(part.id)?.optic).find((entry2) => entry2 !== void 0);
-      return optic?.zoom[0] ?? 1;
+    const zoomOf = (tool2) => aimZoomOf(arsenal, tool2.weapon, tool2.attachments?.map((part) => part.id));
+    const aims = (tool2) => {
+      const kind = arsenal.weapons.get(tool2.weapon)?.action.kind;
+      return kind === "firearm" || kind === "launcher";
     };
-    const isFirearm = (tool2) => arsenal.weapons.get(tool2.weapon)?.action.kind === "firearm";
     const setAim = (on) => {
       if (on === aiming) return;
       aiming = on;
@@ -36745,6 +37357,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       camera2.updateProjectionMatrix();
     };
     const onKeyDown = (event) => {
+      if (host.playerHeld?.()) return;
       if (event.repeat || event.ctrlKey || event.metaKey || event.altKey || TEXT_FIELDS.has(event.target?.tagName ?? "")) return;
       const handled2 = event.code === ACCESSORY_KEYS.light ? act(ACTION_IDS.light) : event.code === ACCESSORY_KEYS.laser ? act(ACTION_IDS.laser) : event.code === ACCESSORY_KEYS.underbarrel ? act(ACTION_IDS.underbarrel) : event.code === ACCESSORY_KEYS.stock && toggleStock();
       if (!handled2) return;
@@ -36753,7 +37366,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
     const isOnRoom = (event) => Boolean(document.pointerLockElement) || event.target instanceof HTMLCanvasElement;
     const onMouseDown = (event) => {
-      if (event.button !== SECONDARY_BUTTON || !isOnRoom(event) || !isFirearm(host.tool())) return;
+      if (event.button !== SECONDARY_BUTTON || !isOnRoom(event) || !aims(host.tool())) return;
       event.preventDefault();
       event.stopImmediatePropagation();
       setAim(true);
@@ -36929,7 +37542,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   };
   var accessoryTextOf = (locale) => ACCESSORY_TEXT[locale] ?? ACCESSORY_TEXT.en;
 
-  // ../game-audio/dist/chunk-KBTUANNG.js
+  // ../game-audio/dist/chunk-C2K7XN2K.js
   var DISTANCE_CURVES = {
     /** The game's `sfx`: `vol / (1 + d² × 0.004)`, cutoff `/ (1 + d × 0.01)`, silent below 0.01 (jogo L62091–62092, L62101). */
     game_sfx: { model: "inverse_square", k: 4e-3, cutoffK: 0.01, minGain: 0.01 },
@@ -37191,12 +37804,46 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     return merged2;
   }
+  var trimmed = (refs, alias) => refs.map((ref) => ({
+    ...ref,
+    ...alias.offset === void 0 ? {} : { offset: alias.offset },
+    ...alias.duration === void 0 ? {} : { duration: alias.duration }
+  }));
+  function aliasSample(alias, file) {
+    const { tiers: _tiers, fallback: _fallback, choke: _choke, ...rest2 } = file;
+    return {
+      ...rest2,
+      id: alias.id,
+      close: trimmed(file.close, alias),
+      ...file.far ? { far: trimmed(file.far, alias) } : {},
+      ...alias.loop === void 0 ? {} : { loop: alias.loop },
+      ...alias.baseFrequency === void 0 ? {} : { baseFrequency: alias.baseFrequency },
+      ...alias.gain === void 0 ? {} : { gain: alias.gain },
+      ...alias.pitch === void 0 ? {} : { pitch: alias.pitch },
+      ...alias.falloff ? { falloff: alias.falloff } : {},
+      fallback: alias.id,
+      sources: [...file.sources, `alias: ${alias.id} \u2192 ${alias.file}`]
+    };
+  }
   function createSoundRegistry(banks = []) {
     const sounds = /* @__PURE__ */ new Map();
     const loops = /* @__PURE__ */ new Map();
     const sets = /* @__PURE__ */ new Map();
     const samples = /* @__PURE__ */ new Map();
     const owners = /* @__PURE__ */ new Map();
+    const aliases = /* @__PURE__ */ new Map();
+    const derived = /* @__PURE__ */ new Map();
+    const resolveAlias = (id) => {
+      const alias = aliases.get(id);
+      if (!alias) return void 0;
+      const cached = derived.get(id);
+      if (cached) return cached;
+      const file = samples.get(alias.file);
+      if (!file) return void 0;
+      const sample = aliasSample(alias, file);
+      derived.set(id, sample);
+      return sample;
+    };
     const registry = {
       register(bank) {
         for (const sound3 of bank.sounds ?? []) {
@@ -37216,6 +37863,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           samples.set(sample.id, sample);
           owners.set(sample.id, bank.id);
         }
+        for (const alias of bank.sampleAliases ?? []) {
+          aliases.set(alias.id, alias);
+          if (!owners.has(alias.id)) owners.set(alias.id, bank.id);
+        }
+        derived.clear();
       },
       patch(id, patch) {
         const sound3 = sounds.get(id);
@@ -37224,22 +37876,31 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (loop) loops.set(id, mergeRecords(loop, patch));
         const sample = samples.get(id);
         if (sample) samples.set(id, mergeRecords(sample, patch));
+        derived.clear();
       },
       remove(id) {
         sounds.delete(id);
         loops.delete(id);
         sets.delete(id);
         samples.delete(id);
+        aliases.delete(id);
         owners.delete(id);
+        derived.clear();
+      },
+      removeSample(id) {
+        samples.delete(id);
+        aliases.delete(id);
+        if (!sounds.has(id) && !loops.has(id) && !sets.has(id)) owners.delete(id);
+        derived.clear();
       },
       sound: (id) => sounds.get(id),
       loop: (id) => loops.get(id),
       set: (id) => sets.get(id),
-      sample: (id) => samples.get(id),
+      sample: (id) => samples.get(id) ?? resolveAlias(id),
       soundIds: () => [...sounds.keys()],
       setIds: () => [...sets.keys()],
       loopIds: () => [...loops.keys()],
-      sampleIds: () => [...samples.keys()],
+      sampleIds: () => [...samples.keys(), ...[...aliases.keys()].filter((id) => !samples.has(id) && resolveAlias(id) !== void 0)],
       bankOf: (id) => owners.get(id)
     };
     for (const bank of banks) registry.register(bank);
@@ -37356,16 +38017,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     return pending;
   }
-  function drawLayer(layer2, scope2) {
+  function drawLayer(layer3, scope2) {
     const pending = { at: 0, gain: 1, filters: [], modulators: [] };
-    for (const key2 of Object.keys(layer2)) {
-      if (key2 === "at" && layer2.at !== void 0) pending.at = draw(layer2.at, scope2);
-      else if (key2 === "duration" && layer2.duration !== void 0) pending.duration = draw(layer2.duration, scope2);
-      else if (key2 === "gain" && layer2.gain !== void 0) pending.gain = draw(layer2.gain, scope2);
-      else if (key2 === "source" && layer2.source.kind === "osc") pending.automation = drawAutomation(layer2.source.frequency, scope2);
-      else if (key2 === "source" && layer2.source.kind === "formant_voice") pending.voice = drawVoice(layer2.source, scope2);
-      else if (key2 === "filters" && layer2.filters) pending.filters = layer2.filters.bank.map((spec) => drawFilter(spec, scope2));
-      else if (key2 === "modulators" && layer2.modulators) pending.modulators = layer2.modulators.map((modulator) => drawModulator(modulator, scope2));
+    for (const key2 of Object.keys(layer3)) {
+      if (key2 === "at" && layer3.at !== void 0) pending.at = draw(layer3.at, scope2);
+      else if (key2 === "duration" && layer3.duration !== void 0) pending.duration = draw(layer3.duration, scope2);
+      else if (key2 === "gain" && layer3.gain !== void 0) pending.gain = draw(layer3.gain, scope2);
+      else if (key2 === "source" && layer3.source.kind === "osc") pending.automation = drawAutomation(layer3.source.frequency, scope2);
+      else if (key2 === "source" && layer3.source.kind === "formant_voice") pending.voice = drawVoice(layer3.source, scope2);
+      else if (key2 === "filters" && layer3.filters) pending.filters = layer3.filters.bank.map((spec) => drawFilter(spec, scope2));
+      else if (key2 === "modulators" && layer3.modulators) pending.modulators = layer3.modulators.map((modulator) => drawModulator(modulator, scope2));
     }
     return pending;
   }
@@ -37376,8 +38037,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     if (source.offset === "fit") return scope2.random() * Math.max(0, noiseSeconds - duration);
     return scope2.random() * (source.offsetScale ?? 1);
   }
-  function finishSource(layer2, pending, duration, offset) {
-    const source = layer2.source;
+  function finishSource(layer3, pending, duration, offset) {
+    const source = layer3.source;
     if (source.kind === "noise") return { kind: "noise", offset, loop: source.loop === true };
     if (source.kind === "osc") return { kind: "osc", wave: source.wave, frequency: finishAutomation(pending.automation ?? {}, duration) };
     const voice2 = pending.voice;
@@ -37399,23 +38060,23 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   function finishEnvelope(envelope2, duration, level) {
     return envelope2.map(([time, value, curve, fixed2]) => ({ time: timeOf(time, duration), value: fixed2 === "fixed" ? value : value * level, curve }));
   }
-  function planLayer(layer2, scope2, defaults, levelInEnvelope, soundLevel) {
-    const pending = drawLayer(layer2, scope2);
+  function planLayer(layer3, scope2, defaults, levelInEnvelope, soundLevel) {
+    const pending = drawLayer(layer3, scope2);
     const duration = pending.duration ?? defaults.duration;
     if (duration === void 0) throw new Error("game-audio: a layer needs a duration (its own or the recipe\u2019s)");
-    const offset = drawOffset(layer2.source, duration, scope2, defaults.noiseSeconds);
+    const offset = drawOffset(layer3.source, duration, scope2, defaults.noiseSeconds);
     const level = pending.gain * soundLevel;
-    const sourceFrequency = layer2.source.kind === "noise" ? 0 : startFrequency(pending.automation ?? pending.voice?.frequency ?? {});
+    const sourceFrequency = layer3.source.kind === "noise" ? 0 : startFrequency(pending.automation ?? pending.voice?.frequency ?? {});
     const planned = {
       at: pending.at,
       duration,
-      tail: layer2.tail ?? defaults.tail ?? DEFAULT_TAIL,
+      tail: layer3.tail ?? defaults.tail ?? DEFAULT_TAIL,
       level,
-      ...layer2.wet === void 0 ? {} : { wet: layer2.wet },
-      source: finishSource(layer2, pending, duration, offset),
-      ...layer2.filters ? {
+      ...layer3.wet === void 0 ? {} : { wet: layer3.wet },
+      source: finishSource(layer3, pending, duration, offset),
+      ...layer3.filters ? {
         filters: {
-          mode: layer2.filters.mode,
+          mode: layer3.filters.mode,
           bank: pending.filters.map(({ spec, frequency, q, gain, level: filterLevel }) => ({
             type: spec.type,
             frequency: finishAutomation(frequency, duration),
@@ -37426,10 +38087,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       } : {},
       modulators: pending.modulators.map((modulator) => finishModulator(modulator, sourceFrequency)),
-      envelope: finishEnvelope(layer2.envelope, duration, levelInEnvelope ? level : 1)
+      envelope: finishEnvelope(layer3.envelope, duration, levelInEnvelope ? level : 1)
     };
-    if (!layer2.repeat) return [planned];
-    return Array.from({ length: layer2.repeat.count }, (_, index) => ({ ...planned, at: planned.at + index * (layer2.repeat?.spacing ?? 0) }));
+    if (!layer3.repeat) return [planned];
+    return Array.from({ length: layer3.repeat.count }, (_, index) => ({ ...planned, at: planned.at + index * (layer3.repeat?.spacing ?? 0) }));
   }
   function scaleAutomation(automation, divisor) {
     const scale = (value) => value === void 0 ? void 0 : value / divisor;
@@ -37437,12 +38098,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     for (const key2 of ["value", "from", "to"]) if (automation[key2] !== void 0) scaled2[key2] = scale(automation[key2]);
     return scaled2;
   }
-  function muffle(layer2, divisor) {
-    if (divisor === 1 || !layer2.filters) return layer2;
-    const bank = layer2.filters.bank.map((filter) => filter.type === "lowpass" ? { ...filter, frequency: scaleAutomation(filter.frequency, divisor) } : filter);
-    return { ...layer2, filters: { ...layer2.filters, bank } };
+  function muffle(layer3, divisor) {
+    if (divisor === 1 || !layer3.filters) return layer3;
+    const bank = layer3.filters.bank.map((filter) => filter.type === "lowpass" ? { ...filter, frequency: scaleAutomation(filter.frequency, divisor) } : filter);
+    return { ...layer3, filters: { ...layer3.filters, bank } };
   }
-  var layerEnd = (layer2) => layer2.at + layer2.duration + layer2.tail;
+  var layerEnd = (layer3) => layer3.at + layer3.duration + layer3.tail;
   function planSound(recipe2, input = {}) {
     const listener = input.listener ?? DEFAULT_LISTENER;
     const distance3 = input.distance ?? (input.position ? listenerDistance(listener, input.position, input.distanceMode) : 0);
@@ -37470,7 +38131,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       noiseSeconds: input.noiseSeconds ?? DEFAULT_NOISE_SECONDS
     };
     const divisor = cutoffDivisor(recipe2.falloff, distance3) / (1 - OCCLUSION_CUTOFF * occlusion);
-    const layers = recipe2.layers.flatMap((layer2) => planLayer(layer2, scope2, defaults, order !== "layered", level)).map((layer2) => muffle(layer2, divisor));
+    const layers = recipe2.layers.flatMap((layer3) => planLayer(layer3, scope2, defaults, order !== "layered", level)).map((layer3) => muffle(layer3, divisor));
     return { ...base, silent: false, length: Math.max(0, ...layers.map(layerEnd)), layers };
   }
   function fillNoise(random, length2) {
@@ -37856,7 +38517,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const index = pickTake(refs.length, input.memory?.get(key2), input.random);
       input.memory?.set(key2, index);
       const ref = refs[index];
-      layers.push({ role, url: ref.url, take: index, gain: gain * (ref.gain ?? 1) * level, rate, at: at3 });
+      layers.push({
+        role,
+        url: ref.url,
+        take: index,
+        gain: gain * (ref.gain ?? 1) * level,
+        rate,
+        at: at3,
+        ...ref.offset === void 0 ? {} : { offset: ref.offset },
+        ...ref.duration === void 0 ? {} : { duration: ref.duration }
+      });
     };
     take("close", close, gains.close, 0);
     take("far", far, gains.far, 0);
@@ -37883,6 +38553,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var DEFAULT_LOOP_CROSSFADE = 0.25;
   var LOOKAHEAD = 1.5;
   var VOLUME_SMOOTHING = 0.05;
+  var RATE_SMOOTHING = 0.04;
+  var RATE_RANGE = [0.25, 4];
   function loopCrossfade(sound3) {
     if (!sound3.loop) return void 0;
     return sound3.loop === true ? DEFAULT_LOOP_CROSSFADE : Math.max(0, sound3.loop.crossfade ?? DEFAULT_LOOP_CROSSFADE);
@@ -37894,6 +38566,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     param2.setValueAtTime(value(0), at3);
     for (let step = 1; step <= CROSSFADE_STEPS; step++) param2.linearRampToValueAtTime(value(step / CROSSFADE_STEPS), at3 + seconds * step / CROSSFADE_STEPS);
   };
+  var loopRate = (sound3, frequency) => sound3.baseFrequency && sound3.baseFrequency > 0 && frequency > 0 ? Math.max(RATE_RANGE[0], Math.min(RATE_RANGE[1], frequency / sound3.baseFrequency)) : 1;
   function createSampleLoopHandle(sound3, host, volume = 0) {
     const crossfade = loopCrossfade(sound3) ?? DEFAULT_LOOP_CROSSFADE;
     let level = volume;
@@ -37903,13 +38576,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     let segments = [];
     let last;
     let timer;
+    let panner;
+    let rate = 1;
+    let position;
     const entry2 = {
       get created() {
         return master !== void 0;
       },
       rewire() {
-        master?.disconnect();
-        master?.connect(host.output(sound3.bus));
+        const out = panner ?? master;
+        out?.disconnect();
+        out?.connect(host.output(sound3.bus));
       },
       stop() {
         stopped = true;
@@ -37926,23 +38603,29 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         segments = [];
         master?.disconnect();
         master = void 0;
+        panner?.disconnect();
+        panner = void 0;
         fallback2?.stop();
         fallback2 = void 0;
         host.unregister(entry2);
       }
     };
-    const nextBuffer = () => {
+    const nextTake = () => {
       const takes2 = sound3.close;
       const take = pickTake(takes2.length, last, host.random);
       last = take;
       const ref = takes2[take];
-      return ref ? host.buffer(ref.url) : void 0;
+      const buffer = ref ? host.buffer(ref.url) : void 0;
+      return ref && buffer ? { buffer, ref } : void 0;
     };
     const schedule = (context, output, at3, first) => {
-      const buffer = nextBuffer();
-      if (!buffer) return void 0;
+      const next = nextTake();
+      if (!next) return void 0;
+      const { buffer, ref } = next;
+      const offset = Math.max(0, Math.min(ref.offset ?? 0, buffer.duration));
       const source = context.createBufferSource();
       source.buffer = buffer;
+      source.playbackRate.value = rate;
       const gain = context.createGain();
       source.connect(gain);
       gain.connect(output);
@@ -37950,15 +38633,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (buffer.duration < 2 * crossfade || sound3.close.length === 1) {
         source.loop = true;
         if (!first) ramp2(gain.gain, "in", at3, Math.max(1e-3, fade));
-        source.start(at3);
+        source.start(at3, offset);
         segments.push({ source, gain, end: Number.POSITIVE_INFINITY });
         return void 0;
       }
       if (first) gain.gain.setValueAtTime(1, at3);
       else ramp2(gain.gain, "in", at3, fade);
-      const end3 = at3 + buffer.duration;
+      const end3 = at3 + (buffer.duration - offset) / rate;
       ramp2(gain.gain, "out", end3 - fade, fade);
-      source.start(at3);
+      source.start(at3, offset);
       source.stop(end3);
       segments.push({ source, gain, end: end3 });
       source.onended = () => {
@@ -37979,14 +38662,26 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         pump(context, output, next, false);
       }, wait);
     };
-    const fileLevel = () => level * (sound3.gain ?? 1);
+    const spatial = () => {
+      if (!position || !host.listener) return 1;
+      return falloffGain(sound3.falloff ?? DEFAULT_SAMPLE_FALLOFF, 1, listenerDistance(host.listener(), position, host.distance));
+    };
+    const fileLevel = () => level * (sound3.gain ?? 1) * spatial();
+    const place = (context) => {
+      if (panner && position && host.listener) panner.pan.setTargetAtTime(panFor(host.listener(), position), context.currentTime, VOLUME_SMOOTHING);
+    };
     const startFiles = () => {
       if (stopped || master || !host.isReady(sound3)) return master !== void 0;
       const context = host.ready();
       if (!context) return false;
       master = context.createGain();
       master.gain.setValueAtTime(fileLevel(), context.currentTime);
-      master.connect(host.output(sound3.bus));
+      if (sound3.pan !== false && position && typeof context.createStereoPanner === "function") {
+        panner = context.createStereoPanner();
+        if (host.listener) panner.pan.value = panFor(host.listener(), position);
+        master.connect(panner);
+        panner.connect(host.output(sound3.bus));
+      } else master.connect(host.output(sound3.bus));
       host.register(entry2);
       pump(context, master, context.currentTime, true);
       if (fallback2) {
@@ -38012,9 +38707,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       set(next) {
         if (stopped) return;
         if (next.volume !== void 0) level = host.muted(sound3.bus) ? 0 : Math.max(0, next.volume);
+        if (next.position) position = next.position;
+        if (next.frequency !== void 0 && sound3.baseFrequency) rate = loopRate(sound3, next.frequency);
         if (level > 0) ensure();
         const context = host.ready();
-        if (master && context) master.gain.setTargetAtTime(fileLevel(), context.currentTime, VOLUME_SMOOTHING);
+        if (master && context) {
+          master.gain.setTargetAtTime(fileLevel(), context.currentTime, VOLUME_SMOOTHING);
+          place(context);
+          if (next.frequency !== void 0 && sound3.baseFrequency) for (const segment of segments) segment.source.playbackRate.setTargetAtTime(rate, context.currentTime, RATE_SMOOTHING);
+        }
         fallback2?.set(next.volume === void 0 ? next : { ...next, volume: level });
       },
       stop: entry2.stop
@@ -38117,9 +38818,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
     return queue;
   }
-  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;
+  var end = (layer3, start) => start + layer3.duration + layer3.tail;
+  var firstFilter = (layer3) => layer3.filters?.bank[0];
+  var offsetOf = (layer3) => layer3.source.kind === "noise" ? layer3.source.offset : 0;
   function setFilter(node, filter, time) {
     if (!filter) return;
     node.type = filter.type;
@@ -38128,28 +38829,28 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   function realizeBurst(plan, target) {
     const { context } = target;
-    const layer2 = plan.layers[0];
-    const time = target.time + layer2.at;
+    const layer3 = plan.layers[0];
+    const time = target.time + layer3.at;
     const gain = context.createGain();
     gain.connect(target.output);
-    const source = noiseSource(target, layer2.source.kind === "noise" && layer2.source.loop);
+    const source = noiseSource(target, layer3.source.kind === "noise" && layer3.source.loop);
     const filter = context.createBiquadFilter();
     source.connect(filter);
     filter.connect(gain);
-    setFilter(filter, firstFilter(layer2), time);
-    applyEnvelope(gain.gain, layer2.envelope, time);
-    source.start(time, offsetOf(layer2));
-    source.stop(end(layer2, time));
+    setFilter(filter, firstFilter(layer3), time);
+    applyEnvelope(gain.gain, layer3.envelope, time);
+    source.start(time, offsetOf(layer3));
+    source.stop(end(layer3, time));
     return voiceOf([source]);
   }
   function realizeScream(plan, target) {
     const { context } = target;
-    const layer2 = plan.layers[0];
-    const time = target.time + layer2.at;
-    const source = noiseSource(target, layer2.source.kind === "noise" && layer2.source.loop);
+    const layer3 = plan.layers[0];
+    const time = target.time + layer3.at;
+    const source = noiseSource(target, layer3.source.kind === "noise" && layer3.source.loop);
     const gain = context.createGain();
     gain.connect(target.output);
-    for (const band of layer2.filters?.bank ?? []) {
+    for (const band of layer3.filters?.bank ?? []) {
       const filter = context.createBiquadFilter();
       filter.type = band.type;
       if (band.q !== void 0) filter.Q.value = band.q;
@@ -38162,7 +38863,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       level.connect(gain);
     }
     const sources = [source];
-    const lfos = layer2.modulators.map((modulator) => {
+    const lfos = layer3.modulators.map((modulator) => {
       const lfo = context.createOscillator();
       const depth = context.createGain();
       if (modulator.wave) lfo.type = modulator.wave;
@@ -38172,75 +38873,75 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       depth.connect(gain.gain);
       return lfo;
     });
-    applyEnvelope(gain.gain, layer2.envelope, time);
-    source.start(time, offsetOf(layer2));
-    source.stop(end(layer2, time));
+    applyEnvelope(gain.gain, layer3.envelope, time);
+    source.start(time, offsetOf(layer3));
+    source.stop(end(layer3, time));
     for (const lfo of lfos) {
       lfo.start(time);
-      lfo.stop(end(layer2, time));
+      lfo.stop(end(layer3, time));
       sources.push(lfo);
     }
     return voiceOf(sources);
   }
   function realizeGroan(plan, target) {
     const { context } = target;
-    const layer2 = plan.layers[0];
-    const time = target.time + layer2.at;
+    const layer3 = plan.layers[0];
+    const time = target.time + layer3.at;
     const oscillator = context.createOscillator();
     const gain = context.createGain();
     const filter = context.createBiquadFilter();
-    const band = firstFilter(layer2);
-    if (layer2.source.kind === "osc") oscillator.type = layer2.source.wave;
+    const band = firstFilter(layer3);
+    if (layer3.source.kind === "osc") oscillator.type = layer3.source.wave;
     if (band) {
       filter.type = band.type;
       if (band.q !== void 0) filter.Q.value = band.q;
     }
-    if (layer2.source.kind === "osc") {
-      assign(oscillator.frequency, layer2.source.frequency, time);
-      rampTo(oscillator.frequency, layer2.source.frequency, time);
+    if (layer3.source.kind === "osc") {
+      assign(oscillator.frequency, layer3.source.frequency, time);
+      rampTo(oscillator.frequency, layer3.source.frequency, time);
     }
     if (band) assign(filter.frequency, band.frequency, time);
-    applyEnvelope(gain.gain, layer2.envelope, time);
+    applyEnvelope(gain.gain, layer3.envelope, time);
     oscillator.connect(filter);
     filter.connect(gain);
     gain.connect(target.output);
     oscillator.start(time);
-    oscillator.stop(end(layer2, time));
+    oscillator.stop(end(layer3, time));
     return voiceOf([oscillator]);
   }
   function realizeBoom(plan, target) {
     const { context } = target;
-    const layer2 = plan.layers[0];
-    const time = target.time + layer2.at;
+    const layer3 = plan.layers[0];
+    const time = target.time + layer3.at;
     const oscillator = context.createOscillator();
     const gain = context.createGain();
-    if (layer2.source.kind === "osc") {
-      oscillator.type = layer2.source.wave;
-      assign(oscillator.frequency, layer2.source.frequency, time);
-      rampTo(oscillator.frequency, layer2.source.frequency, time);
+    if (layer3.source.kind === "osc") {
+      oscillator.type = layer3.source.wave;
+      assign(oscillator.frequency, layer3.source.frequency, time);
+      rampTo(oscillator.frequency, layer3.source.frequency, time);
     }
-    applyEnvelope(gain.gain, layer2.envelope, time);
+    applyEnvelope(gain.gain, layer3.envelope, time);
     oscillator.connect(gain);
     gain.connect(target.output);
     oscillator.start(time);
-    oscillator.stop(end(layer2, time));
+    oscillator.stop(end(layer3, time));
     return voiceOf([oscillator]);
   }
   function realizeStatic(plan, target) {
     const { context } = target;
-    const layer2 = plan.layers[0];
-    const time = target.time + layer2.at;
+    const layer3 = plan.layers[0];
+    const time = target.time + layer3.at;
     const gain = context.createGain();
     const source = context.createBufferSource();
     const filter = context.createBiquadFilter();
     source.buffer = target.noise();
-    setFilter(filter, firstFilter(layer2), time);
-    applyEnvelope(gain.gain, layer2.envelope, time);
+    setFilter(filter, firstFilter(layer3), time);
+    applyEnvelope(gain.gain, layer3.envelope, time);
     source.connect(filter);
     filter.connect(gain);
     gain.connect(target.output);
-    source.start(time, offsetOf(layer2));
-    source.stop(end(layer2, time));
+    source.start(time, offsetOf(layer3));
+    source.stop(end(layer3, time));
     return voiceOf([source]);
   }
   function realizeChord(plan, target) {
@@ -38252,14 +38953,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const source = layers[index].source;
       if (source.kind === "osc") oscillators[index].type = source.wave;
     }
-    layers.forEach((layer2, index) => {
-      if (layer2.source.kind === "osc") assign(oscillators[index].frequency, layer2.source.frequency, target.time + layer2.at);
+    layers.forEach((layer3, index) => {
+      if (layer3.source.kind === "osc") assign(oscillators[index].frequency, layer3.source.frequency, target.time + layer3.at);
     });
     applyEnvelope(gain.gain, layers[0].envelope, target.time + layers[0].at);
     for (const oscillator of oscillators) oscillator.connect(gain);
     gain.connect(target.output);
-    layers.forEach((layer2, index) => oscillators[index].start(target.time + layer2.at));
-    layers.forEach((layer2, index) => oscillators[index].stop(end(layer2, target.time + layer2.at)));
+    layers.forEach((layer3, index) => oscillators[index].start(target.time + layer3.at));
+    layers.forEach((layer3, index) => oscillators[index].stop(end(layer3, target.time + layer3.at)));
     return voiceOf(oscillators);
   }
   function realizeCalls(plan, target) {
@@ -38271,32 +38972,32 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     if (band) filter.type = band.type;
     filter.connect(gain);
     gain.connect(target.output);
-    const oscillators = plan.layers.map((layer2) => {
-      const time = target.time + layer2.at;
+    const oscillators = plan.layers.map((layer3) => {
+      const time = target.time + layer3.at;
       const oscillator = context.createOscillator();
-      if (layer2.source.kind === "osc") {
-        oscillator.type = layer2.source.wave;
-        assign(oscillator.frequency, layer2.source.frequency, time);
-        rampTo(oscillator.frequency, layer2.source.frequency, time);
+      if (layer3.source.kind === "osc") {
+        oscillator.type = layer3.source.wave;
+        assign(oscillator.frequency, layer3.source.frequency, time);
+        rampTo(oscillator.frequency, layer3.source.frequency, time);
       }
       if (band) {
         assign(filter.frequency, band.frequency, time);
         if (band.q !== void 0) filter.Q.value = band.q;
       }
       const envelope2 = context.createGain();
-      applyEnvelope(envelope2.gain, layer2.envelope, time);
+      applyEnvelope(envelope2.gain, layer3.envelope, time);
       oscillator.connect(envelope2);
       envelope2.connect(filter);
       oscillator.start(time);
-      oscillator.stop(end(layer2, time));
+      oscillator.stop(end(layer3, time));
       return oscillator;
     });
     return voiceOf(oscillators);
   }
-  var end2 = (layer2, start) => start + layer2.duration + layer2.tail;
-  function outputStage2(plan, layer2, target) {
+  var end2 = (layer3, start) => start + layer3.duration + layer3.tail;
+  function outputStage2(plan, layer3, target) {
     const { context } = target;
-    const level = gainNode(context, layer2.level);
+    const level = gainNode(context, layer3.level);
     let node = level;
     if (plan.pan !== void 0 && typeof context.createStereoPanner === "function") {
       const panner = context.createStereoPanner();
@@ -38305,54 +39006,54 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       node = panner;
     }
     node.connect(target.output);
-    if (layer2.wet && target.wet) {
-      const send = gainNode(context, layer2.wet);
+    if (layer3.wet && target.wet) {
+      const send = gainNode(context, layer3.wet);
       node.connect(send);
       send.connect(target.wet);
     }
     return level;
   }
-  function realizeNoiseLayer(plan, layer2, target) {
+  function realizeNoiseLayer(plan, layer3, target) {
     const { context } = target;
-    const time = target.time + layer2.at;
-    const source = noiseSource(target, layer2.source.kind === "noise" && layer2.source.loop);
-    const filters = (layer2.filters?.bank ?? []).map((filter) => {
+    const time = target.time + layer3.at;
+    const source = noiseSource(target, layer3.source.kind === "noise" && layer3.source.loop);
+    const filters = (layer3.filters?.bank ?? []).map((filter) => {
       const node = filterNode(context, filter, time);
       rampTo(node.frequency, filter.frequency, time);
       return node;
     });
     const envelope2 = context.createGain();
-    applyEnvelope(envelope2.gain, layer2.envelope, time);
+    applyEnvelope(envelope2.gain, layer3.envelope, time);
     let tail = source;
     for (const filter of filters) tail = tail.connect(filter);
     tail.connect(envelope2);
-    envelope2.connect(outputStage2(plan, layer2, target));
-    source.start(time, layer2.source.kind === "noise" ? layer2.source.offset : 0);
-    source.stop(end2(layer2, time));
+    envelope2.connect(outputStage2(plan, layer3, target));
+    source.start(time, layer3.source.kind === "noise" ? layer3.source.offset : 0);
+    source.stop(end2(layer3, time));
     return [source];
   }
-  function realizeToneLayer(plan, layer2, target) {
+  function realizeToneLayer(plan, layer3, target) {
     const { context } = target;
-    const time = target.time + layer2.at;
+    const time = target.time + layer3.at;
     const oscillator = context.createOscillator();
-    if (layer2.source.kind === "osc") {
-      oscillator.type = layer2.source.wave;
-      assign(oscillator.frequency, layer2.source.frequency, time);
-      rampTo(oscillator.frequency, layer2.source.frequency, time);
+    if (layer3.source.kind === "osc") {
+      oscillator.type = layer3.source.wave;
+      assign(oscillator.frequency, layer3.source.frequency, time);
+      rampTo(oscillator.frequency, layer3.source.frequency, time);
     }
     const envelope2 = context.createGain();
-    applyEnvelope(envelope2.gain, layer2.envelope, time);
+    applyEnvelope(envelope2.gain, layer3.envelope, time);
     oscillator.connect(envelope2);
-    envelope2.connect(outputStage2(plan, layer2, target));
+    envelope2.connect(outputStage2(plan, layer3, target));
     oscillator.start(time);
-    oscillator.stop(end2(layer2, time));
+    oscillator.stop(end2(layer3, time));
     return [oscillator];
   }
-  function realizeVoiceLayer(plan, layer2, target) {
-    const source = layer2.source;
+  function realizeVoiceLayer(plan, layer3, target) {
+    const source = layer3.source;
     if (source.kind !== "formant_voice") return [];
     const { context } = target;
-    const time = target.time + layer2.at;
+    const time = target.time + layer3.at;
     const oscillator = context.createOscillator();
     oscillator.type = source.wave;
     assign(oscillator.frequency, source.frequency, time);
@@ -38373,10 +39074,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     for (const formant of formants) formant.connect(mix3);
     breathLevel.connect(mix3);
     const envelope2 = context.createGain();
-    applyEnvelope(envelope2.gain, layer2.envelope, time);
+    applyEnvelope(envelope2.gain, layer3.envelope, time);
     mix3.connect(envelope2);
-    envelope2.connect(outputStage2(plan, layer2, target));
-    const stop = end2(layer2, time);
+    envelope2.connect(outputStage2(plan, layer3, target));
+    const stop = end2(layer3, time);
     oscillator.start(time);
     vibrato.start(time);
     breath.start(time, source.breath.offset);
@@ -38386,24 +39087,24 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return [oscillator, vibrato, breath];
   }
   function realizeLayered(plan, target) {
-    const sources = plan.layers.flatMap((layer2) => {
-      if (layer2.source.kind === "noise") return realizeNoiseLayer(plan, layer2, target);
-      if (layer2.source.kind === "osc") return realizeToneLayer(plan, layer2, target);
-      return realizeVoiceLayer(plan, layer2, target);
+    const sources = plan.layers.flatMap((layer3) => {
+      if (layer3.source.kind === "noise") return realizeNoiseLayer(plan, layer3, target);
+      if (layer3.source.kind === "osc") return realizeToneLayer(plan, layer3, target);
+      return realizeVoiceLayer(plan, layer3, target);
     });
     return voiceOf(sources);
   }
   function realizeSiren(plan, target) {
     const { context } = target;
-    const layer2 = plan.layers[0];
-    const time = target.time + layer2.at;
+    const layer3 = plan.layers[0];
+    const time = target.time + layer3.at;
     const oscillator = context.createOscillator();
-    if (layer2.source.kind === "osc") {
-      oscillator.type = layer2.source.wave;
-      assign(oscillator.frequency, layer2.source.frequency, time);
-      rampTo(oscillator.frequency, layer2.source.frequency, time);
+    if (layer3.source.kind === "osc") {
+      oscillator.type = layer3.source.wave;
+      assign(oscillator.frequency, layer3.source.frequency, time);
+      rampTo(oscillator.frequency, layer3.source.frequency, time);
     }
-    const depths = layer2.modulators.map((modulator) => {
+    const depths = layer3.modulators.map((modulator) => {
       const lfo = context.createOscillator();
       if (modulator.wave) lfo.type = modulator.wave;
       lfo.frequency.value = modulator.rate;
@@ -38414,57 +39115,57 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     });
     const lfos = depths.map(({ lfo }) => lfo);
     const envelope2 = context.createGain();
-    applyEnvelope(envelope2.gain, layer2.envelope, time);
+    applyEnvelope(envelope2.gain, layer3.envelope, time);
     for (const { depth, target: modulated } of depths) if (modulated === "gain") depth.connect(envelope2.gain);
-    const filters = (layer2.filters?.bank ?? []).map((filter) => filterNode(context, filter, time));
+    const filters = (layer3.filters?.bank ?? []).map((filter) => filterNode(context, filter, time));
     let tail = oscillator;
     for (const filter of filters) tail = tail.connect(filter);
     tail.connect(envelope2);
     envelope2.connect(target.output);
-    if (layer2.wet && target.wet) {
-      const send = gainNode(context, layer2.wet);
+    if (layer3.wet && target.wet) {
+      const send = gainNode(context, layer3.wet);
       envelope2.connect(send);
       send.connect(target.wet);
     }
-    const stop = end2(layer2, time);
+    const stop = end2(layer3, time);
     oscillator.start(time);
     for (const lfo of lfos) lfo.start(time);
     oscillator.stop(stop);
     for (const lfo of lfos) lfo.stop(stop);
     return voiceOf([oscillator, ...lfos]);
   }
-  function noiseLayer(layer2, target, time) {
+  function noiseLayer(layer3, target, time) {
     const { context } = target;
-    const source = noiseSource(target, layer2.source.kind === "noise" && layer2.source.loop);
-    const filters = (layer2.filters?.bank ?? []).map((filter) => filterNode(context, filter, time));
+    const source = noiseSource(target, layer3.source.kind === "noise" && layer3.source.loop);
+    const filters = (layer3.filters?.bank ?? []).map((filter) => filterNode(context, filter, time));
     const envelope2 = context.createGain();
-    applyEnvelope(envelope2.gain, layer2.envelope, time);
+    applyEnvelope(envelope2.gain, layer3.envelope, time);
     let tail = source;
     for (const filter of filters) tail = tail.connect(filter);
     tail.connect(envelope2).connect(target.output);
-    source.start(time, layer2.source.kind === "noise" ? layer2.source.offset : 0);
-    source.stop(time + layer2.duration + layer2.tail);
+    source.start(time, layer3.source.kind === "noise" ? layer3.source.offset : 0);
+    source.stop(time + layer3.duration + layer3.tail);
     return source;
   }
-  function toneLayer(layer2, target, time) {
+  function toneLayer(layer3, target, time) {
     const { context } = target;
     const oscillator = context.createOscillator();
-    if (layer2.source.kind === "osc") {
-      oscillator.type = layer2.source.wave;
-      assign(oscillator.frequency, layer2.source.frequency, time);
-      rampTo(oscillator.frequency, layer2.source.frequency, time);
+    if (layer3.source.kind === "osc") {
+      oscillator.type = layer3.source.wave;
+      assign(oscillator.frequency, layer3.source.frequency, time);
+      rampTo(oscillator.frequency, layer3.source.frequency, time);
     }
     const envelope2 = context.createGain();
-    applyEnvelope(envelope2.gain, layer2.envelope, time);
+    applyEnvelope(envelope2.gain, layer3.envelope, time);
     oscillator.connect(envelope2).connect(target.output);
     oscillator.start(time);
-    oscillator.stop(time + layer2.duration + layer2.tail);
+    oscillator.stop(time + layer3.duration + layer3.tail);
     return oscillator;
   }
   function realizeWeapon(plan, target) {
-    const sources = plan.layers.map((layer2) => {
-      const time = target.time + layer2.at;
-      return layer2.source.kind === "noise" ? noiseLayer(layer2, target, time) : toneLayer(layer2, target, time);
+    const sources = plan.layers.map((layer3) => {
+      const time = target.time + layer3.at;
+      return layer3.source.kind === "noise" ? noiseLayer(layer3, target, time) : toneLayer(layer3, target, time);
     });
     return voiceOf(sources);
   }
@@ -38512,19 +39213,19 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     rate: modulator.rate * rate,
     ...modulator.target === "frequency" ? { depth: modulator.depth * rate } : {}
   });
-  var tuneLayer = (layer2, rate) => ({
-    ...layer2,
-    at: layer2.at / rate,
-    duration: layer2.duration / rate,
-    tail: layer2.tail / rate,
-    source: tuneSource(layer2.source, rate),
-    ...layer2.filters ? { filters: { ...layer2.filters, bank: layer2.filters.bank.map((filter) => tuneFilter(filter, rate)) } } : {},
-    modulators: layer2.modulators.map((modulator) => tuneModulator(modulator, rate)),
-    envelope: layer2.envelope.map((point) => ({ ...point, time: point.time / rate }))
+  var tuneLayer = (layer3, rate) => ({
+    ...layer3,
+    at: layer3.at / rate,
+    duration: layer3.duration / rate,
+    tail: layer3.tail / rate,
+    source: tuneSource(layer3.source, rate),
+    ...layer3.filters ? { filters: { ...layer3.filters, bank: layer3.filters.bank.map((filter) => tuneFilter(filter, rate)) } } : {},
+    modulators: layer3.modulators.map((modulator) => tuneModulator(modulator, rate)),
+    envelope: layer3.envelope.map((point) => ({ ...point, time: point.time / rate }))
   });
   function retunePlan(plan, rate) {
     if (rate === 1 || !(rate > 0)) return plan;
-    return { ...plan, length: plan.length / rate, layers: plan.layers.map((layer2) => tuneLayer(layer2, rate)) };
+    return { ...plan, length: plan.length / rate, layers: plan.layers.map((layer3) => tuneLayer(layer3, rate)) };
   }
   function createSetPicker() {
     const last = /* @__PURE__ */ new Map();
@@ -38612,6 +39313,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
     };
   }
+  var TRIM_FADE = 0.04;
   function realizeSample(plan, target) {
     const context = target.context;
     let head = target.output;
@@ -38633,16 +39335,26 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     voice2.connect(head);
     head = voice2;
     const sources = [];
-    for (const layer2 of plan.layers) {
-      const buffer = target.buffer(layer2.url);
+    for (const layer3 of plan.layers) {
+      const buffer = target.buffer(layer3.url);
       if (!buffer) continue;
       const source = context.createBufferSource();
       source.buffer = buffer;
-      source.playbackRate.value = layer2.rate;
-      const gain = gainNode(context, layer2.gain);
+      source.playbackRate.value = layer3.rate;
+      const gain = gainNode(context, layer3.gain);
       source.connect(gain);
       gain.connect(head);
-      source.start(target.time + layer2.at);
+      const at3 = target.time + layer3.at;
+      const offset = Math.max(0, Math.min(layer3.offset ?? 0, buffer.duration));
+      if (layer3.duration === void 0) source.start(at3, offset);
+      else {
+        const duration = Math.max(0, Math.min(layer3.duration, buffer.duration - offset));
+        const end3 = at3 + duration / layer3.rate;
+        const fade = Math.min(TRIM_FADE, (end3 - at3) / 4);
+        gain.gain.setValueAtTime(layer3.gain, end3 - fade);
+        gain.gain.linearRampToValueAtTime(0, end3);
+        source.start(at3, offset, duration);
+      }
       sources.push(source);
     }
     const realized = voiceOf(sources);
@@ -38662,7 +39374,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   function sampleLength(plan, seconds) {
     let length2 = 0;
-    for (const layer2 of plan.layers) length2 = Math.max(length2, layer2.at + (seconds(layer2.url) ?? 0) / layer2.rate);
+    for (const layer3 of plan.layers) {
+      const file = seconds(layer3.url) ?? 0;
+      const played = layer3.duration === void 0 ? file - (layer3.offset ?? 0) : Math.min(layer3.duration, file - (layer3.offset ?? 0));
+      length2 = Math.max(length2, layer3.at + Math.max(0, played) / layer3.rate);
+    }
     return length2;
   }
   function limiterCurve2(knee, ceiling, range3, points = 2049) {
@@ -38676,8 +39392,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     return curve;
   }
-  var usesNoise = (recipe2) => recipe2.layers.some((layer2) => layer2.source.kind !== "osc");
-  var planUsesNoise = (plan) => plan.layers.some((layer2) => layer2.source.kind !== "osc");
+  var usesNoise = (recipe2) => recipe2.layers.some((layer3) => layer3.source.kind !== "osc");
+  var planUsesNoise = (plan) => plan.layers.some((layer3) => layer3.source.kind !== "osc");
   function createAudioEngine(options = {}) {
     const seed = options.seed ?? 1;
     const registry = createSoundRegistry(options.banks);
@@ -38916,7 +39632,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         level: plan.level,
         distance: plan.distance,
         ...plan.pan === void 0 ? {} : { pan: plan.pan },
-        layers: plan.layers.map((layer2) => ({ role: layer2.role, url: layer2.url, take: layer2.take, rate: layer2.rate })),
+        layers: plan.layers.map((layer3) => ({ role: layer3.role, url: layer3.url, take: layer3.take, rate: layer3.rate })),
         ...plan.tier ? { tier: plan.tier } : {}
       });
       voices.setLength(voiceId, sampleLength(plan, (url2) => sampleStore.seconds(url2)) + (playOptions.delay ?? 0));
@@ -39049,7 +39765,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             random: engineRandom,
             register: loopHost.register,
             unregister: loopHost.unregister,
-            muted: (bus) => busSettings.get(bus)?.muted === true
+            muted: (bus) => busSettings.get(bus)?.muted === true,
+            listener: () => listener,
+            ...options.distance ? { distance: options.distance } : {}
           },
           loopOptions.volume
         );
@@ -39234,7 +39952,22 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ["smg_45_auto", 2, "sfx_pistol"],
       ["weapon_draw", 2],
       ["suppressor_attach", 3],
-      ["suppressor_detach", 3]
+      ["suppressor_detach", 3],
+      ["minigun_loop", 3],
+      ["smg_5_7x28", 3],
+      ["mg_belt_adjust", 3],
+      ["mg_belt_box_attach", 3],
+      ["mg_cover_open", 3],
+      ["mg_cover_close", 3],
+      ["weapon_holster", 3],
+      ["scope_zoom", 3]
+    ]),
+    ...entries("impactos", [
+      ["knife_hit_wall", 3],
+      ["helmet_hit", 3],
+      ["vest_hit", 3],
+      ["headshot", 3],
+      ["blood_squirt", 3]
     ]),
     ...entries("explosoes-fogo", [
       ["explosion_grenade", 1, "boom"],
@@ -39252,7 +39985,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ["grenade_bounce", 1],
       ["c4_plant", 2],
       ["c4_beep", 2],
-      ["c4_disarm", 2]
+      ["c4_disarm", 2],
+      ["c4_disarming_loop", 3],
+      ["c4_remote_detonate", 3],
+      ["smoke_grenade_hiss", 3],
+      ["grenade_pin_pull", 3],
+      ["electric_shock", 3],
+      ["electric_spark", 3]
     ]),
     ...entries("personagem", [
       ["footstep_concrete_walk", 1, "sfx_step"],
@@ -39280,7 +40019,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ["zombie_attack", 1],
       ["zombie_pain", 1],
       ["zombie_claw_hit", 1, "sfx_flesh"],
-      ["zombie_claw_miss", 2]
+      ["zombie_claw_miss", 2],
+      ["swing_whoosh", 3],
+      ["heartbeat_critical", 3],
+      ["fall_water", 3],
+      ["fall_damage", 3],
+      ["fall_scream", 3],
+      ["footstep_glass_walk", 3]
     ]),
     ...entries("veiculos", [
       ["engine_loop_car", 1],
@@ -39290,7 +40035,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ["car_door_open", 1, "latch"],
       ["car_door_close", 1, "shut_metal"],
       ["horn_car", 2, "horn"],
-      ["tire_skid_asphalt", 2]
+      ["tire_skid_asphalt", 2],
+      ["jet_flyby", 3],
+      ["helicopter_turbine", 3],
+      ["tire_burnout", 3],
+      ["handbrake_turn", 3],
+      ["siren_police", 3]
     ]),
     ...entries("itens-portas", [
       ["item_pickup_metal", 1],
@@ -39301,7 +40051,27 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ["door_creak", 1, "creak_wood"],
       ["door_locked_rattle", 1, "rattle"],
       ["drawer_open", 2, "slide"],
-      ["fridge_close", 2, "shut_metal"]
+      ["fridge_close", 2, "shut_metal"],
+      ["inventory_open", 3],
+      ["inventory_close", 3],
+      ["inventory_select", 3],
+      ["inventory_place", 3],
+      ["pickup_chime", 3],
+      ["item_pickup_coins", 3],
+      ["bandage_use", 3],
+      ["bandage_refuse", 3],
+      ["flashlight_toggle", 3],
+      ["gear_draw", 3],
+      ["gear_holster", 3],
+      ["button_press", 3],
+      ["lock_desk_open", 3],
+      ["elevator_move_loop", 3],
+      ["elevator_stop", 3],
+      ["door_sliding", 3],
+      ["door_kick", 3],
+      ["door_wood_break", 3],
+      ["gate_iron_open", 3],
+      ["gate_iron_close", 3]
     ]),
     ...entries("ambiente", [
       ["rain_loop", 2],
@@ -39309,7 +40079,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ["thunder_near", 2],
       ["thunder_far", 2],
       ["water_splash", 2],
-      ["helicopter_loop", 3]
+      ["helicopter_loop", 3],
+      ["bird_flush", 3],
+      ["dog_growl", 3],
+      ["dog_whimper", 3],
+      ["dog_howl", 3],
+      ["zombie_dog_bark", 3],
+      ["zombie_dog_howl_far", 3],
+      ["insect_squash", 3],
+      ["insect_crawl", 3],
+      ["fan_loop", 3]
     ])
   ];
   var SFX_MATERIALS = [
@@ -39445,6 +40224,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     return { id: options.id, samples };
   }
+  var CATALOG = new Map([...SFX_CATALOG, ...SFX_IMPACTS].map((entry2) => [entry2.id, entry2]));
   var PT = {
     group: "Som",
     name: "Painel de som (arquivos e C1\u2013C10)",
@@ -39519,9 +40299,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     strengths: { light: "leve", medium: "m\xE9dio", heavy: "forte" },
     states: { file: "A", synth: "S", missing: "F" },
     criteria: { C1: "C1 Sincronia", C2: "C2 Certo p/ a\xE7\xE3o", C3: "C3 Dist\xE2ncia", C4: "C4 Posi\xE7\xE3o", C5: "C5 Varia\xE7\xE3o", C6: "C6 Volume", C7: "C7 Intensidade", C8: "C8 Cauda", C9: "C9 Rajada", C10: "C10 Escuta" },
-    metrics: { source: "1 \xB7 Fonte do que tocou", chosen: "1 \xB7 Escolhido", matrix: "2 \xB7 Matriz", last: "\xDAltimo tocado", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Prefer\xEAncias", state: "5 \xB7 Medi\xE7\xE3o", count: "1 \xB7 Cat\xE1logo" },
+    metrics: { source: "1 \xB7 Fonte do que tocou", chosen: "1 \xB7 Escolhido", matrix: "2 \xB7 Matriz", last: "\xDAltimo tocado", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Prefer\xEAncias", state: "5 \xB7 Medi\xE7\xE3o", count: "1 \xB7 Cat\xE1logo", unlicensed: "1 \xB7 Arquivo sem licen\xE7a" },
     run: { idle: "parada", measuring: "medindo\u2026", done: "pronta", failed: "falhou", recording: "gravando\u2026", recorded: "grava\xE7\xE3o baixada" },
-    words: { none: "\u2014", hidden: "? (revele)", prefers: "prefere", approved: "aprovado pelo dono" },
+    words: { none: "\u2014", hidden: "? (revele)", prefers: "prefere", approved: "aprovado pelo dono", local_file: "arquivo do pacote local", sdk_file: "grava\xE7\xE3o do SDK", synth: "s\xEDntese do SDK" },
     sources: { sdk: "SDK", user: "seu som", synth: "sintetizado" },
     probe: "Fonte do som",
     wall: "Parede (oclus\xE3o)",
@@ -39592,9 +40372,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     environments: { indoor: "indoor", outdoor: "outdoor" },
     strengths: { light: "light", medium: "medium", heavy: "heavy" },
     criteria: { C1: "C1 Sync", C2: "C2 Right sound", C3: "C3 Distance", C4: "C4 Position", C5: "C5 Variation", C6: "C6 Level", C7: "C7 Strength", C8: "C8 Tail", C9: "C9 Burst", C10: "C10 Listening" },
-    metrics: { source: "1 \xB7 Source of what played", chosen: "1 \xB7 Chosen", matrix: "2 \xB7 Matrix", last: "Last played", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Preferences", state: "5 \xB7 Measurement", count: "1 \xB7 Catalogue" },
+    metrics: { source: "1 \xB7 Source of what played", chosen: "1 \xB7 Chosen", matrix: "2 \xB7 Matrix", last: "Last played", ab: "4 \xB7 A \xD7 B", blind: "4 \xB7 X", verdicts: "4 \xB7 Preferences", state: "5 \xB7 Measurement", count: "1 \xB7 Catalogue", unlicensed: "1 \xB7 File without licence" },
     run: { idle: "idle", measuring: "measuring\u2026", done: "done", failed: "failed", recording: "recording\u2026", recorded: "recording downloaded" },
-    words: { none: "\u2014", hidden: "? (reveal)", prefers: "prefers", approved: "approved by the owner" },
+    words: { none: "\u2014", hidden: "? (reveal)", prefers: "prefers", approved: "approved by the owner", local_file: "local pack file", sdk_file: "SDK recording", synth: "SDK synthesis" },
     sources: { sdk: "SDK", user: "your sound", synth: "synthesized" },
     probe: "Sound source",
     wall: "Wall (occlusion)",
@@ -39665,6 +40445,66 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
   }
   var sceneMany = (count, make3) => Array.from({ length: count }, make3);
+  var hz = (midi) => 440 * 2 ** ((midi - 69) / 12);
+  var layer = (note2, beat, wave, level) => {
+    const [at3, midi, beats] = note2;
+    const length2 = beats * beat;
+    return {
+      at: at3 * beat,
+      duration: length2,
+      source: { kind: "osc", wave, frequency: { set: hz(midi) } },
+      envelope: [[0, 1e-4, "set"], [0.01, level, "linear"], [Math.max(0.02, length2 * 0.9), level * 0.35, "linear"], [length2, 1e-4, "exp", "fixed"]]
+    };
+  };
+  function radioTrack(spec) {
+    const beat = 60 / spec.bpm;
+    const recipes = Array.from({ length: spec.bars }, (_, bar2) => {
+      const inBar = (notes) => notes.filter((n) => n[0] >= bar2 * 4 && n[0] < bar2 * 4 + 4).map((n) => [n[0] - bar2 * 4, n[1], n[2]]);
+      const layers = [
+        ...inBar(spec.bass).map((n) => layer(n, beat, "triangle", 0.16)),
+        ...inBar(spec.chords).map((n) => layer(n, beat, "sine", 0.05)),
+        ...inBar(spec.melody).map((n) => layer(n, beat, spec.wave, 0.07))
+      ];
+      return { id: `${spec.id}_${bar2}`, bus: "world", duration: 4 * beat, layers, falloff: { model: "none" } };
+    });
+    return { song: { id: spec.id, barSeconds: 4 * beat, bars: recipes.map((r) => r.id) }, recipes };
+  }
+  var chord = (bar2, root, minor = false) => [[bar2 * 4, root, 4], [bar2 * 4, root + (minor ? 3 : 4), 4], [bar2 * 4, root + 7, 4]];
+  var bassLine = (roots, pattern) => roots.flatMap((root, bar2) => pattern.map((b) => [bar2 * 4 + b, root - 12, 0.9]));
+  var TRACKS = [
+    // a bright pop loop: I–V–vi–IV in C
+    radioTrack({
+      id: "radio_track_pop",
+      bpm: 112,
+      bars: 4,
+      wave: "square",
+      bass: bassLine([48, 55, 57, 53], [0, 1.5, 2, 3]),
+      chords: [...chord(0, 60), ...chord(1, 55), ...chord(2, 57, true), ...chord(3, 53)],
+      melody: [[0, 76, 1], [1, 74, 0.5], [1.5, 72, 1.5], [4, 74, 1], [5, 76, 1], [6, 79, 2], [8, 76, 1], [9, 74, 1], [10, 72, 2], [12, 72, 1], [13, 74, 1], [14, 72, 2]]
+    }),
+    // a syncopated loop in A minor, the bass on the off-beats
+    radioTrack({
+      id: "radio_track_groove",
+      bpm: 100,
+      bars: 4,
+      wave: "triangle",
+      bass: bassLine([57, 62, 64, 57], [0, 0.75, 1.5, 2.5, 3.25]),
+      chords: [...chord(0, 57, true), ...chord(1, 62, true), ...chord(2, 64), ...chord(3, 57, true)],
+      melody: [[0.5, 72, 0.5], [1.25, 76, 0.75], [2.5, 74, 1], [4.5, 77, 0.5], [5.25, 74, 0.75], [6.5, 72, 1.5], [8.5, 71, 0.5], [9.25, 74, 0.75], [10.5, 76, 1.5], [12.5, 72, 0.5], [13.25, 69, 2]]
+    }),
+    // a slow blues-like loop in F with a swung melody
+    radioTrack({
+      id: "radio_track_slow",
+      bpm: 76,
+      bars: 4,
+      wave: "sine",
+      bass: bassLine([53, 58, 53, 60], [0, 2]),
+      chords: [...chord(0, 65), ...chord(1, 58), ...chord(2, 65), ...chord(3, 60)],
+      melody: [[0, 72, 1.5], [1.67, 75, 0.33], [2, 77, 2], [4, 74, 1], [5, 72, 1], [6, 70, 2], [8, 72, 1.5], [9.67, 69, 0.33], [10, 65, 2], [12, 67, 1], [13, 70, 1], [14, 72, 2]]
+    })
+  ];
+  var RADIO_TRACKS = TRACKS.map((t) => t.song);
+  var RADIO_BANK = { id: "vehicle_radio", sounds: TRACKS.flatMap((t) => t.recipes), loops: [] };
   var FOLEY_FALLOFF = {
     model: "inverse_square",
     k: 0.02,
@@ -40271,11 +41111,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ...s.splash ? [sceneNoise({ type: "bandpass", f: s.splash.f * take.f, f2: s.splash.f2 * take.f, q: 1.4, d: s.splash.d * take.t * weight ** 0.4, vol: s.splash.vol * gait.vol * take.v * weight ** 0.5 })] : []
     ];
   }
-  var quieter = (level, layers) => layers.map((layer2) => {
-    const gain = layer2.gain ?? 1;
-    if (typeof gain === "number") return { ...layer2, gain: gain * level };
-    if (Array.isArray(gain)) return { ...layer2, gain: [gain[0] * level, gain[1] * level] };
-    return layer2;
+  var quieter = (level, layers) => layers.map((layer22) => {
+    const gain = layer22.gain ?? 1;
+    if (typeof gain === "number") return { ...layer22, gain: gain * level };
+    if (Array.isArray(gain)) return { ...layer22, gain: [gain[0] * level, gain[1] * level] };
+    return layer22;
   });
   var recipe = (id, layers, falloff, bus = "world") => ({ id, bus, pan: true, layers, falloff, sources: ["sdk"] });
   var takeId = (id, index) => `${id}_${String(index + 1).padStart(2, "0")}`;
@@ -40291,7 +41131,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     (take) => quieter(LANDING_LEVEL, [
       // both feet, a hair apart, then the knees taking the weight (a low body thump) and the clothes settling
       ...footLayers(surface, take, GAITS.run, LANDINGS[landing2].weight),
-      ...footLayers(surface, { ...take, v: take.v * 0.6 }, GAITS.run, LANDINGS[landing2].weight * 0.6).map((layer2) => ({ ...layer2, at: (typeof layer2.at === "number" ? layer2.at : 0) + 0.018 * take.t })),
+      ...footLayers(surface, { ...take, v: take.v * 0.6 }, GAITS.run, LANDINGS[landing2].weight * 0.6).map((layer22) => ({ ...layer22, at: (typeof layer22.at === "number" ? layer22.at : 0) + 0.018 * take.t })),
       sceneTone({ f: 60 * take.f, f2: 38, d: 0.14 * LANDINGS[landing2].weight * take.t, vol: 0.22 * LANDINGS[landing2].weight ** 0.7 * take.v, delay: 0.02 }),
       sceneNoise({ type: "bandpass", f: [1800, 2600], q: 0.8, d: 0.18, vol: LANDINGS[landing2].cloth * take.v, delay: 0.04 })
     ]),
@@ -40337,7 +41177,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     fall_damage: (take) => [
       ...BODY.body_fall(take),
       sceneNoise({ type: "highpass", f: 2800, d: 0.02, vol: 0.35 * take.v, delay: 0.01 }),
-      ...voice({ f0: 170, f1: 110, d: 0.32, fA: 650, fB: 1150, noise: 0.25, vol: 0.32 })(take).map((layer2) => ({ ...layer2, at: 0.08 }))
+      ...voice({ f0: 170, f1: 110, d: 0.32, fA: 650, fB: 1150, noise: 0.25, vol: 0.32 })(take).map((layer22) => ({ ...layer22, at: 0.08 }))
     ],
     player_hurt: voice({ f0: 150, f1: 105, d: 0.26, fA: 620, fB: 1100, noise: 0.3, vol: 0.35 }),
     player_breath_run: (take) => [
@@ -42410,7 +43250,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             if (base.space === "indoor") {
               for (const voice2 of shot.voices) if (voice2.group === "tail") playGunshotVoice(voice2, extras);
             }
-            const layers = handle?.kind === "sample" ? handle.plan.layers.map((layer2) => ({ role: layer2.role, take: layer2.take, rate: layer2.rate })) : [];
+            const layers = handle?.kind === "sample" ? handle.plan.layers.map((layer3) => ({ role: layer3.role, take: layer3.take, rate: layer3.rate })) : [];
             options.onGunshot?.(shot, { ...base, take, pitch }, { kind: "sample", id: recorded, layers });
             return;
           }
@@ -43232,6 +44072,19 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         "drink",
         "sticky"
       ]
+    },
+    {
+      id: "mud",
+      color: 4008988,
+      opacity: 0.95,
+      stainColor: 3811866,
+      viscosity: 40,
+      density: 1600,
+      dryTime: 900,
+      gloss: 0.4,
+      tags: [
+        "dirty"
+      ]
     }
   ];
   var LIQUIDS = liquids_default;
@@ -49837,6 +50690,273 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return group;
   }
 
+  // src/models/rounded-box.ts
+  var uvAlong = (THREE, faceDirection, normal, uvAxis, projectionAxis, radius, sideLength) => {
+    const arcLength = 2 * Math.PI * radius / 4;
+    const centerLength = Math.max(sideLength - 2 * radius, 0);
+    const halfArc = Math.PI / 4;
+    const projected = new THREE.Vector3().copy(normal);
+    projected[projectionAxis] = 0;
+    projected.normalize();
+    const arcUvRatio = 0.5 * arcLength / (arcLength + centerLength);
+    const arcAngleRatio = 1 - projected.angleTo(faceDirection) / halfArc;
+    if (Math.sign(projected[uvAxis]) === 1) return arcAngleRatio * arcUvRatio;
+    const centerUv = centerLength / (arcLength + centerLength);
+    return centerUv + arcUvRatio + arcUvRatio * (1 - arcAngleRatio);
+  };
+  var FACES = [
+    { direction: [1, 0, 0], u: ["z", "y", false], v: ["y", "z", true] },
+    { direction: [-1, 0, 0], u: ["z", "y", true], v: ["y", "z", true] },
+    { direction: [0, 1, 0], u: ["x", "z", true], v: ["z", "x", false] },
+    { direction: [0, -1, 0], u: ["x", "z", true], v: ["z", "x", true] },
+    { direction: [0, 0, 1], u: ["x", "y", true], v: ["y", "x", true] },
+    { direction: [0, 0, -1], u: ["x", "y", false], v: ["y", "x", true] }
+  ];
+  function createRoundedBoxGeometry(THREE, width, height, depth, segments, radius) {
+    const count = segments * 2 + 1;
+    const rounding = Math.min(width / 2, height / 2, depth / 2, radius);
+    const geometry = new THREE.BoxGeometry(1, 1, 1, count, count, count);
+    const flat2 = geometry.toNonIndexed();
+    geometry.setIndex(null);
+    geometry.setAttribute("position", flat2.attributes.position);
+    geometry.setAttribute("normal", flat2.attributes.normal);
+    geometry.setAttribute("uv", flat2.attributes.uv);
+    const position = new THREE.Vector3();
+    const normal = new THREE.Vector3();
+    const box5 = new THREE.Vector3(width, height, depth).divideScalar(2).subScalar(rounding);
+    const positions2 = geometry.attributes.position.array;
+    const normals = geometry.attributes.normal.array;
+    const uvs = geometry.attributes.uv.array;
+    const faceTriangles = positions2.length / 6;
+    const halfSegment = 0.5 / count;
+    const sides = { x: width, y: height, z: depth };
+    for (let i = 0, j = 0; i < positions2.length; i += 3, j += 2) {
+      position.fromArray(positions2, i);
+      normal.copy(position);
+      normal.x -= Math.sign(normal.x) * halfSegment;
+      normal.y -= Math.sign(normal.y) * halfSegment;
+      normal.z -= Math.sign(normal.z) * halfSegment;
+      normal.normalize();
+      positions2[i] = box5.x * Math.sign(position.x) + normal.x * rounding;
+      positions2[i + 1] = box5.y * Math.sign(position.y) + normal.y * rounding;
+      positions2[i + 2] = box5.z * Math.sign(position.z) + normal.z * rounding;
+      normals[i] = normal.x;
+      normals[i + 1] = normal.y;
+      normals[i + 2] = normal.z;
+      const face = FACES[Math.floor(i / faceTriangles)];
+      if (!face) continue;
+      const direction = new THREE.Vector3(...face.direction);
+      for (const [offset, [uvAxis, projectionAxis, mirrored]] of [[0, face.u], [1, face.v]]) {
+        const value = uvAlong(THREE, direction, normal, uvAxis, projectionAxis, rounding, sides[uvAxis]);
+        uvs[j + offset] = mirrored ? 1 - value : value;
+      }
+    }
+    return geometry;
+  }
+
+  // src/models/kit.ts
+  var PI2 = Math.PI;
+  var createMaterials = (THREE) => {
+    const standard = (color2, roughness = 0.7, metalness = 0.2, extra = {}) => new THREE.MeshStandardMaterial({ color: color2, roughness, metalness, ...extra });
+    const basic = (color2, extra = {}) => new THREE.MeshBasicMaterial({ color: color2, ...extra });
+    const additive = { transparent: true, opacity: 0.95, blending: THREE.AdditiveBlending, depthWrite: false };
+    const materials = {
+      metal: standard(3422010, 0.42, 0.75),
+      steel: standard(7106418, 0.32, 0.85),
+      steelL: standard(9080208, 0.28, 0.9),
+      dark: standard(1711133, 0.55, 0.5),
+      poly: standard(2369058, 0.8, 0.05),
+      olive: standard(4936241, 0.8, 0.05),
+      tan: standard(10259043, 0.8, 0.05),
+      wood: standard(4860951, 0.55, 0),
+      woodL: standard(6175263, 0.55, 0),
+      brass: standard(12819013, 0.28, 0.9),
+      copper: standard(11561531, 0.3, 0.85),
+      lead: standard(7171955, 0.5, 0.5),
+      shell: standard(10692380, 0.5, 0.05),
+      glass: standard(8364968, 0.05, 0.1, { transparent: true, opacity: 0.42 }),
+      lens: standard(2311770, 0.05, 0.3, { transparent: true, opacity: 0.9, emissive: 399392 }),
+      rubber: standard(1381653, 0.85, 0),
+      white: standard(13617332, 0.8, 0),
+      hole: standard(526343, 1, 0),
+      bake: standard(5911072, 0.55, 0),
+      rust: standard(7027230, 0.95, 0.3),
+      rustD: standard(4860440, 0.95, 0.25),
+      worn: standard(5593178, 0.6, 0.6),
+      fire: basic(16742946),
+      fire2: basic(16764762),
+      flashA: basic(16757575, additive),
+      flashB: basic(16773568, additive),
+      smokeP: standard(9079430, 1, 0, { transparent: true, opacity: 0.35, depthWrite: false }),
+      /** Launcher paints. */
+      yellow: standard(11570978, 0.6, 0),
+      red: standard(9313300, 0.45, 0.1),
+      redPaint: standard(10691354, 0.35, 0.2),
+      tape: standard(9079944, 0.9, 0),
+      pipe: standard(10115634, 0.35, 0.8),
+      green: standard(3818536, 0.75, 0.05),
+      /** Explosive finishes: the molotov's bottle, the dynamite's paper, the C4's putty and the detonator's wire. */
+      bottle: standard(3103284, 0.1, 0.1, { transparent: true, opacity: 0.72 }),
+      dynamite: standard(10365471, 0.7, 0),
+      c4: standard(7170636, 0.95, 0),
+      wire: standard(11542560, 0.5, 0),
+      /** Magazine finishes named by the options. */
+      bakelite: standard(6958620, 0.6, 0),
+      polyMag: standard(2763302, 0.85, 0)
+    };
+    markShared(...Object.values(materials));
+    return materials;
+  };
+  var kits = /* @__PURE__ */ new WeakMap();
+  function modelKit(host) {
+    const cached = kits.get(host);
+    if (cached) return cached;
+    const THREE = shapeGeometries(host);
+    const geometries = /* @__PURE__ */ new Map();
+    const shadowed = (mesh3) => {
+      mesh3.castShadow = true;
+      mesh3.receiveShadow = true;
+      return mesh3;
+    };
+    const place = (parent, mesh3, x, y, z) => {
+      mesh3.position.set(x, y, z);
+      parent.add(mesh3);
+      return mesh3;
+    };
+    const kit = {
+      THREE,
+      M: createMaterials(THREE),
+      roundness: null,
+      group: () => new THREE.Group(),
+      box(parent, w, h, d, material, x, y, z, rz = 0, ry = 0, rx = 0) {
+        const radius = Math.min(w, h, d) * (kit.roundness ?? 0.2);
+        const key2 = `${w.toFixed(4)},${h.toFixed(4)},${d.toFixed(4)},${radius.toFixed(5)}`;
+        let geometry = geometries.get(key2);
+        if (!geometry) {
+          geometry = radius > 25e-5 ? createRoundedBoxGeometry(THREE, w, h, d, 2, radius) : new THREE.BoxGeometry(w, h, d);
+          markShared(geometry);
+          geometries.set(key2, geometry);
+        }
+        const mesh3 = place(parent, shadowed(new THREE.Mesh(geometry, material)), x, y, z);
+        mesh3.rotation.set(rx, ry, rz);
+        return mesh3;
+      },
+      cylinderX(parent, radius, length2, material, x, y, z, segments = 16, radiusEnd) {
+        const mesh3 = shadowed(new THREE.Mesh(new THREE.CylinderGeometry(radiusEnd ?? radius, radius, length2, segments), material));
+        mesh3.rotation.z = -PI2 / 2;
+        return place(parent, mesh3, x, y, z);
+      },
+      cylinderY(parent, radius, height, material, x, y, z, segments = 16, radiusEnd) {
+        return place(parent, shadowed(new THREE.Mesh(new THREE.CylinderGeometry(radiusEnd ?? radius, radius, height, segments), material)), x, y, z);
+      },
+      cylinderZ(parent, radius, length2, material, x, y, z, segments = 16) {
+        const mesh3 = shadowed(new THREE.Mesh(new THREE.CylinderGeometry(radius, radius, length2, segments), material));
+        mesh3.rotation.x = PI2 / 2;
+        return place(parent, mesh3, x, y, z);
+      },
+      sphere(parent, radius, material, x, y, z, detail = 1) {
+        return place(parent, shadowed(new THREE.Mesh(new THREE.IcosahedronGeometry(radius, detail), material)), x, y, z);
+      },
+      torus: (parent, geometry, material, x, y, z) => place(parent, shadowed(new THREE.Mesh(geometry, material)), x, y, z),
+      mark(parent, x, y, z) {
+        const object2 = new THREE.Object3D();
+        object2.position.set(x, y, z);
+        parent.add(object2);
+        return object2;
+      },
+      pivot(parent, x = 0, y = 0, z = 0) {
+        const group = new THREE.Group();
+        group.position.set(x, y, z);
+        parent.add(group);
+        return group;
+      }
+    };
+    kits.set(host, kit);
+    return kit;
+  }
+  function heatify(glow, mesh3) {
+    mesh3.material = mesh3.material.clone();
+    glow.push(mesh3);
+    return mesh3;
+  }
+
+  // src/models/explosives.ts
+  var grenade = (kit, group) => {
+    const { M, sphere: sphere2, cylinderY, box: box5, torus: torus2, THREE } = kit;
+    sphere2(group, 0.032, M.olive, 0, 0.032, 0, 1);
+    cylinderY(group, 0.011, 0.022, M.metal, 0, 0.072, 0);
+    box5(group, 0.012, 0.07, 6e-3, M.metal, 0.016, 0.05, 0, 0.2);
+    torus2(group, new THREE.TorusGeometry(85e-4, 16e-4, 6, 12), M.steel, -0.012, 0.082, 0);
+    kit.mark(group, 0, 0.032, 0).name = "handle";
+  };
+  var molotov = (kit, group) => {
+    const { M, cylinderY, box: box5 } = kit;
+    cylinderY(group, 0.036, 0.17, M.bottle, 0, 0.085, 0, 10);
+    cylinderY(group, 0.012, 0.06, M.bottle, 0, 0.2, 0, 8, 0.036);
+    box5(group, 0.03, 0.08, 0.02, M.white, 5e-3, 0.25, 0, 0.3);
+    cylinderY(group, 0.02, 0.07, M.fire, 0.01, 0.31, 0, 6, 0).userData.flame = true;
+    kit.mark(group, 0, 0.085, 0).name = "handle";
+  };
+  var pipeBomb = (kit, group) => {
+    const { M, cylinderX, cylinderY } = kit;
+    cylinderX(group, 0.025, 0.2, M.metal, 0, 0.03, 0, 8);
+    cylinderX(group, 0.031, 0.025, M.dark, -0.1, 0.03, 0, 6);
+    cylinderX(group, 0.031, 0.025, M.dark, 0.1, 0.03, 0, 6);
+    cylinderY(group, 2e-3, 0.06, M.white, 0.1, 0.07, 0);
+    kit.mark(group, 0, 0.03, 0).name = "handle";
+  };
+  var dynamite = (kit, group) => {
+    const { M, cylinderX } = kit;
+    for (const [z, y] of [[-0.015, 0], [0.015, 0], [0, 0.026]]) cylinderX(group, 0.014, 0.2, M.dynamite, 0, 0.016 + y, z, 8);
+    cylinderX(group, 0.031, 0.03, M.dark, -0.04, 0.025, 0, 8);
+    cylinderX(group, 0.031, 0.03, M.dark, 0.05, 0.025, 0, 8);
+    cylinderX(group, 2e-3, 0.1, M.white, 0.14, 0.03, 0, 4);
+    kit.mark(group, 0, 0.025, 0).name = "handle";
+  };
+  var c4 = (kit, group) => {
+    const { M, box: box5, cylinderY } = kit;
+    box5(group, 0.28, 0.05, 0.11, M.c4, 0, 0.025, 0);
+    box5(group, 0.05, 0.03, 0.04, M.dark, 0.06, 0.065, 0);
+    cylinderY(group, 4e-3, 0.05, M.metal, 0.03, 0.07, 0);
+    box5(group, 0.24, 3e-3, 3e-3, M.wire, 0.18, 0.055, 0.02);
+    box5(group, 0.24, 3e-3, 3e-3, M.metal, 0.18, 0.055, 0.03);
+    kit.mark(group, 0, 0.025, 0).name = "handle";
+  };
+  var claymore = (kit, group) => {
+    const { M, box: box5 } = kit;
+    for (const i of [-1, 0, 1]) box5(group, 0.075, 0.083, 0.035, M.olive, i * 0.072, 0.12, Math.abs(i) * 0.012, 0, -i * 0.25);
+    for (const [x, z] of [[-0.07, 0.03], [-0.07, -0.03], [0.07, 0.03], [0.07, -0.03]]) box5(group, 4e-3, 0.09, 4e-3, M.metal, x, 0.04, z, x > 0 ? -0.25 : 0.25);
+    kit.mark(group, 0, 0.12, 0).name = "handle";
+  };
+  var flashbang = (kit, group) => {
+    const { M, cylinderY, box: box5 } = kit;
+    cylinderY(group, 0.022, 0.13, M.olive, 0, 0.065, 0, 10);
+    for (let i = 0; i < 4; i++) cylinderY(group, 0.023, 8e-3, M.dark, 0, 0.025 + i * 0.028, 0, 10);
+    cylinderY(group, 0.012, 0.02, M.metal, 0, 0.14, 0);
+    box5(group, 0.01, 0.08, 5e-3, M.metal, 0.024, 0.1, 0, 0.15);
+    kit.mark(group, 0, 0.065, 0).name = "handle";
+  };
+  var BUILDERS3 = {
+    m67: grenade,
+    molotov,
+    pipe_bomb: pipeBomb,
+    dynamite,
+    c4,
+    claymore,
+    flashbang
+  };
+  var EXPLOSIVE_MODEL_IDS = Object.keys(BUILDERS3);
+  var hasExplosiveModel = (explosiveId) => explosiveId in BUILDERS3;
+  function buildExplosiveModel(THREE, explosiveId) {
+    const builder = BUILDERS3[explosiveId];
+    if (!builder) return void 0;
+    const kit = modelKit(THREE);
+    const group = markKitOrigin(kit.group(), { owner: "game-weapons-three", kind: "explosive", id: explosiveId });
+    group.name = explosiveId;
+    builder(kit, group);
+    return group;
+  }
+
   // src/weapon-item-model.ts
   var SHIPPED_WEAPON_ITEM_MODELS = [
     ["wrench", { item: "adjustable_wrench" }],
@@ -49845,8 +50965,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     ["crossbow", { turn: 1 }],
     ["knife", { flip: true }],
     ["meat_cleaver", { flip: true }],
-    ["screwdriver", { flip: true }]
+    ["screwdriver", { flip: true }],
+    // the Itens do Vale Cinzento hammer is a claw hammer: the head and the two-pronged claw
+    ["claw_hammer", { item: "hammer" }]
   ];
+  var hasThrowableModel = (def) => def.action?.kind === "throwable" && def.action.explosive !== void 0 && hasExplosiveModel(def.action.explosive);
+  var buildThrowableModel = (THREE, def) => def.action?.kind === "throwable" && def.action.explosive !== void 0 ? buildExplosiveModel(THREE, def.action.explosive) : void 0;
   var weaponPropsOver = (models) => {
     const itemModelOf = (weaponId, items) => {
       const id = models.get(weaponId)?.item ?? weaponId;
@@ -49862,7 +50986,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       get: (weaponId) => models.get(weaponId),
       itemModelOf,
       buildItemModel,
-      buildModel: (THREE, def, items) => buildItemModel(THREE, def, items) ?? buildProp(THREE, weaponProp(def))
+      buildModel: (THREE, def, items) => buildItemModel(THREE, def, items) ?? buildThrowableModel(THREE, def) ?? buildProp(THREE, weaponProp(def))
     };
   };
   var defaultProps;
@@ -49874,6 +50998,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
 
   // src/box-fx.ts
   var EJECTS_ON_SHOT = /* @__PURE__ */ new Set(["pistol", "smg", "carbine", "rifle", "sniper", "shotgun"]);
+  var SPOUTS = /* @__PURE__ */ new Set(["firearm", "flame", "heat", "extinguisher"]);
   var DROPS_MAGAZINE = /* @__PURE__ */ new Set(["pistol", "smg", "carbine", "rifle", "sniper"]);
   var CYCLES = /* @__PURE__ */ new Set(["shotgun_pump_12", "rifle_bolt_308"]);
   var FALLBACK_ENERGY = 300;
@@ -49908,6 +51033,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     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);
+    const frontOf = new THREE.Vector3();
     const equip = (weapon) => {
       if (model) hand.remove(model);
       model = null;
@@ -49918,6 +51044,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const length2 = new THREE.Box3().setFromObject(model).getSize(v).x;
       rear = new THREE.Box3().setFromObject(model).min.x;
       lengthMetres = length2;
+      frontOf.copy(new THREE.Box3().setFromObject(model).getCenter(v)).setX(rear + length2);
       model.quaternion.copy(pointForward);
       hand.add(model);
       inHand = def.id;
@@ -50018,6 +51145,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         inHand = null;
         hold = null;
       },
+      muzzle() {
+        if (!model || !def || !SPOUTS.has(def.action.kind)) return null;
+        hand.updateMatrixWorld(true);
+        const at3 = model.localToWorld(v.copy(frontOf));
+        const along = v2.set(1, 0, 0).applyQuaternion(model.getWorldQuaternion(q2)).normalize();
+        return { position: [at3.x, at3.y, at3.z], direction: [along.x, along.y, along.z], drawsFlash: false };
+      },
       handTargets() {
         if (!model || !hold) return null;
         hand.updateMatrixWorld(true);
@@ -51618,193 +52752,23 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       options: {
         rpm: 3e3
       }
-    }
-  };
-
-  // src/models/rounded-box.ts
-  var uvAlong = (THREE, faceDirection, normal, uvAxis, projectionAxis, radius, sideLength) => {
-    const arcLength = 2 * Math.PI * radius / 4;
-    const centerLength = Math.max(sideLength - 2 * radius, 0);
-    const halfArc = Math.PI / 4;
-    const projected = new THREE.Vector3().copy(normal);
-    projected[projectionAxis] = 0;
-    projected.normalize();
-    const arcUvRatio = 0.5 * arcLength / (arcLength + centerLength);
-    const arcAngleRatio = 1 - projected.angleTo(faceDirection) / halfArc;
-    if (Math.sign(projected[uvAxis]) === 1) return arcAngleRatio * arcUvRatio;
-    const centerUv = centerLength / (arcLength + centerLength);
-    return centerUv + arcUvRatio + arcUvRatio * (1 - arcAngleRatio);
-  };
-  var FACES = [
-    { direction: [1, 0, 0], u: ["z", "y", false], v: ["y", "z", true] },
-    { direction: [-1, 0, 0], u: ["z", "y", true], v: ["y", "z", true] },
-    { direction: [0, 1, 0], u: ["x", "z", true], v: ["z", "x", false] },
-    { direction: [0, -1, 0], u: ["x", "z", true], v: ["z", "x", true] },
-    { direction: [0, 0, 1], u: ["x", "y", true], v: ["y", "x", true] },
-    { direction: [0, 0, -1], u: ["x", "y", false], v: ["y", "x", true] }
-  ];
-  function createRoundedBoxGeometry(THREE, width, height, depth, segments, radius) {
-    const count = segments * 2 + 1;
-    const rounding = Math.min(width / 2, height / 2, depth / 2, radius);
-    const geometry = new THREE.BoxGeometry(1, 1, 1, count, count, count);
-    const flat2 = geometry.toNonIndexed();
-    geometry.setIndex(null);
-    geometry.setAttribute("position", flat2.attributes.position);
-    geometry.setAttribute("normal", flat2.attributes.normal);
-    geometry.setAttribute("uv", flat2.attributes.uv);
-    const position = new THREE.Vector3();
-    const normal = new THREE.Vector3();
-    const box5 = new THREE.Vector3(width, height, depth).divideScalar(2).subScalar(rounding);
-    const positions2 = geometry.attributes.position.array;
-    const normals = geometry.attributes.normal.array;
-    const uvs = geometry.attributes.uv.array;
-    const faceTriangles = positions2.length / 6;
-    const halfSegment = 0.5 / count;
-    const sides = { x: width, y: height, z: depth };
-    for (let i = 0, j = 0; i < positions2.length; i += 3, j += 2) {
-      position.fromArray(positions2, i);
-      normal.copy(position);
-      normal.x -= Math.sign(normal.x) * halfSegment;
-      normal.y -= Math.sign(normal.y) * halfSegment;
-      normal.z -= Math.sign(normal.z) * halfSegment;
-      normal.normalize();
-      positions2[i] = box5.x * Math.sign(position.x) + normal.x * rounding;
-      positions2[i + 1] = box5.y * Math.sign(position.y) + normal.y * rounding;
-      positions2[i + 2] = box5.z * Math.sign(position.z) + normal.z * rounding;
-      normals[i] = normal.x;
-      normals[i + 1] = normal.y;
-      normals[i + 2] = normal.z;
-      const face = FACES[Math.floor(i / faceTriangles)];
-      if (!face) continue;
-      const direction = new THREE.Vector3(...face.direction);
-      for (const [offset, [uvAxis, projectionAxis, mirrored]] of [[0, face.u], [1, face.v]]) {
-        const value = uvAlong(THREE, direction, normal, uvAxis, projectionAxis, rounding, sides[uvAxis]);
-        uvs[j + offset] = mirrored ? 1 - value : value;
+    },
+    m79: {
+      builder: "breakLauncher",
+      caliber: "40\xD746",
+      length: 730,
+      barrel: 356,
+      options: {
+        stock: "fixed",
+        wood: 1,
+        mag: "none",
+        hg: "wood",
+        hgFrac: 0.4,
+        br: 0.022,
+        hR: 0.05
       }
     }
-    return geometry;
-  }
-
-  // src/models/kit.ts
-  var PI2 = Math.PI;
-  var createMaterials = (THREE) => {
-    const standard = (color2, roughness = 0.7, metalness = 0.2, extra = {}) => new THREE.MeshStandardMaterial({ color: color2, roughness, metalness, ...extra });
-    const basic = (color2, extra = {}) => new THREE.MeshBasicMaterial({ color: color2, ...extra });
-    const additive = { transparent: true, opacity: 0.95, blending: THREE.AdditiveBlending, depthWrite: false };
-    const materials = {
-      metal: standard(3422010, 0.42, 0.75),
-      steel: standard(7106418, 0.32, 0.85),
-      steelL: standard(9080208, 0.28, 0.9),
-      dark: standard(1711133, 0.55, 0.5),
-      poly: standard(2369058, 0.8, 0.05),
-      olive: standard(4936241, 0.8, 0.05),
-      tan: standard(10259043, 0.8, 0.05),
-      wood: standard(4860951, 0.55, 0),
-      woodL: standard(6175263, 0.55, 0),
-      brass: standard(12819013, 0.28, 0.9),
-      copper: standard(11561531, 0.3, 0.85),
-      lead: standard(7171955, 0.5, 0.5),
-      shell: standard(10692380, 0.5, 0.05),
-      glass: standard(8364968, 0.05, 0.1, { transparent: true, opacity: 0.42 }),
-      lens: standard(2311770, 0.05, 0.3, { transparent: true, opacity: 0.9, emissive: 399392 }),
-      rubber: standard(1381653, 0.85, 0),
-      white: standard(13617332, 0.8, 0),
-      hole: standard(526343, 1, 0),
-      bake: standard(5911072, 0.55, 0),
-      rust: standard(7027230, 0.95, 0.3),
-      rustD: standard(4860440, 0.95, 0.25),
-      worn: standard(5593178, 0.6, 0.6),
-      fire: basic(16742946),
-      fire2: basic(16764762),
-      flashA: basic(16757575, additive),
-      flashB: basic(16773568, additive),
-      smokeP: standard(9079430, 1, 0, { transparent: true, opacity: 0.35, depthWrite: false }),
-      /** Launcher paints. */
-      yellow: standard(11570978, 0.6, 0),
-      red: standard(9313300, 0.45, 0.1),
-      redPaint: standard(10691354, 0.35, 0.2),
-      tape: standard(9079944, 0.9, 0),
-      pipe: standard(10115634, 0.35, 0.8),
-      green: standard(3818536, 0.75, 0.05),
-      /** Magazine finishes named by the options. */
-      bakelite: standard(6958620, 0.6, 0),
-      polyMag: standard(2763302, 0.85, 0)
-    };
-    markShared(...Object.values(materials));
-    return materials;
   };
-  var kits = /* @__PURE__ */ new WeakMap();
-  function modelKit(host) {
-    const cached = kits.get(host);
-    if (cached) return cached;
-    const THREE = shapeGeometries(host);
-    const geometries = /* @__PURE__ */ new Map();
-    const shadowed = (mesh3) => {
-      mesh3.castShadow = true;
-      mesh3.receiveShadow = true;
-      return mesh3;
-    };
-    const place = (parent, mesh3, x, y, z) => {
-      mesh3.position.set(x, y, z);
-      parent.add(mesh3);
-      return mesh3;
-    };
-    const kit = {
-      THREE,
-      M: createMaterials(THREE),
-      roundness: null,
-      group: () => new THREE.Group(),
-      box(parent, w, h, d, material, x, y, z, rz = 0, ry = 0, rx = 0) {
-        const radius = Math.min(w, h, d) * (kit.roundness ?? 0.2);
-        const key2 = `${w.toFixed(4)},${h.toFixed(4)},${d.toFixed(4)},${radius.toFixed(5)}`;
-        let geometry = geometries.get(key2);
-        if (!geometry) {
-          geometry = radius > 25e-5 ? createRoundedBoxGeometry(THREE, w, h, d, 2, radius) : new THREE.BoxGeometry(w, h, d);
-          markShared(geometry);
-          geometries.set(key2, geometry);
-        }
-        const mesh3 = place(parent, shadowed(new THREE.Mesh(geometry, material)), x, y, z);
-        mesh3.rotation.set(rx, ry, rz);
-        return mesh3;
-      },
-      cylinderX(parent, radius, length2, material, x, y, z, segments = 16, radiusEnd) {
-        const mesh3 = shadowed(new THREE.Mesh(new THREE.CylinderGeometry(radiusEnd ?? radius, radius, length2, segments), material));
-        mesh3.rotation.z = -PI2 / 2;
-        return place(parent, mesh3, x, y, z);
-      },
-      cylinderY(parent, radius, height, material, x, y, z, segments = 16, radiusEnd) {
-        return place(parent, shadowed(new THREE.Mesh(new THREE.CylinderGeometry(radiusEnd ?? radius, radius, height, segments), material)), x, y, z);
-      },
-      cylinderZ(parent, radius, length2, material, x, y, z, segments = 16) {
-        const mesh3 = shadowed(new THREE.Mesh(new THREE.CylinderGeometry(radius, radius, length2, segments), material));
-        mesh3.rotation.x = PI2 / 2;
-        return place(parent, mesh3, x, y, z);
-      },
-      sphere(parent, radius, material, x, y, z, detail = 1) {
-        return place(parent, shadowed(new THREE.Mesh(new THREE.IcosahedronGeometry(radius, detail), material)), x, y, z);
-      },
-      torus: (parent, geometry, material, x, y, z) => place(parent, shadowed(new THREE.Mesh(geometry, material)), x, y, z),
-      mark(parent, x, y, z) {
-        const object2 = new THREE.Object3D();
-        object2.position.set(x, y, z);
-        parent.add(object2);
-        return object2;
-      },
-      pivot(parent, x = 0, y = 0, z = 0) {
-        const group = new THREE.Group();
-        group.position.set(x, y, z);
-        parent.add(group);
-        return group;
-      }
-    };
-    kits.set(host, kit);
-    return kit;
-  }
-  function heatify(glow, mesh3) {
-    mesh3.material = mesh3.material.clone();
-    glow.push(mesh3);
-    return mesh3;
-  }
 
   // src/models/break-action.ts
   function buildBreakAction(kit, options) {
@@ -51839,6 +52803,509 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return { group, parts };
   }
 
+  // src/models/attachments/muzzle-brake.ts
+  function buildBrake(kit, parent, kind, x, y, barrelRadius, heat = () => void 0) {
+    const { M, box: box5, cylinderX } = kit;
+    const scale = kind === 2 ? 3.2 : 2;
+    const length2 = kind === 2 ? 0.12 : 0.06;
+    heat(cylinderX(parent, barrelRadius * scale, length2, M.dark, x - length2 / 2, y, 0, kind === 2 ? 8 : 16));
+    for (let i = 0; i < 3; i++) box5(parent, length2 * 0.16, barrelRadius * scale * 1.3, barrelRadius * scale * 2.2, M.hole, x - length2 * 0.25 - i * length2 * 0.25, y, 0);
+  }
+
+  // src/models/capture.ts
+  function captured(parent, draw2) {
+    const before = parent.children.length;
+    draw2();
+    return parent.children.slice(before);
+  }
+  function recordFitting(parts, id, parent, draw2) {
+    parts.fittings = { ...parts.fittings, [id]: captured(parent, draw2) };
+  }
+
+  // src/models/details.ts
+  var PI3 = Math.PI;
+  function rail(kit, parent, x, length2, y, z, width, rotationX = 0) {
+    const { M, box: box5 } = kit;
+    const pivot = kit.pivot(parent, 0, y, z);
+    pivot.rotation.x = rotationX;
+    box5(pivot, length2, 5e-3, width, M.dark, x + length2 / 2, 0, 0);
+    const slots = Math.floor(length2 / 95e-4);
+    for (let i = 0; i < slots; i++) box5(pivot, 52e-4, 35e-4, width * 1.12, M.metal, x + 6e-3 + i * 95e-4, 35e-4, 0);
+    return pivot;
+  }
+  function vents(kit, parent, x, length2, y, z, count, height) {
+    for (let i = 0; i < count; i++) kit.box(parent, length2 / count * 0.45, height, 3e-3, kit.M.hole, x + (i + 0.5) * length2 / count, y, z);
+  }
+  function scope(kit, parent, kind, cx, cy, cz = 0) {
+    const { M, box: box5, cylinderX, cylinderY, cylinderZ, THREE } = kit;
+    if (kind === 1) {
+      box5(parent, 0.044, 0.01, 0.028, M.dark, cx, cy + 5e-3, cz);
+      cylinderX(parent, 0.0155, 0.034, M.dark, cx + 4e-3, cy + 0.026, cz, 18);
+      cylinderX(parent, 0.0125, 2e-3, M.lens, cx + 0.022, cy + 0.026, cz, 18);
+      cylinderY(parent, 4e-3, 6e-3, M.dark, cx + 4e-3, cy + 0.044, cz, 10);
+      return;
+    }
+    if (kind === 2) {
+      box5(parent, 0.07, 0.012, 0.026, M.dark, cx, cy + 6e-3, cz);
+      cylinderX(parent, 0.016, 0.1, M.dark, cx - 0.01, cy + 0.032, cz, 18);
+      cylinderX(parent, 0.016, 0.035, M.dark, cx + 0.055, cy + 0.032, cz, 18, 0.02);
+      cylinderX(parent, 0.017, 2e-3, M.lens, cx + 0.073, cy + 0.032, cz, 18);
+      cylinderY(parent, 7e-3, 0.012, M.dark, cx, cy + 0.052, cz, 12);
+      box5(parent, 0.03, 0.01, 0.012, M.dark, cx - 0.01, cy + 0.054, cz);
+      return;
+    }
+    const sleeve = kind === 4 ? 0.2 : 0.32;
+    cylinderX(parent, 0.0135, sleeve * 0.55, M.dark, cx, cy + 0.045, cz, 18);
+    cylinderX(parent, 0.0135, sleeve * 0.25, M.dark, cx + sleeve * 0.36, cy + 0.045, cz, 18, 0.026);
+    cylinderX(parent, 0.026, 0.05, M.dark, cx + sleeve * 0.5, cy + 0.045, cz, 18);
+    cylinderX(parent, 0.024, 2e-3, M.lens, cx + sleeve * 0.5 + 0.026, cy + 0.045, cz, 18);
+    cylinderX(parent, 0.019, 0.06, M.dark, cx - sleeve * 0.38, cy + 0.045, cz, 18, 0.0135);
+    cylinderX(parent, 0.019, 0.035, M.rubber, cx - sleeve * 0.38 - 0.045, cy + 0.045, cz, 18);
+    cylinderX(parent, 0.017, 2e-3, M.lens, cx - sleeve * 0.38 - 0.063, cy + 0.045, cz, 18);
+    cylinderY(parent, 0.01, 0.022, M.dark, cx, cy + 0.066, cz, 14);
+    cylinderY(parent, 0.011, 4e-3, M.metal, cx, cy + 0.078, cz, 14);
+    cylinderZ(parent, 0.01, 0.022, M.dark, cx, cy + 0.045, cz + 0.022, 14);
+    for (const offset of [-0.07, 0.07]) {
+      const ring3 = kit.torus(parent, new THREE.TorusGeometry(0.0155, 3e-3, 8, 20), M.dark, cx + offset, cy + 0.045, cz);
+      ring3.rotation.y = PI3 / 2;
+      box5(parent, 0.016, 0.03, 0.022, M.dark, cx + offset, cy + 0.018, cz);
+    }
+  }
+  var buttpad = (kit, parent, x, y, height, width) => void kit.box(parent, 0.012, height, width, kit.M.rubber, x, y, 0);
+  var swivel = (kit, parent, x, y) => void kit.torus(parent, new kit.THREE.TorusGeometry(6e-3, 15e-4, 6, 12), kit.M.metal, x, y, 0);
+
+  // src/models/attachments/bipod.ts
+  function buildBipod(kit, parent, x, y) {
+    const { M, box: box5, cylinderX } = kit;
+    cylinderX(parent, 8e-3, 0.02, M.dark, x, y, 0, 12);
+    for (const side of [-1, 1]) {
+      const leg = kit.pivot(parent, x, y, side * 0.012);
+      leg.rotation.set(side * 0.15, 0, -0.35);
+      box5(leg, 6e-3, 0.2, 6e-3, M.dark, 0, -0.1, 0);
+      box5(leg, 0.01, 6e-3, 0.01, M.rubber, 0, -0.2, 0);
+    }
+  }
+  var buildBipodModel = ({ kit }) => {
+    const group = kit.group();
+    buildBipod(kit, group, 0, 0);
+    return group;
+  };
+
+  // src/models/rifle-fittings.ts
+  var SCOPE_IDS = { 1: "red_dot", 2: "acog_4x", 3: "scope_3_9x", 4: "scope_6_24x" };
+  function buildFittings(context, gripX) {
+    const { kit, group, parts, options: o, furniture: furn, length: L, receiverStart: x0, receiverEnd: x1, receiverHeight: hR, receiverWidth: wR, barrelRadius: r, barrelY: by } = context;
+    const { M, box: box5, cylinderX, cylinderZ, sphere: sphere2 } = kit;
+    const middle = (x0 + x1) / 2;
+    if (o.scope) recordFitting(parts, SCOPE_IDS[o.scope] ?? "scope", group, () => scope(kit, group, o.scope, middle + 0.03, hR / 2 + (o.rail ? 6e-3 : 0), o.scope === 4 ? -0.02 : 0));
+    if (o.carry) {
+      box5(group, 0.15, 0.026, 0.014, M.metal, middle, hR / 2 + 0.03, 0);
+      box5(group, 0.012, 0.03, 0.014, M.metal, middle + 0.07, hR / 2 + 0.014, 0);
+      box5(group, 0.012, 0.03, 0.014, M.metal, middle - 0.07, hR / 2 + 0.014, 0);
+    }
+    if (o.bipod) recordFitting(parts, "bipod", group, () => buildBipod(kit, group, x1 + (L - x1) * 0.45 + 0.04, by - 0.012));
+    if (o.bolt) {
+      const handle = kit.pivot(group, x1 - 0.045, by, 0);
+      parts.boltHandle = handle;
+      parts.boltHandleRest = handle.position.x;
+      cylinderZ(handle, 42e-4, 0.05, M.steelL, 0, 0, wR / 2 + 0.022, 12);
+      sphere2(handle, 95e-4, M.dark, 0, -4e-3, wR / 2 + 0.048, 1);
+      cylinderX(group, hR * 0.3, 0.03, M.steel, x0 + 5e-3, by, 0, 16);
+    }
+    if (o.lever) {
+      const lever = kit.pivot(group, gripX - 0.02, -hR / 2 - 0.01, 0);
+      parts.lever = lever;
+      box5(lever, 0.11, 6e-3, 0.012, M.metal, 0.055, -0.052, 0);
+      box5(lever, 6e-3, 0.05, 0.012, M.metal, 3e-3, -0.028, 0);
+      box5(lever, 6e-3, 0.05, 0.012, M.metal, 0.108, -0.028, 0);
+      box5(lever, 0.04, 6e-3, 0.012, M.metal, 0.08, -2e-3, 0);
+      box5(group, 0.03, 0.012, 3e-3, M.dark, x1 - 0.04, by, wR / 2 + 1e-3);
+    }
+    if (o.tube) {
+      const tubeLength = (L - x1) * (o.tubeLen || 0.8);
+      cylinderX(group, 0.0105, tubeLength, M.metal, x1 + tubeLength / 2, by - 0.023, 0, 16);
+      cylinderX(group, 0.0125, 0.02, M.dark, x1 + tubeLength + 6e-3, by - 0.023, 0, 16);
+    }
+    if (o.pump) {
+      const pump = kit.pivot(group);
+      parts.pump = pump;
+      box5(pump, 0.17, 0.042, 0.046, furn, x1 + 0.14, by - 0.022, 0);
+      for (let i = 0; i < 8; i++) box5(pump, 6e-3, 0.044, 0.048, M.dark, x1 + 0.07 + i * 0.02, by - 0.022, 0);
+    }
+    if (o.heat) {
+      cylinderX(group, r * 1.75, (L - x1) * 0.7, M.dark, x1 + (L - x1) * 0.4, by, 0, 12);
+      for (let i = 0; i < 10; i++) box5(group, 8e-3, r * 1.5, 4e-3, M.hole, x1 + (L - x1) * (0.1 + i * 0.06), by + r * 0.8, r * 1.5);
+    }
+    if (o.bayo) box5(group, 0.025, 8e-3, 0.01, M.metal, L - 0.07, by - 0.016, 0);
+    if (o.rod) cylinderX(group, 3e-3, (L - x1) * 0.85, M.steel, x1 + (L - x1) * 0.45, by - 0.014, 0, 8);
+  }
+
+  // src/models/rifle-forend.ts
+  var PI4 = Math.PI;
+  function buildForend(context) {
+    const { kit, group, options: o, furniture: furn, length: L, receiverEnd: x1, receiverHeight: hR, receiverWidth: wR, barrelRadius: r, barrelY: by } = context;
+    const { M, box: box5 } = kit;
+    const hasLongScope = (o.scope ?? 0) >= 3;
+    if (!context.isTraditional && o.hg !== "none") {
+      const handguardLength = (L - x1) * (o.hgFrac || 0.5);
+      const hx = x1 + handguardLength / 2;
+      const hh = hR * 0.8;
+      if (o.hg === "rail") {
+        box5(group, handguardLength, hh, wR * 1.04, M.dark, hx, by - 2e-3, 0);
+        rail(kit, group, x1, handguardLength, by + hh / 2, 0, wR * 0.66);
+        rail(kit, group, x1 + 0.01, handguardLength - 0.02, by - 2e-3, wR * 0.54, wR * 0.4, PI4 / 2);
+        rail(kit, group, x1 + 0.01, handguardLength - 0.02, by - 2e-3, -wR * 0.54, wR * 0.4, -PI4 / 2);
+        rail(kit, group, x1 + 0.01, handguardLength - 0.02, by - hh / 2, 0, wR * 0.6, PI4);
+      } else {
+        const material = o.hg === "wood" ? M.wood : furn;
+        if (o.ak) {
+          box5(group, handguardLength, hh * 0.55, wR * 1.08, material, hx, by - hh * 0.22, 0);
+          box5(group, handguardLength * 0.75, hh * 0.35, wR * 0.7, material, hx - handguardLength * 0.1, by + r * 2.2, 0);
+        } else {
+          box5(group, handguardLength, hh, wR * 1.08, material, hx, by - 2e-3, 0);
+          vents(kit, group, x1 + 0.01, handguardLength - 0.02, by + hh * 0.15, wR * 0.54 + 1e-3, Math.round(handguardLength / 0.025), hh * 0.3);
+          vents(kit, group, x1 + 0.01, handguardLength - 0.02, by + hh * 0.15, -wR * 0.54 - 1e-3, Math.round(handguardLength / 0.025), hh * 0.3);
+        }
+      }
+      if (!hasLongScope && !o.rail && o.ak) {
+        box5(group, 0.03, 0.016, wR * 0.6, M.metal, x1 + 0.02, by + r * 2.5 + 0.01, 0);
+        box5(group, 0.012, 4e-3, wR * 0.5, M.dark, x1 + 0.03, by + r * 2.5 + 0.019, 0);
+      }
+    }
+    if (hasLongScope) return;
+    const sightX = L - (o.ak ? 0.06 : 0.08);
+    if (o.ak) {
+      box5(group, 0.022, 0.022, wR * 0.6, M.metal, sightX, by + 8e-3, 0);
+      box5(group, 6e-3, 0.024, 4e-3, M.metal, sightX, by + 0.026, 8e-3);
+      box5(group, 6e-3, 0.024, 4e-3, M.metal, sightX, by + 0.026, -8e-3);
+      box5(group, 3e-3, 0.016, 3e-3, M.dark, sightX, by + 0.022, 0);
+    } else if (!o.rail || o.carry) {
+      box5(group, 0.018, 0.014, wR * 0.55, M.dark, sightX, by + 8e-3, 0);
+      box5(group, 0.012, 0.034, 8e-3, M.dark, sightX, by + 0.03, 0, -0.25);
+    } else box5(group, 0.012, 0.024, 0.012, M.dark, sightX - 0.04, by + hR * 0.4 + 0.012, 0);
+  }
+
+  // src/models/attachments/belt-box.ts
+  function buildBeltBox(kit, belt) {
+    const { M, box: box5, cylinderX } = kit;
+    box5(belt, 0.11, 0.1, 0.08, M.olive, 0, 0, 0);
+    box5(belt, 0.112, 0.012, 0.082, M.dark, 0, 0.046, 0);
+    for (let i = 0; i < 7; i++) {
+      cylinderX(belt, 42e-4, 0.034, M.brass, -0.04 + i * 0.012, 0.07, 0.035, 10);
+      box5(belt, 6e-3, 6e-3, 0.012, M.metal, -0.04 + i * 0.012, 0.066, 0.035);
+    }
+  }
+
+  // src/models/attachments/drum.ts
+  function buildDrum(kit, magazine) {
+    const { M, box: box5, cylinderZ } = kit;
+    cylinderZ(magazine, 0.075, 0.07, M.dark, 0.02, -0.085, 0, 22);
+    cylinderZ(magazine, 0.05, 0.074, M.metal, 0.02, -0.085, 0, 18);
+    box5(magazine, 0.05, 0.04, 0.03, M.dark, 0, -0.02, 0);
+  }
+
+  // src/models/helical-magazine.ts
+  var PI5 = Math.PI;
+  var LENGTH = 0.26;
+  var RADIUS = 0.026;
+  var TURNS = 11;
+  function buildHelicalMagazine(context) {
+    const { kit, group, parts, receiverEnd, barrelY, barrelRadius } = context;
+    const { M, cylinderX, box: box5 } = kit;
+    const x = receiverEnd + LENGTH / 2 + 0.02;
+    const y = barrelY - barrelRadius - RADIUS - 0.012;
+    const magazine = kit.pivot(group, x, y, 0);
+    parts.mag = magazine;
+    cylinderX(magazine, RADIUS, LENGTH, M.dark, 0, 0, 0, 20);
+    cylinderX(magazine, RADIUS * 1.06, 0.01, M.metal, -LENGTH / 2, 0, 0, 20);
+    cylinderX(magazine, RADIUS * 1.06, 0.01, M.metal, LENGTH / 2, 0, 0, 20);
+    for (let i = 0; i < TURNS; i++) box5(magazine, 0.012, RADIUS * 2.15, 0.014, M.metal, -LENGTH / 2 + (i + 0.5) * LENGTH / TURNS, 0, 0, 0, 0, i * PI5 / 4);
+    box5(magazine, 0.05, 0.03, 0.03, M.dark, -LENGTH / 2 - 0.02, RADIUS * 0.4, 0);
+    parts.magDrop = 0.16;
+    return x;
+  }
+
+  // src/models/rifle-controls.ts
+  function buildGrip(context) {
+    const { kit, group, parts, options: o, furniture: furn, receiverStart: x0, receiverHeight: hR, receiverWidth: wR } = context;
+    const { M, box: box5 } = kit;
+    const gx = x0 + (o.gripAt || 0.07);
+    if (!context.isTraditional && o.grip !== "none") {
+      const grip = kit.pivot(group, gx - 0.012, -hR / 2 - 0.046, 0);
+      grip.rotation.z = -0.3;
+      parts.grip = grip;
+      box5(grip, 0.032, 0.105, 0.028, furn, 0, 0, 0);
+      for (let i = 0; i < 3; i++) box5(grip, 6e-3, 0.012, 0.026, furn, 0.017, 0.022 - i * 0.02, 0);
+      box5(grip, 0.034, 8e-3, 0.03, furn, 0, -0.052, 0);
+    }
+    box5(group, 0.06, 4e-3, 0.01, M.metal, gx + 0.03, -hR / 2 - 0.024, 0);
+    box5(group, 4e-3, 0.022, 0.01, M.metal, gx + 0.06, -hR / 2 - 0.013, 0);
+    parts.trigger = box5(group, 4e-3, 0.016, 4e-3, M.dark, gx + 0.024, -hR / 2 - 0.012, 0, 0.15);
+    if (o.sel) parts.safety = box5(group, 0.016, 5e-3, 3e-3, M.dark, gx + 5e-3, -hR * 0.15, -wR / 2 - 2e-3, 0.4);
+    return gx;
+  }
+  function buildMagazine(context, gx) {
+    const { kit, group, parts, options: o, receiverStart: x0, receiverHeight: hR, receiverWidth: wR, receiverLength: RL } = context;
+    const { M, box: box5 } = kit;
+    if (o.mag === "helical") return buildHelicalMagazine(context);
+    const mx = o.magAt != null ? x0 + o.magAt : gx + 0.075;
+    const scale = o.magLen || 1;
+    const magazine = kit.pivot(group, mx, -hR / 2, 0);
+    parts.mag = magazine;
+    const finish = o.magMat === "bakelite" ? M.bakelite : o.magMat === "poly" ? M.polyMag : void 0;
+    if (o.mag === "curved") {
+      let px = 0;
+      let py = 0;
+      const material = finish ?? M.metal;
+      for (const angle of [0.06, 0.22, 0.38]) {
+        const length2 = 0.07 * scale;
+        const cx = px + Math.sin(angle) * length2 / 2;
+        const cy = py - Math.cos(angle) * length2 / 2;
+        box5(magazine, 0.052, length2 + 4e-3, 0.024, material, cx, cy, 0, angle);
+        box5(magazine, 0.04, length2 * 0.8, 0.026, M.dark, cx, cy, 0, angle);
+        px += Math.sin(angle) * length2;
+        py -= Math.cos(angle) * length2;
+      }
+      box5(magazine, 0.058, 8e-3, 0.028, material, px, py, 0, 0.38);
+      parts.magDrop = 0.07 * scale * 3 + 0.04;
+    } else if (o.mag === "box") {
+      const length2 = 0.13 * scale;
+      const curve = o.curve || 0;
+      const segment = length2 / 3;
+      const material = finish ?? M.dark;
+      let px = 0;
+      let py = 0;
+      let angle = 0.08;
+      for (let i = 0; i < 3; i++) {
+        angle = 0.08 + curve * i;
+        const cx = px + Math.sin(angle) * segment / 2;
+        const cy = py - Math.cos(angle) * segment / 2;
+        box5(magazine, 0.05, segment + 4e-3, 0.024, material, cx, cy, 0, angle);
+        box5(magazine, 0.04, 3e-3, 0.026, M.metal, cx, cy, 0, angle);
+        px += Math.sin(angle) * segment;
+        py -= Math.cos(angle) * segment;
+      }
+      box5(magazine, 0.056, 7e-3, 0.028, material, px, py - 2e-3, 0, angle);
+      parts.magDrop = length2 + 0.03;
+    } else if (o.mag === "drum") {
+      buildDrum(kit, magazine);
+      parts.magDrop = 0.2;
+    } else if (o.mag === "internal") {
+      box5(group, 0.08, 0.025, 0.03, context.isTraditional ? context.furniture : M.metal, mx, -hR / 2 - 0.012, 0);
+      parts.mag = null;
+    } else parts.mag = null;
+    if (o.mag === "belt") {
+      const belt = kit.pivot(group, mx + 0.02, -hR / 2 - 0.05, -0.045);
+      parts.belt = belt;
+      buildBeltBox(kit, belt);
+      const cover = kit.pivot(group, x0 + 0.01, hR / 2, 0);
+      parts.cover = cover;
+      box5(cover, RL - 0.03, 0.014, wR * 1.05, M.metal, (RL - 0.03) / 2, 7e-3, 0);
+      box5(cover, 0.02, 0.012, wR * 0.6, M.dark, RL - 0.04, 0.016, 0);
+    }
+    return mx;
+  }
+
+  // src/models/rifle-stock.ts
+  function buildStock(context, magazineX) {
+    const { kit, group, options: o, furniture: furn, length: L, stockLength: S, receiverStart: x0, receiverEnd: x1, receiverHeight: hR } = context;
+    const { M, box: box5, cylinderX } = kit;
+    if (context.isTraditional) {
+      buttpad(kit, group, 6e-3, -0.04, 0.13, 0.038);
+      box5(group, 0.03, 0.13, 0.038, furn, 0.024, -0.04, 0);
+      box5(group, S, 0.055, 0.034, furn, S / 2, -0.012, 0, 0.06);
+      box5(group, 0.09, 0.05, 0.032, furn, x0 - 0.02, -0.035, 0, 0.25);
+      const forendLength = x1 - x0 + (L - x1) * (o.fore ?? 0.62);
+      if (forendLength > 0) box5(group, forendLength, 0.045, 0.04, furn, x0 + forendLength / 2, -hR / 2 + 4e-3, 0);
+      if (o.stock === "straight") box5(group, 0.15, 0.04, 0.035, furn, x1 + 0.08, -hR / 2, 0);
+      box5(group, 0.04, 4e-3, 0.03, M.metal, magazineX, -hR / 2 - 0.022, 0);
+      swivel(kit, group, 0.2, -0.08);
+      swivel(kit, group, x1 + (L - x1) * 0.45, -hR / 2 - 0.03);
+      if (o.bands) for (const fraction of [0.35, 0.75]) cylinderX(group, 0.024, 8e-3, M.metal, x1 + (L - x1) * fraction * (o.fore || 0.62), -4e-3, 0, 16);
+    } else if (o.stock === "fixed" || o.stock === "wood") {
+      box5(group, S, 0.05, 0.03, furn, S / 2, -8e-3, 0, 0.05);
+      box5(group, 0.03, 0.13, 0.036, furn, 0.022, -0.035, 0);
+      buttpad(kit, group, 4e-3, -0.035, 0.13, 0.036);
+      if (o.stock === "wood") box5(group, S * 0.6, 0.03, 0.028, furn, S * 0.55, -0.045, 0, 0.2);
+      swivel(kit, group, 0.08, -0.09);
+    } else if (o.stock === "skeleton") {
+      box5(group, S, 0.014, 0.026, furn, S / 2, 0.012, 0, 0.03);
+      box5(group, S, 0.014, 0.026, furn, S / 2, -0.05, 0, -0.08);
+      box5(group, 0.03, 0.12, 0.034, furn, 0.02, -0.025, 0);
+      buttpad(kit, group, 4e-3, -0.025, 0.12, 0.034);
+    } else if (o.stock === "retract") {
+      cylinderX(group, 0.013, S, M.metal, S / 2, 0, 0, 16);
+      for (let i = 0; i < 5; i++) box5(group, 3e-3, 3e-3, 8e-3, M.dark, S * 0.2 + i * 0.015, -0.013, 0);
+      box5(group, 0.034, 0.11, 0.036, furn, 0.02, -0.025, 0);
+      box5(group, S * 0.55, 0.032, 0.03, furn, S * 0.35, 0, 0);
+      buttpad(kit, group, 3e-3, -0.025, 0.11, 0.036);
+    } else if (o.stock === "fold") {
+      box5(group, S, 6e-3, 6e-3, M.metal, S / 2, 0.01, 0.012);
+      box5(group, S, 6e-3, 6e-3, M.metal, S / 2, -0.04, 0.012, -0.12);
+      box5(group, 0.012, 0.1, 0.03, M.metal, 6e-3, -0.02, 0.012);
+    }
+  }
+
+  // src/models/rifle.ts
+  var PI6 = Math.PI;
+  function buildReceiver(context) {
+    const { kit, group, parts, options: o, length: L, receiverStart: x0, receiverEnd: x1, receiverHeight: hR, receiverWidth: wR, receiverLength: RL, barrelY: by } = context;
+    const { M, box: box5, cylinderX, cylinderY, cylinderZ, sphere: sphere2 } = kit;
+    const receiverMaterial = o.tan ? M.tan : M.metal;
+    const middle = (x0 + x1) / 2;
+    if (o.round) {
+      cylinderX(group, hR * 0.36, RL, M.steel, middle, by, 0, 20);
+      cylinderX(group, hR * 0.32, 0.05, M.steel, x0 - 0.01, by, 0, 18);
+    } else if (o.ar) {
+      box5(group, RL, hR * 0.5, wR, receiverMaterial, middle, hR * 0.25, 0);
+      box5(group, RL * 0.92, hR * 0.52, wR * 0.96, receiverMaterial, middle - RL * 0.02, -hR * 0.24, 0);
+      box5(group, 0.05, 0.03, wR * 1.15, receiverMaterial, x0 + RL * 0.62, -hR * 0.5 - 0.01, 0);
+      cylinderZ(group, 6e-3, 0.012, M.metal, x1 - 0.03, hR * 0.28, wR / 2 + 6e-3, 12);
+      box5(group, 0.012, 0.01, 0.012, M.metal, x1 - 0.05, hR * 0.12, wR / 2 + 6e-3);
+      box5(group, 0.03, 8e-3, 0.012, M.dark, x0 + 0.02, hR / 2 + 4e-3, 0);
+      box5(group, 0.012, 6e-3, 4e-3, M.dark, x0 + RL * 0.55, -hR * 0.15, -wR / 2 - 2e-3);
+    } else box5(group, RL, hR, wR, receiverMaterial, middle, 0, 0);
+    if (o.ak) {
+      box5(group, RL * 0.86, hR * 0.28, wR * 0.95, M.metal, middle - 8e-3, hR / 2 + 4e-3, 0);
+      for (let i = 0; i < 3; i++) box5(group, 4e-3, hR * 0.3, wR * 0.97, M.dark, x0 + RL * 0.25 + i * 0.02, hR / 2 + 4e-3, 0);
+      box5(group, RL * 0.5, 0.012, 3e-3, M.metal, x0 + RL * 0.55, -hR * 0.02, wR / 2 + 15e-4, -0.05);
+      box5(group, 0.012, 0.014, 3e-3, M.dark, x0 + RL * 0.32, -hR * 0.05, wR / 2 + 2e-3);
+    }
+    if (o.g3) {
+      cylinderX(group, 9e-3, (L - x1) * 0.6, M.metal, x1 + (L - x1) * 0.28, hR * 0.48, 0, 14);
+      box5(group, 0.012, 0.024, 8e-3, M.dark, x1 + (L - x1) * 0.5, hR * 0.48, -0.012);
+      cylinderY(group, 0.012, 0.016, M.dark, x0 + 0.03, hR / 2 + 8e-3, 0, 12);
+    }
+    const ejectX = x1 - (o.ejectBack || 0.07);
+    const ejectY = o.ar ? hR * 0.2 : by;
+    box5(group, 0.05, hR * 0.36, 4e-3, M.hole, ejectX, ejectY, wR / 2 - 4e-4);
+    const bolt = kit.pivot(group);
+    parts.bolt = bolt;
+    parts.stroke = Math.min(0.1, RL * 0.32);
+    box5(bolt, 0.044, hR * 0.26, 6e-3, M.steelL, ejectX, ejectY, wR / 2 - 12e-4);
+    if (o.charge) {
+      box5(bolt, 0.012, 0.01, 0.03, M.metal, ejectX + 0.04, ejectY + 4e-3, wR / 2 + 0.012);
+      sphere2(bolt, 65e-4, M.metal, ejectX + 0.04, ejectY + 4e-3, wR / 2 + 0.028, 1);
+    }
+    if (o.ar) box5(group, 0.012, 0.016, 6e-3, receiverMaterial, ejectX - 0.03, ejectY + 4e-3, wR / 2 + 4e-3);
+    if (o.rail) rail(kit, group, x0 - 5e-3, RL + 0.07, hR / 2 + (o.ar ? 0 : 3e-3), 0, wR * 0.68);
+  }
+  function buildBarrel(context) {
+    const { kit, group, parts, options: o, length: L, barrelLength: Bl, receiverEnd: x1, barrelRadius: r, barrelY: by } = context;
+    const { M, box: box5, cylinderX } = kit;
+    heatify(parts.glow, cylinderX(group, r, Bl, M.metal, L - Bl / 2, by, 0, 16));
+    if (o.jacket) {
+      cylinderX(group, r * 2, (L - x1) * 0.6, M.dark, x1 + (L - x1) * 0.3, by, 0, 16);
+      for (let i = 0; i < 6; i++) cylinderX(group, r * 2.15, 4e-3, M.metal, x1 + (L - x1) * (0.05 + i * 0.09), by, 0, 16);
+    }
+    if (o.gas) cylinderX(group, r * 0.75, (L - x1) * 0.55, M.metal, x1 + (L - x1) * 0.3, by + r * 2.2, 0, 14);
+    if (o.brake) {
+      const kind = o.brake === 2 ? 2 : 1;
+      recordFitting(parts, kind === 2 ? "muzzle_brake_heavy" : "muzzle_brake", group, () => buildBrake(kit, group, kind, L, by, r, (body) => void heatify(parts.glow, body)));
+    } else if (!o.noFH) {
+      recordFitting(parts, "muzzle_default", group, () => {
+        heatify(parts.glow, cylinderX(group, r * 1.45, 0.042, M.dark, L - 0.021, by, 0, 16));
+        for (let i = 0; i < 4; i++) {
+          const angle = i * PI6 / 2 + PI6 / 4;
+          box5(group, 0.026, 25e-4, 4e-3, M.hole, L - 0.02, by + Math.cos(angle) * r * 1.42, Math.sin(angle) * r * 1.42, 0, 0, angle);
+        }
+      });
+    }
+    cylinderX(group, r * 0.55, 4e-3, M.hole, L + 5e-4, by, 0, 12);
+  }
+  var familyOf = (o) => {
+    if (o.mag === "belt") return "belt";
+    if (o.pump) return "pump";
+    if (o.lever) return "lever";
+    if (o.tube) return "semi12";
+    if (o.bolt) return o.mag === "box" ? "boltmag" : "bolt";
+    return o.mag === "internal" ? "semiint" : "rifle";
+  };
+  function buildRifle(kit, options) {
+    const { M } = kit;
+    const group = kit.group();
+    const parts = { family: "rifle", glow: [] };
+    const length2 = (options.L ?? 0) / 1e3;
+    const barrelLength = (options.B ?? 0) / 1e3;
+    const isTraditional = options.stock === "trad" || options.stock === "straight";
+    const stockLength = options.stock === "none" ? 0 : options.stockLen || Math.min(0.36, Math.max(0.2, 0.3 * length2));
+    const receiverStart = stockLength;
+    const receiverEnd = Math.max(receiverStart + 0.12, length2 - barrelLength * 0.92);
+    const receiverHeight = options.hR || 0.06;
+    const context = {
+      kit,
+      group,
+      parts,
+      options,
+      furniture: options.wood ? M.wood : options.olive ? M.olive : options.tan ? M.tan : M.poly,
+      isTraditional,
+      length: length2,
+      barrelLength,
+      stockLength,
+      receiverStart,
+      receiverEnd,
+      receiverHeight,
+      receiverWidth: options.wR || 0.034,
+      barrelRadius: options.br || 85e-4,
+      barrelY: receiverHeight * 0.15,
+      receiverLength: receiverEnd - receiverStart
+    };
+    buildReceiver(context);
+    buildBarrel(context);
+    buildForend(context);
+    const gripX = buildGrip(context);
+    const magazineX = buildMagazine(context, gripX);
+    parts.stockMeshes = context.isTraditional ? [] : captured(group, () => buildStock(context, magazineX));
+    if (context.isTraditional) buildStock(context, magazineX);
+    buildFittings(context, gripX);
+    const hasHandguard = !context.isTraditional && options.hg !== "none";
+    parts.frames = {
+      length: length2,
+      barrelY: context.barrelY,
+      barrelRadius: context.barrelRadius,
+      receiverStart,
+      receiverEnd,
+      receiverHeight,
+      receiverWidth: context.receiverWidth,
+      handguardEnd: receiverEnd + (length2 - receiverEnd) * (hasHandguard ? options.hgFrac || 0.5 : 0.4),
+      magazineX,
+      gripX,
+      hasRail: Boolean(options.rail)
+    };
+    const { barrelY: by, receiverWidth: wR } = context;
+    const ejectX = receiverEnd - (options.ejectBack || 0.07);
+    const ejectY = options.ar ? receiverHeight * 0.2 : by;
+    parts.muzzle = kit.mark(group, length2 + 0.01, by, 0);
+    parts.eject = kit.mark(group, ejectX, ejectY, wR / 2 + 6e-3);
+    parts.loadPort = kit.mark(group, receiverEnd - 0.05, -receiverHeight / 2 - 4e-3, 0);
+    parts.topLoad = kit.mark(group, ejectX, receiverHeight / 2 + 4e-3, 0);
+    parts.family = familyOf(options);
+    return { group, parts };
+  }
+
+  // src/models/break-launcher.ts
+  function buildBreakLauncher(kit, options) {
+    const built2 = buildRifle(kit, options);
+    const { group, parts } = built2;
+    const frames = parts.frames;
+    if (!frames) return built2;
+    const hingeY = frames.barrelY - frames.barrelRadius;
+    const barrels = kit.pivot(group, frames.receiverEnd, hingeY, 0);
+    group.updateMatrixWorld(true);
+    const centre = new kit.THREE.Vector3();
+    for (const child of [...group.children]) {
+      if (child === barrels) continue;
+      const mesh3 = child;
+      const isAhead = mesh3.isMesh ? new kit.THREE.Box3().setFromObject(mesh3).getCenter(centre).x > frames.receiverEnd : child === parts.muzzle;
+      if (isAhead) barrels.attach(child);
+    }
+    parts.barrels = barrels;
+    parts.breech = [kit.mark(barrels, 4e-3, frames.barrelY - hingeY, 0)];
+    parts.eject = parts.breech[0];
+    parts.family = "break";
+    return built2;
+  }
+
   // src/models/attachments/mount-frames.ts
   var DEFAULT_BARREL_RADIUS = 85e-4;
   var DEFAULT_RECEIVER_WIDTH = 0.034;
@@ -51913,58 +53380,6 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
   }
 
-  // src/models/details.ts
-  var PI3 = Math.PI;
-  function rail(kit, parent, x, length2, y, z, width, rotationX = 0) {
-    const { M, box: box5 } = kit;
-    const pivot = kit.pivot(parent, 0, y, z);
-    pivot.rotation.x = rotationX;
-    box5(pivot, length2, 5e-3, width, M.dark, x + length2 / 2, 0, 0);
-    const slots = Math.floor(length2 / 95e-4);
-    for (let i = 0; i < slots; i++) box5(pivot, 52e-4, 35e-4, width * 1.12, M.metal, x + 6e-3 + i * 95e-4, 35e-4, 0);
-    return pivot;
-  }
-  function vents(kit, parent, x, length2, y, z, count, height) {
-    for (let i = 0; i < count; i++) kit.box(parent, length2 / count * 0.45, height, 3e-3, kit.M.hole, x + (i + 0.5) * length2 / count, y, z);
-  }
-  function scope(kit, parent, kind, cx, cy, cz = 0) {
-    const { M, box: box5, cylinderX, cylinderY, cylinderZ, THREE } = kit;
-    if (kind === 1) {
-      box5(parent, 0.044, 0.01, 0.028, M.dark, cx, cy + 5e-3, cz);
-      cylinderX(parent, 0.0155, 0.034, M.dark, cx + 4e-3, cy + 0.026, cz, 18);
-      cylinderX(parent, 0.0125, 2e-3, M.lens, cx + 0.022, cy + 0.026, cz, 18);
-      cylinderY(parent, 4e-3, 6e-3, M.dark, cx + 4e-3, cy + 0.044, cz, 10);
-      return;
-    }
-    if (kind === 2) {
-      box5(parent, 0.07, 0.012, 0.026, M.dark, cx, cy + 6e-3, cz);
-      cylinderX(parent, 0.016, 0.1, M.dark, cx - 0.01, cy + 0.032, cz, 18);
-      cylinderX(parent, 0.016, 0.035, M.dark, cx + 0.055, cy + 0.032, cz, 18, 0.02);
-      cylinderX(parent, 0.017, 2e-3, M.lens, cx + 0.073, cy + 0.032, cz, 18);
-      cylinderY(parent, 7e-3, 0.012, M.dark, cx, cy + 0.052, cz, 12);
-      box5(parent, 0.03, 0.01, 0.012, M.dark, cx - 0.01, cy + 0.054, cz);
-      return;
-    }
-    const sleeve = kind === 4 ? 0.2 : 0.32;
-    cylinderX(parent, 0.0135, sleeve * 0.55, M.dark, cx, cy + 0.045, cz, 18);
-    cylinderX(parent, 0.0135, sleeve * 0.25, M.dark, cx + sleeve * 0.36, cy + 0.045, cz, 18, 0.026);
-    cylinderX(parent, 0.026, 0.05, M.dark, cx + sleeve * 0.5, cy + 0.045, cz, 18);
-    cylinderX(parent, 0.024, 2e-3, M.lens, cx + sleeve * 0.5 + 0.026, cy + 0.045, cz, 18);
-    cylinderX(parent, 0.019, 0.06, M.dark, cx - sleeve * 0.38, cy + 0.045, cz, 18, 0.0135);
-    cylinderX(parent, 0.019, 0.035, M.rubber, cx - sleeve * 0.38 - 0.045, cy + 0.045, cz, 18);
-    cylinderX(parent, 0.017, 2e-3, M.lens, cx - sleeve * 0.38 - 0.063, cy + 0.045, cz, 18);
-    cylinderY(parent, 0.01, 0.022, M.dark, cx, cy + 0.066, cz, 14);
-    cylinderY(parent, 0.011, 4e-3, M.metal, cx, cy + 0.078, cz, 14);
-    cylinderZ(parent, 0.01, 0.022, M.dark, cx, cy + 0.045, cz + 0.022, 14);
-    for (const offset of [-0.07, 0.07]) {
-      const ring3 = kit.torus(parent, new THREE.TorusGeometry(0.0155, 3e-3, 8, 20), M.dark, cx + offset, cy + 0.045, cz);
-      ring3.rotation.y = PI3 / 2;
-      box5(parent, 0.016, 0.03, 0.022, M.dark, cx + offset, cy + 0.018, cz);
-    }
-  }
-  var buttpad = (kit, parent, x, y, height, width) => void kit.box(parent, 0.012, height, width, kit.M.rubber, x, y, 0);
-  var swivel = (kit, parent, x, y) => void kit.torus(parent, new kit.THREE.TorusGeometry(6e-3, 15e-4, 6, 12), kit.M.metal, x, y, 0);
-
   // src/models/bullpup.ts
   function buildBullpup(kit, options) {
     const { M, box: box5, cylinderX } = kit;
@@ -52090,7 +53505,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
 
   // src/models/launcher-rounds.ts
-  var PI4 = Math.PI;
+  var PI7 = Math.PI;
   function buildRocketGrenade(kit) {
     const { M, cylinderX } = kit;
     const round5 = kit.group();
@@ -52120,7 +53535,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     cylinderX(rocket, diameter, 0.12, M.olive, 0.36, 0, 0, 18, diameter * 0.25);
     for (let i = 0; i < 4; i++) {
       const fin = box5(rocket, 0.06, 2e-3, diameter * 1.4, M.metal, -0.17, 0, 0);
-      fin.rotation.x = i * PI4 / 4;
+      fin.rotation.x = i * PI7 / 4;
     }
     return rocket;
   }
@@ -52258,7 +53673,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
 
   // src/models/m134.ts
-  var PI5 = Math.PI;
+  var PI8 = Math.PI;
   var BARRELS = 6;
   var CLUSTER_RADIUS = 0.03;
   var BARREL_RADIUS = 78e-4;
@@ -52270,7 +53685,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const length2 = BARREL_END - 0.3;
     let heated;
     for (let i = 0; i < BARRELS; i++) {
-      const angle = i * 2 * PI5 / BARRELS;
+      const angle = i * 2 * PI8 / BARRELS;
       const y = Math.cos(angle) * CLUSTER_RADIUS;
       const z = Math.sin(angle) * CLUSTER_RADIUS;
       const barrel = cylinderX(barrels, BARREL_RADIUS, length2, M.metal, 0.3 + length2 / 2, y, z, 14);
@@ -52419,7 +53834,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
 
   // src/models/pistol-slide.ts
-  var PI6 = Math.PI;
+  var PI9 = Math.PI;
   function buildSlide(kit, slide2, parts, options, style, size, metal2) {
     const { M, box: box5, cylinderX } = kit;
     const { length: L, width: w } = size;
@@ -52447,8 +53862,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     if (style.tri) {
       const tube2 = new kit.THREE.Mesh(new kit.THREE.CylinderGeometry(0.016, 0.016, L * 0.6, 3), metal2);
       tube2.castShadow = tube2.receiveShadow = true;
-      tube2.rotation.set(0, 0, -PI6 / 2);
-      tube2.rotateY(PI6 / 6);
+      tube2.rotation.set(0, 0, -PI9 / 2);
+      tube2.rotateY(PI9 / 6);
       tube2.position.set(L * 0.7, slideHeight * 0.08, 0);
       slide2.add(tube2);
       heatify(parts.glow, tube2);
@@ -52500,7 +53915,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   };
 
   // src/models/pistol.ts
-  var PI7 = Math.PI;
+  var PI10 = Math.PI;
   function buildFrame2(kit, group, parts, options, style, size, materials) {
     const { M, box: box5, cylinderZ, sphere: sphere2 } = kit;
     const { length: L, height: h, width: w } = size;
@@ -52592,8 +54007,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       box5(group, 4e-3, 0.03, 9e-3, frameMetal, gx + 0.073, ty - 0.02, 0, 0.2);
       box5(group, 8e-3, 6e-3, 9e-3, frameMetal, gx + 0.074, ty - 0.037, 0, 0.4);
     } else {
-      const guard = kit.torus(group, new kit.THREE.TorusGeometry(0.019, 22e-4, 6, 16, PI7), frameMetal, gx + 0.05, ty - 0.014, 0);
-      guard.rotation.z = PI7;
+      const guard = kit.torus(group, new kit.THREE.TorusGeometry(0.019, 22e-4, 6, 16, PI10), frameMetal, gx + 0.05, ty - 0.014, 0);
+      guard.rotation.z = PI10;
       guard.scale.set(1.2, 1, 1);
     }
     const isGlock = options.st === "glock" || !options.st;
@@ -52617,7 +54032,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
 
   // src/models/revolver.ts
-  var PI8 = Math.PI;
+  var PI11 = Math.PI;
   var DEFAULT_CHAMBERS = 6;
   function buildRevolver(kit, options) {
     const { M, box: box5, cylinderX } = kit;
@@ -52635,12 +54050,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     parts.cylinder = cylinder2;
     cylinderX(cylinder2, 0.0215, 0.042, metal2, 0, 0, 0, 24);
     for (let i = 0; i < chambers; i++) {
-      const angle = i * 2 * PI8 / chambers;
+      const angle = i * 2 * PI11 / chambers;
       box5(cylinder2, 0.026, 5e-3, 5e-3, M.dark, 0, Math.cos(angle) * 0.0205, Math.sin(angle) * 0.0205, 0, 0, angle);
     }
     parts.chambers = [];
     for (let i = 0; i < chambers; i++) {
-      const angle = i * 2 * PI8 / chambers + PI8 / chambers;
+      const angle = i * 2 * PI11 / chambers + PI11 / chambers;
       parts.chambers.push(kit.mark(cylinder2, -0.022, Math.cos(angle) * 0.013, Math.sin(angle) * 0.013));
       cylinderX(cylinder2, 46e-4, 2e-3, M.brass, -0.0215, Math.cos(angle) * 0.013, Math.sin(angle) * 0.013, 12);
     }
@@ -52665,434 +54080,6 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return { group, parts };
   }
 
-  // src/models/attachments/muzzle-brake.ts
-  function buildBrake(kit, parent, kind, x, y, barrelRadius, heat = () => void 0) {
-    const { M, box: box5, cylinderX } = kit;
-    const scale = kind === 2 ? 3.2 : 2;
-    const length2 = kind === 2 ? 0.12 : 0.06;
-    heat(cylinderX(parent, barrelRadius * scale, length2, M.dark, x - length2 / 2, y, 0, kind === 2 ? 8 : 16));
-    for (let i = 0; i < 3; i++) box5(parent, length2 * 0.16, barrelRadius * scale * 1.3, barrelRadius * scale * 2.2, M.hole, x - length2 * 0.25 - i * length2 * 0.25, y, 0);
-  }
-
-  // src/models/capture.ts
-  function captured(parent, draw2) {
-    const before = parent.children.length;
-    draw2();
-    return parent.children.slice(before);
-  }
-  function recordFitting(parts, id, parent, draw2) {
-    parts.fittings = { ...parts.fittings, [id]: captured(parent, draw2) };
-  }
-
-  // src/models/attachments/bipod.ts
-  function buildBipod(kit, parent, x, y) {
-    const { M, box: box5, cylinderX } = kit;
-    cylinderX(parent, 8e-3, 0.02, M.dark, x, y, 0, 12);
-    for (const side of [-1, 1]) {
-      const leg = kit.pivot(parent, x, y, side * 0.012);
-      leg.rotation.set(side * 0.15, 0, -0.35);
-      box5(leg, 6e-3, 0.2, 6e-3, M.dark, 0, -0.1, 0);
-      box5(leg, 0.01, 6e-3, 0.01, M.rubber, 0, -0.2, 0);
-    }
-  }
-  var buildBipodModel = ({ kit }) => {
-    const group = kit.group();
-    buildBipod(kit, group, 0, 0);
-    return group;
-  };
-
-  // src/models/rifle-fittings.ts
-  var SCOPE_IDS = { 1: "red_dot", 2: "acog_4x", 3: "scope_3_9x", 4: "scope_6_24x" };
-  function buildFittings(context, gripX) {
-    const { kit, group, parts, options: o, furniture: furn, length: L, receiverStart: x0, receiverEnd: x1, receiverHeight: hR, receiverWidth: wR, barrelRadius: r, barrelY: by } = context;
-    const { M, box: box5, cylinderX, cylinderZ, sphere: sphere2 } = kit;
-    const middle = (x0 + x1) / 2;
-    if (o.scope) recordFitting(parts, SCOPE_IDS[o.scope] ?? "scope", group, () => scope(kit, group, o.scope, middle + 0.03, hR / 2 + (o.rail ? 6e-3 : 0), o.scope === 4 ? -0.02 : 0));
-    if (o.carry) {
-      box5(group, 0.15, 0.026, 0.014, M.metal, middle, hR / 2 + 0.03, 0);
-      box5(group, 0.012, 0.03, 0.014, M.metal, middle + 0.07, hR / 2 + 0.014, 0);
-      box5(group, 0.012, 0.03, 0.014, M.metal, middle - 0.07, hR / 2 + 0.014, 0);
-    }
-    if (o.bipod) recordFitting(parts, "bipod", group, () => buildBipod(kit, group, x1 + (L - x1) * 0.45 + 0.04, by - 0.012));
-    if (o.bolt) {
-      const handle = kit.pivot(group, x1 - 0.045, by, 0);
-      parts.boltHandle = handle;
-      parts.boltHandleRest = handle.position.x;
-      cylinderZ(handle, 42e-4, 0.05, M.steelL, 0, 0, wR / 2 + 0.022, 12);
-      sphere2(handle, 95e-4, M.dark, 0, -4e-3, wR / 2 + 0.048, 1);
-      cylinderX(group, hR * 0.3, 0.03, M.steel, x0 + 5e-3, by, 0, 16);
-    }
-    if (o.lever) {
-      const lever = kit.pivot(group, gripX - 0.02, -hR / 2 - 0.01, 0);
-      parts.lever = lever;
-      box5(lever, 0.11, 6e-3, 0.012, M.metal, 0.055, -0.052, 0);
-      box5(lever, 6e-3, 0.05, 0.012, M.metal, 3e-3, -0.028, 0);
-      box5(lever, 6e-3, 0.05, 0.012, M.metal, 0.108, -0.028, 0);
-      box5(lever, 0.04, 6e-3, 0.012, M.metal, 0.08, -2e-3, 0);
-      box5(group, 0.03, 0.012, 3e-3, M.dark, x1 - 0.04, by, wR / 2 + 1e-3);
-    }
-    if (o.tube) {
-      const tubeLength = (L - x1) * (o.tubeLen || 0.8);
-      cylinderX(group, 0.0105, tubeLength, M.metal, x1 + tubeLength / 2, by - 0.023, 0, 16);
-      cylinderX(group, 0.0125, 0.02, M.dark, x1 + tubeLength + 6e-3, by - 0.023, 0, 16);
-    }
-    if (o.pump) {
-      const pump = kit.pivot(group);
-      parts.pump = pump;
-      box5(pump, 0.17, 0.042, 0.046, furn, x1 + 0.14, by - 0.022, 0);
-      for (let i = 0; i < 8; i++) box5(pump, 6e-3, 0.044, 0.048, M.dark, x1 + 0.07 + i * 0.02, by - 0.022, 0);
-    }
-    if (o.heat) {
-      cylinderX(group, r * 1.75, (L - x1) * 0.7, M.dark, x1 + (L - x1) * 0.4, by, 0, 12);
-      for (let i = 0; i < 10; i++) box5(group, 8e-3, r * 1.5, 4e-3, M.hole, x1 + (L - x1) * (0.1 + i * 0.06), by + r * 0.8, r * 1.5);
-    }
-    if (o.bayo) box5(group, 0.025, 8e-3, 0.01, M.metal, L - 0.07, by - 0.016, 0);
-    if (o.rod) cylinderX(group, 3e-3, (L - x1) * 0.85, M.steel, x1 + (L - x1) * 0.45, by - 0.014, 0, 8);
-  }
-
-  // src/models/rifle-forend.ts
-  var PI9 = Math.PI;
-  function buildForend(context) {
-    const { kit, group, options: o, furniture: furn, length: L, receiverEnd: x1, receiverHeight: hR, receiverWidth: wR, barrelRadius: r, barrelY: by } = context;
-    const { M, box: box5 } = kit;
-    const hasLongScope = (o.scope ?? 0) >= 3;
-    if (!context.isTraditional && o.hg !== "none") {
-      const handguardLength = (L - x1) * (o.hgFrac || 0.5);
-      const hx = x1 + handguardLength / 2;
-      const hh = hR * 0.8;
-      if (o.hg === "rail") {
-        box5(group, handguardLength, hh, wR * 1.04, M.dark, hx, by - 2e-3, 0);
-        rail(kit, group, x1, handguardLength, by + hh / 2, 0, wR * 0.66);
-        rail(kit, group, x1 + 0.01, handguardLength - 0.02, by - 2e-3, wR * 0.54, wR * 0.4, PI9 / 2);
-        rail(kit, group, x1 + 0.01, handguardLength - 0.02, by - 2e-3, -wR * 0.54, wR * 0.4, -PI9 / 2);
-        rail(kit, group, x1 + 0.01, handguardLength - 0.02, by - hh / 2, 0, wR * 0.6, PI9);
-      } else {
-        const material = o.hg === "wood" ? M.wood : furn;
-        if (o.ak) {
-          box5(group, handguardLength, hh * 0.55, wR * 1.08, material, hx, by - hh * 0.22, 0);
-          box5(group, handguardLength * 0.75, hh * 0.35, wR * 0.7, material, hx - handguardLength * 0.1, by + r * 2.2, 0);
-        } else {
-          box5(group, handguardLength, hh, wR * 1.08, material, hx, by - 2e-3, 0);
-          vents(kit, group, x1 + 0.01, handguardLength - 0.02, by + hh * 0.15, wR * 0.54 + 1e-3, Math.round(handguardLength / 0.025), hh * 0.3);
-          vents(kit, group, x1 + 0.01, handguardLength - 0.02, by + hh * 0.15, -wR * 0.54 - 1e-3, Math.round(handguardLength / 0.025), hh * 0.3);
-        }
-      }
-      if (!hasLongScope && !o.rail && o.ak) {
-        box5(group, 0.03, 0.016, wR * 0.6, M.metal, x1 + 0.02, by + r * 2.5 + 0.01, 0);
-        box5(group, 0.012, 4e-3, wR * 0.5, M.dark, x1 + 0.03, by + r * 2.5 + 0.019, 0);
-      }
-    }
-    if (hasLongScope) return;
-    const sightX = L - (o.ak ? 0.06 : 0.08);
-    if (o.ak) {
-      box5(group, 0.022, 0.022, wR * 0.6, M.metal, sightX, by + 8e-3, 0);
-      box5(group, 6e-3, 0.024, 4e-3, M.metal, sightX, by + 0.026, 8e-3);
-      box5(group, 6e-3, 0.024, 4e-3, M.metal, sightX, by + 0.026, -8e-3);
-      box5(group, 3e-3, 0.016, 3e-3, M.dark, sightX, by + 0.022, 0);
-    } else if (!o.rail || o.carry) {
-      box5(group, 0.018, 0.014, wR * 0.55, M.dark, sightX, by + 8e-3, 0);
-      box5(group, 0.012, 0.034, 8e-3, M.dark, sightX, by + 0.03, 0, -0.25);
-    } else box5(group, 0.012, 0.024, 0.012, M.dark, sightX - 0.04, by + hR * 0.4 + 0.012, 0);
-  }
-
-  // src/models/attachments/belt-box.ts
-  function buildBeltBox(kit, belt) {
-    const { M, box: box5, cylinderX } = kit;
-    box5(belt, 0.11, 0.1, 0.08, M.olive, 0, 0, 0);
-    box5(belt, 0.112, 0.012, 0.082, M.dark, 0, 0.046, 0);
-    for (let i = 0; i < 7; i++) {
-      cylinderX(belt, 42e-4, 0.034, M.brass, -0.04 + i * 0.012, 0.07, 0.035, 10);
-      box5(belt, 6e-3, 6e-3, 0.012, M.metal, -0.04 + i * 0.012, 0.066, 0.035);
-    }
-  }
-
-  // src/models/attachments/drum.ts
-  function buildDrum(kit, magazine) {
-    const { M, box: box5, cylinderZ } = kit;
-    cylinderZ(magazine, 0.075, 0.07, M.dark, 0.02, -0.085, 0, 22);
-    cylinderZ(magazine, 0.05, 0.074, M.metal, 0.02, -0.085, 0, 18);
-    box5(magazine, 0.05, 0.04, 0.03, M.dark, 0, -0.02, 0);
-  }
-
-  // src/models/helical-magazine.ts
-  var PI10 = Math.PI;
-  var LENGTH = 0.26;
-  var RADIUS = 0.026;
-  var TURNS = 11;
-  function buildHelicalMagazine(context) {
-    const { kit, group, parts, receiverEnd, barrelY, barrelRadius } = context;
-    const { M, cylinderX, box: box5 } = kit;
-    const x = receiverEnd + LENGTH / 2 + 0.02;
-    const y = barrelY - barrelRadius - RADIUS - 0.012;
-    const magazine = kit.pivot(group, x, y, 0);
-    parts.mag = magazine;
-    cylinderX(magazine, RADIUS, LENGTH, M.dark, 0, 0, 0, 20);
-    cylinderX(magazine, RADIUS * 1.06, 0.01, M.metal, -LENGTH / 2, 0, 0, 20);
-    cylinderX(magazine, RADIUS * 1.06, 0.01, M.metal, LENGTH / 2, 0, 0, 20);
-    for (let i = 0; i < TURNS; i++) box5(magazine, 0.012, RADIUS * 2.15, 0.014, M.metal, -LENGTH / 2 + (i + 0.5) * LENGTH / TURNS, 0, 0, 0, 0, i * PI10 / 4);
-    box5(magazine, 0.05, 0.03, 0.03, M.dark, -LENGTH / 2 - 0.02, RADIUS * 0.4, 0);
-    parts.magDrop = 0.16;
-    return x;
-  }
-
-  // src/models/rifle-controls.ts
-  function buildGrip(context) {
-    const { kit, group, parts, options: o, furniture: furn, receiverStart: x0, receiverHeight: hR, receiverWidth: wR } = context;
-    const { M, box: box5 } = kit;
-    const gx = x0 + (o.gripAt || 0.07);
-    if (!context.isTraditional && o.grip !== "none") {
-      const grip = kit.pivot(group, gx - 0.012, -hR / 2 - 0.046, 0);
-      grip.rotation.z = -0.3;
-      parts.grip = grip;
-      box5(grip, 0.032, 0.105, 0.028, furn, 0, 0, 0);
-      for (let i = 0; i < 3; i++) box5(grip, 6e-3, 0.012, 0.026, furn, 0.017, 0.022 - i * 0.02, 0);
-      box5(grip, 0.034, 8e-3, 0.03, furn, 0, -0.052, 0);
-    }
-    box5(group, 0.06, 4e-3, 0.01, M.metal, gx + 0.03, -hR / 2 - 0.024, 0);
-    box5(group, 4e-3, 0.022, 0.01, M.metal, gx + 0.06, -hR / 2 - 0.013, 0);
-    parts.trigger = box5(group, 4e-3, 0.016, 4e-3, M.dark, gx + 0.024, -hR / 2 - 0.012, 0, 0.15);
-    if (o.sel) parts.safety = box5(group, 0.016, 5e-3, 3e-3, M.dark, gx + 5e-3, -hR * 0.15, -wR / 2 - 2e-3, 0.4);
-    return gx;
-  }
-  function buildMagazine(context, gx) {
-    const { kit, group, parts, options: o, receiverStart: x0, receiverHeight: hR, receiverWidth: wR, receiverLength: RL } = context;
-    const { M, box: box5 } = kit;
-    if (o.mag === "helical") return buildHelicalMagazine(context);
-    const mx = o.magAt != null ? x0 + o.magAt : gx + 0.075;
-    const scale = o.magLen || 1;
-    const magazine = kit.pivot(group, mx, -hR / 2, 0);
-    parts.mag = magazine;
-    const finish = o.magMat === "bakelite" ? M.bakelite : o.magMat === "poly" ? M.polyMag : void 0;
-    if (o.mag === "curved") {
-      let px = 0;
-      let py = 0;
-      const material = finish ?? M.metal;
-      for (const angle of [0.06, 0.22, 0.38]) {
-        const length2 = 0.07 * scale;
-        const cx = px + Math.sin(angle) * length2 / 2;
-        const cy = py - Math.cos(angle) * length2 / 2;
-        box5(magazine, 0.052, length2 + 4e-3, 0.024, material, cx, cy, 0, angle);
-        box5(magazine, 0.04, length2 * 0.8, 0.026, M.dark, cx, cy, 0, angle);
-        px += Math.sin(angle) * length2;
-        py -= Math.cos(angle) * length2;
-      }
-      box5(magazine, 0.058, 8e-3, 0.028, material, px, py, 0, 0.38);
-      parts.magDrop = 0.07 * scale * 3 + 0.04;
-    } else if (o.mag === "box") {
-      const length2 = 0.13 * scale;
-      const curve = o.curve || 0;
-      const segment = length2 / 3;
-      const material = finish ?? M.dark;
-      let px = 0;
-      let py = 0;
-      let angle = 0.08;
-      for (let i = 0; i < 3; i++) {
-        angle = 0.08 + curve * i;
-        const cx = px + Math.sin(angle) * segment / 2;
-        const cy = py - Math.cos(angle) * segment / 2;
-        box5(magazine, 0.05, segment + 4e-3, 0.024, material, cx, cy, 0, angle);
-        box5(magazine, 0.04, 3e-3, 0.026, M.metal, cx, cy, 0, angle);
-        px += Math.sin(angle) * segment;
-        py -= Math.cos(angle) * segment;
-      }
-      box5(magazine, 0.056, 7e-3, 0.028, material, px, py - 2e-3, 0, angle);
-      parts.magDrop = length2 + 0.03;
-    } else if (o.mag === "drum") {
-      buildDrum(kit, magazine);
-      parts.magDrop = 0.2;
-    } else if (o.mag === "internal") {
-      box5(group, 0.08, 0.025, 0.03, context.isTraditional ? context.furniture : M.metal, mx, -hR / 2 - 0.012, 0);
-      parts.mag = null;
-    } else parts.mag = null;
-    if (o.mag === "belt") {
-      const belt = kit.pivot(group, mx + 0.02, -hR / 2 - 0.05, -0.045);
-      parts.belt = belt;
-      buildBeltBox(kit, belt);
-      const cover = kit.pivot(group, x0 + 0.01, hR / 2, 0);
-      parts.cover = cover;
-      box5(cover, RL - 0.03, 0.014, wR * 1.05, M.metal, (RL - 0.03) / 2, 7e-3, 0);
-      box5(cover, 0.02, 0.012, wR * 0.6, M.dark, RL - 0.04, 0.016, 0);
-    }
-    return mx;
-  }
-
-  // src/models/rifle-stock.ts
-  function buildStock(context, magazineX) {
-    const { kit, group, options: o, furniture: furn, length: L, stockLength: S, receiverStart: x0, receiverEnd: x1, receiverHeight: hR } = context;
-    const { M, box: box5, cylinderX } = kit;
-    if (context.isTraditional) {
-      buttpad(kit, group, 6e-3, -0.04, 0.13, 0.038);
-      box5(group, 0.03, 0.13, 0.038, furn, 0.024, -0.04, 0);
-      box5(group, S, 0.055, 0.034, furn, S / 2, -0.012, 0, 0.06);
-      box5(group, 0.09, 0.05, 0.032, furn, x0 - 0.02, -0.035, 0, 0.25);
-      const forendLength = x1 - x0 + (L - x1) * (o.fore ?? 0.62);
-      if (forendLength > 0) box5(group, forendLength, 0.045, 0.04, furn, x0 + forendLength / 2, -hR / 2 + 4e-3, 0);
-      if (o.stock === "straight") box5(group, 0.15, 0.04, 0.035, furn, x1 + 0.08, -hR / 2, 0);
-      box5(group, 0.04, 4e-3, 0.03, M.metal, magazineX, -hR / 2 - 0.022, 0);
-      swivel(kit, group, 0.2, -0.08);
-      swivel(kit, group, x1 + (L - x1) * 0.45, -hR / 2 - 0.03);
-      if (o.bands) for (const fraction of [0.35, 0.75]) cylinderX(group, 0.024, 8e-3, M.metal, x1 + (L - x1) * fraction * (o.fore || 0.62), -4e-3, 0, 16);
-    } else if (o.stock === "fixed" || o.stock === "wood") {
-      box5(group, S, 0.05, 0.03, furn, S / 2, -8e-3, 0, 0.05);
-      box5(group, 0.03, 0.13, 0.036, furn, 0.022, -0.035, 0);
-      buttpad(kit, group, 4e-3, -0.035, 0.13, 0.036);
-      if (o.stock === "wood") box5(group, S * 0.6, 0.03, 0.028, furn, S * 0.55, -0.045, 0, 0.2);
-      swivel(kit, group, 0.08, -0.09);
-    } else if (o.stock === "skeleton") {
-      box5(group, S, 0.014, 0.026, furn, S / 2, 0.012, 0, 0.03);
-      box5(group, S, 0.014, 0.026, furn, S / 2, -0.05, 0, -0.08);
-      box5(group, 0.03, 0.12, 0.034, furn, 0.02, -0.025, 0);
-      buttpad(kit, group, 4e-3, -0.025, 0.12, 0.034);
-    } else if (o.stock === "retract") {
-      cylinderX(group, 0.013, S, M.metal, S / 2, 0, 0, 16);
-      for (let i = 0; i < 5; i++) box5(group, 3e-3, 3e-3, 8e-3, M.dark, S * 0.2 + i * 0.015, -0.013, 0);
-      box5(group, 0.034, 0.11, 0.036, furn, 0.02, -0.025, 0);
-      box5(group, S * 0.55, 0.032, 0.03, furn, S * 0.35, 0, 0);
-      buttpad(kit, group, 3e-3, -0.025, 0.11, 0.036);
-    } else if (o.stock === "fold") {
-      box5(group, S, 6e-3, 6e-3, M.metal, S / 2, 0.01, 0.012);
-      box5(group, S, 6e-3, 6e-3, M.metal, S / 2, -0.04, 0.012, -0.12);
-      box5(group, 0.012, 0.1, 0.03, M.metal, 6e-3, -0.02, 0.012);
-    }
-  }
-
-  // src/models/rifle.ts
-  var PI11 = Math.PI;
-  function buildReceiver(context) {
-    const { kit, group, parts, options: o, length: L, receiverStart: x0, receiverEnd: x1, receiverHeight: hR, receiverWidth: wR, receiverLength: RL, barrelY: by } = context;
-    const { M, box: box5, cylinderX, cylinderY, cylinderZ, sphere: sphere2 } = kit;
-    const receiverMaterial = o.tan ? M.tan : M.metal;
-    const middle = (x0 + x1) / 2;
-    if (o.round) {
-      cylinderX(group, hR * 0.36, RL, M.steel, middle, by, 0, 20);
-      cylinderX(group, hR * 0.32, 0.05, M.steel, x0 - 0.01, by, 0, 18);
-    } else if (o.ar) {
-      box5(group, RL, hR * 0.5, wR, receiverMaterial, middle, hR * 0.25, 0);
-      box5(group, RL * 0.92, hR * 0.52, wR * 0.96, receiverMaterial, middle - RL * 0.02, -hR * 0.24, 0);
-      box5(group, 0.05, 0.03, wR * 1.15, receiverMaterial, x0 + RL * 0.62, -hR * 0.5 - 0.01, 0);
-      cylinderZ(group, 6e-3, 0.012, M.metal, x1 - 0.03, hR * 0.28, wR / 2 + 6e-3, 12);
-      box5(group, 0.012, 0.01, 0.012, M.metal, x1 - 0.05, hR * 0.12, wR / 2 + 6e-3);
-      box5(group, 0.03, 8e-3, 0.012, M.dark, x0 + 0.02, hR / 2 + 4e-3, 0);
-      box5(group, 0.012, 6e-3, 4e-3, M.dark, x0 + RL * 0.55, -hR * 0.15, -wR / 2 - 2e-3);
-    } else box5(group, RL, hR, wR, receiverMaterial, middle, 0, 0);
-    if (o.ak) {
-      box5(group, RL * 0.86, hR * 0.28, wR * 0.95, M.metal, middle - 8e-3, hR / 2 + 4e-3, 0);
-      for (let i = 0; i < 3; i++) box5(group, 4e-3, hR * 0.3, wR * 0.97, M.dark, x0 + RL * 0.25 + i * 0.02, hR / 2 + 4e-3, 0);
-      box5(group, RL * 0.5, 0.012, 3e-3, M.metal, x0 + RL * 0.55, -hR * 0.02, wR / 2 + 15e-4, -0.05);
-      box5(group, 0.012, 0.014, 3e-3, M.dark, x0 + RL * 0.32, -hR * 0.05, wR / 2 + 2e-3);
-    }
-    if (o.g3) {
-      cylinderX(group, 9e-3, (L - x1) * 0.6, M.metal, x1 + (L - x1) * 0.28, hR * 0.48, 0, 14);
-      box5(group, 0.012, 0.024, 8e-3, M.dark, x1 + (L - x1) * 0.5, hR * 0.48, -0.012);
-      cylinderY(group, 0.012, 0.016, M.dark, x0 + 0.03, hR / 2 + 8e-3, 0, 12);
-    }
-    const ejectX = x1 - (o.ejectBack || 0.07);
-    const ejectY = o.ar ? hR * 0.2 : by;
-    box5(group, 0.05, hR * 0.36, 4e-3, M.hole, ejectX, ejectY, wR / 2 - 4e-4);
-    const bolt = kit.pivot(group);
-    parts.bolt = bolt;
-    parts.stroke = Math.min(0.1, RL * 0.32);
-    box5(bolt, 0.044, hR * 0.26, 6e-3, M.steelL, ejectX, ejectY, wR / 2 - 12e-4);
-    if (o.charge) {
-      box5(bolt, 0.012, 0.01, 0.03, M.metal, ejectX + 0.04, ejectY + 4e-3, wR / 2 + 0.012);
-      sphere2(bolt, 65e-4, M.metal, ejectX + 0.04, ejectY + 4e-3, wR / 2 + 0.028, 1);
-    }
-    if (o.ar) box5(group, 0.012, 0.016, 6e-3, receiverMaterial, ejectX - 0.03, ejectY + 4e-3, wR / 2 + 4e-3);
-    if (o.rail) rail(kit, group, x0 - 5e-3, RL + 0.07, hR / 2 + (o.ar ? 0 : 3e-3), 0, wR * 0.68);
-  }
-  function buildBarrel(context) {
-    const { kit, group, parts, options: o, length: L, barrelLength: Bl, receiverEnd: x1, barrelRadius: r, barrelY: by } = context;
-    const { M, box: box5, cylinderX } = kit;
-    heatify(parts.glow, cylinderX(group, r, Bl, M.metal, L - Bl / 2, by, 0, 16));
-    if (o.jacket) {
-      cylinderX(group, r * 2, (L - x1) * 0.6, M.dark, x1 + (L - x1) * 0.3, by, 0, 16);
-      for (let i = 0; i < 6; i++) cylinderX(group, r * 2.15, 4e-3, M.metal, x1 + (L - x1) * (0.05 + i * 0.09), by, 0, 16);
-    }
-    if (o.gas) cylinderX(group, r * 0.75, (L - x1) * 0.55, M.metal, x1 + (L - x1) * 0.3, by + r * 2.2, 0, 14);
-    if (o.brake) {
-      const kind = o.brake === 2 ? 2 : 1;
-      recordFitting(parts, kind === 2 ? "muzzle_brake_heavy" : "muzzle_brake", group, () => buildBrake(kit, group, kind, L, by, r, (body) => void heatify(parts.glow, body)));
-    } else if (!o.noFH) {
-      recordFitting(parts, "muzzle_default", group, () => {
-        heatify(parts.glow, cylinderX(group, r * 1.45, 0.042, M.dark, L - 0.021, by, 0, 16));
-        for (let i = 0; i < 4; i++) {
-          const angle = i * PI11 / 2 + PI11 / 4;
-          box5(group, 0.026, 25e-4, 4e-3, M.hole, L - 0.02, by + Math.cos(angle) * r * 1.42, Math.sin(angle) * r * 1.42, 0, 0, angle);
-        }
-      });
-    }
-    cylinderX(group, r * 0.55, 4e-3, M.hole, L + 5e-4, by, 0, 12);
-  }
-  var familyOf = (o) => {
-    if (o.mag === "belt") return "belt";
-    if (o.pump) return "pump";
-    if (o.lever) return "lever";
-    if (o.tube) return "semi12";
-    if (o.bolt) return o.mag === "box" ? "boltmag" : "bolt";
-    return o.mag === "internal" ? "semiint" : "rifle";
-  };
-  function buildRifle(kit, options) {
-    const { M } = kit;
-    const group = kit.group();
-    const parts = { family: "rifle", glow: [] };
-    const length2 = (options.L ?? 0) / 1e3;
-    const barrelLength = (options.B ?? 0) / 1e3;
-    const isTraditional = options.stock === "trad" || options.stock === "straight";
-    const stockLength = options.stock === "none" ? 0 : options.stockLen || Math.min(0.36, Math.max(0.2, 0.3 * length2));
-    const receiverStart = stockLength;
-    const receiverEnd = Math.max(receiverStart + 0.12, length2 - barrelLength * 0.92);
-    const receiverHeight = options.hR || 0.06;
-    const context = {
-      kit,
-      group,
-      parts,
-      options,
-      furniture: options.wood ? M.wood : options.olive ? M.olive : options.tan ? M.tan : M.poly,
-      isTraditional,
-      length: length2,
-      barrelLength,
-      stockLength,
-      receiverStart,
-      receiverEnd,
-      receiverHeight,
-      receiverWidth: options.wR || 0.034,
-      barrelRadius: options.br || 85e-4,
-      barrelY: receiverHeight * 0.15,
-      receiverLength: receiverEnd - receiverStart
-    };
-    buildReceiver(context);
-    buildBarrel(context);
-    buildForend(context);
-    const gripX = buildGrip(context);
-    const magazineX = buildMagazine(context, gripX);
-    parts.stockMeshes = context.isTraditional ? [] : captured(group, () => buildStock(context, magazineX));
-    if (context.isTraditional) buildStock(context, magazineX);
-    buildFittings(context, gripX);
-    const hasHandguard = !context.isTraditional && options.hg !== "none";
-    parts.frames = {
-      length: length2,
-      barrelY: context.barrelY,
-      barrelRadius: context.barrelRadius,
-      receiverStart,
-      receiverEnd,
-      receiverHeight,
-      receiverWidth: context.receiverWidth,
-      handguardEnd: receiverEnd + (length2 - receiverEnd) * (hasHandguard ? options.hgFrac || 0.5 : 0.4),
-      magazineX,
-      gripX,
-      hasRail: Boolean(options.rail)
-    };
-    const { barrelY: by, receiverWidth: wR } = context;
-    const ejectX = receiverEnd - (options.ejectBack || 0.07);
-    const ejectY = options.ar ? receiverHeight * 0.2 : by;
-    parts.muzzle = kit.mark(group, length2 + 0.01, by, 0);
-    parts.eject = kit.mark(group, ejectX, ejectY, wR / 2 + 6e-3);
-    parts.loadPort = kit.mark(group, receiverEnd - 0.05, -receiverHeight / 2 - 4e-3, 0);
-    parts.topLoad = kit.mark(group, ejectX, receiverHeight / 2 + 4e-3, 0);
-    parts.family = familyOf(options);
-    return { group, parts };
-  }
-
   // src/models/index.ts
   var MODEL_ENTRIES = models_default2;
   var ARCHETYPE_MODELS = (() => {
@@ -53105,13 +54092,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     return chosen;
   })();
-  var BUILDERS3 = {
+  var BUILDERS4 = {
     pistol: buildPistol,
     revolver: buildRevolver,
     rifle: buildRifle,
     bullpup: buildBullpup,
     p90: (kit) => buildP90(kit),
     break: buildBreakAction,
+    breakLauncher: buildBreakLauncher,
     m2: (kit) => buildM2(kit),
     m134: (kit) => buildM134(kit),
     launcher: buildLauncher
@@ -53135,7 +54123,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const kit = modelKit(THREE);
     const options = { L: entry2.length, B: entry2.barrel, cal: entry2.caliber, ...entry2.options };
     if (id in ARCHETYPE_MODELS) delete options.chambers;
-    const built2 = BUILDERS3[entry2.builder](kit, options);
+    const built2 = BUILDERS4[entry2.builder](kit, options);
     nameParts(built2.parts);
     let root;
     if (entry2.builder === "launcher") {
@@ -53370,9 +54358,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     if (kind !== "one_by_one") events.push(cue(0.7, "move_in", { from: "chambers" }), sound2(0.7, "speedloader"));
     return { tweens: [turn("crane", "x", 0, 0.22, 0, -1.25), turn("crane", "x", 1.05, 0.2, -1.25, 0)], events, end: 1.3 };
   }
-  var breakReload = () => ({
+  var breakReload = (chambers) => ({
     tweens: [turn("barrels", "z", 0, 0.2, 0, -0.5), turn("barrels", "z", 1, 0.15, -0.5, 0)],
-    events: [sound2(0, "barrels_open"), cue(0.25, "eject_casing", { from: "breech", down: false }), sound2(0.25, "casings_eject"), cue(0.65, "move_in", { from: "breech" }), sound2(0.65, "shell_insert"), sound2(0.8, "shell_insert"), sound2(1.13, "barrels_close")],
+    events: [
+      sound2(0, "barrels_open"),
+      cue(0.25, "eject_casing", { from: "breech", down: false }),
+      sound2(0.25, "casings_eject"),
+      cue(0.65, "move_in", { from: "breech" }),
+      sound2(0.65, "shell_insert"),
+      ...chambers > 1 ? [sound2(0.8, "shell_insert")] : [],
+      sound2(1.13, "barrels_close")
+    ],
     end: 1.2
   });
   var beltReload = (context) => ({
@@ -53445,7 +54441,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     if (family === "rocket" || family === "flame") return heavyReload(context);
     if (parts.mag) return magazineReload(context, kind);
     if (family === "revolver" && parts.crane) return revolverReload(kind);
-    if (family === "break" && parts.barrels) return breakReload();
+    if (family === "break" && parts.barrels) return breakReload(parts.breech?.length ?? 2);
     if (family === "belt" && parts.cover && parts.belt) return beltReload(context);
     if (isTube(context)) return tubeReload(context, kind);
     if (family === "bolt") return boltReload(context);
@@ -55580,16 +56576,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (this.spaces.delete(id)) this.list = [...this.spaces.values()];
         return;
       }
-      const [hx, hy, hz] = enclosure.halfSize;
+      const [hx, hy, hz2] = enclosure.halfSize;
       const space = {
         cx: enclosure.center[0],
         cy: enclosure.center[1],
         cz: enclosure.center[2],
         hx: Math.abs(hx),
         hy: Math.abs(hy),
-        hz: Math.abs(hz),
+        hz: Math.abs(hz2),
         r: rotation(enclosure.orientation),
-        radius: Math.hypot(hx, hy, hz),
+        radius: Math.hypot(hx, hy, hz2),
         openings: enclosure.openings ?? [],
         leak: Math.max(0, enclosure.leak ?? 0)
       };
@@ -59772,13 +60768,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   function composeAfterEffects(context) {
     const { core, def, random, x, y, z } = context;
     const mark = def.mark;
-    if (mark.crater && mark.dent && y < 1.2) {
+    const keepsMarks = !core.marklessAt?.(x, z);
+    if (keepsMarks && mark.crater && mark.dent && y < 1.2) {
       core.emit({ type: "crater", x, z, radius: mark.crater, depth: mark.dent });
       core.trace?.crater?.(x, z, mark.crater, mark.dent);
       addCrater(core.marks, core.ground, random, { x, z, radius: mark.crater, depth: mark.dent, marks: core.layers.mark });
       if (core.layers.shrapnel) composeRimDebris(context);
     }
-    if (mark.scorch && y < 1.2 && core.layers.mark) {
+    if (keepsMarks && mark.scorch && y < 1.2 && core.layers.mark) {
       core.trace?.scorch?.(x, z, mark.scorch);
       addScorch(core.marks, random, x, z, mark.scorch);
     }
@@ -61487,7 +62484,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const wind = { x: DEFAULT_WIND.x, y: DEFAULT_WIND.y, z: DEFAULT_WIND.z };
     if (options.wind) [wind.x, wind.y, wind.z] = options.wind;
     const camera2 = { x: 0, y: 1.6, z: 0 };
-    const layers = Object.fromEntries(VFX_LAYERS.map((layer2) => [layer2, true]));
+    const layers = Object.fromEntries(VFX_LAYERS.map((layer3) => [layer3, true]));
     const ground = options.ground;
     const groundAt = options.groundAt ?? (ground ? (x, z) => ground.heightAt(x, z) : () => 0);
     const handles = { next: 0, events: 0 };
@@ -61529,6 +62526,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       spawned: { puffs: 0, sparks: 0, chunks: 0, lights: 0 },
       clock: { time: 0, lastBlast: -1, lod: 1, forcedLod: null },
       groundAt,
+      ...options.marklessAt ? { marklessAt: options.marklessAt } : {},
       emit: (request) => options.onRequest?.(request)
     };
     function definitionOf(id) {
@@ -61555,6 +62553,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return player ?? (player = createEffectPlayer({ engine: workshop(), effects, view }));
     }
     return {
+      hostGroundAt: options.groundAt,
       play(id, point, playOptions = {}) {
         if (!(id in effects)) return null;
         const seed = playOptions.seed ?? (randomMode === "shared" ? void 0 : Math.imul(++handles.events, AUTO_SEED) + (options.seed ?? 0));
@@ -61617,10 +62616,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const fires = core.fires;
         for (let index = fires.items.length - 1; index >= 0; index--) if (fires.items[index].handle === handle) fires.removeAt(index);
       },
-      setLayer(layer2, on) {
-        layers[layer2] = on;
+      setLayer(layer3, on) {
+        layers[layer3] = on;
       },
-      layer: (layer2) => layers[layer2],
+      layer: (layer3) => layers[layer3],
       setCamera(position) {
         camera2.x = position[0];
         camera2.y = position[1];
@@ -61707,7 +62706,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
   }
 
-  // ../game-vfx-three/dist/chunk-2MZDWTHX.js
+  // ../game-vfx-three/dist/chunk-CPRCWTSQ.js
   var GLOW_VERTEX = `attribute vec4 aP;attribute vec4 aC;varying vec2 vU;varying vec4 vC;
 void main(){vec3 R=vec3(viewMatrix[0][0],viewMatrix[1][0],viewMatrix[2][0]);vec3 Up=vec3(viewMatrix[0][1],viewMatrix[1][1],viewMatrix[2][1]);
 vec3 wp=aP.xyz+(R*position.x+Up*position.y)*aP.w;vU=position.xy;vC=aC;gl_Position=projectionMatrix*viewMatrix*vec4(wp,1.);}`;
@@ -62147,7 +63146,11 @@ void main(){
     const dirt = texture(paint(make3, (context, size) => drawDirt(context, size, random)));
     return { scorch, dirt };
   }
-  var MAX_CONFORM_STEPS = 48;
+  var FLAT_STEPS_PER_METRE = 8;
+  var MAX_FLAT_STEPS = 48;
+  var DUG_STEPS_PER_METRE = 20;
+  var MAX_DUG_STEPS = 64;
+  var FLAT_TOLERANCE = 2e-3;
   var MIN_CONFORM_STEPS = 16;
   var BLOOD_GROW_RATE = 1.2;
   var BLOOD_START_GROWTH = 0.05;
@@ -62230,9 +63233,21 @@ void main(){
       spareGeometries.push(oldest.mesh.geometry);
       if (spareGeometries.length > MAX_SPARE_GROUND_GEOMETRIES) spareGeometries.shift().dispose();
     }
+    const heightAt = options.heightAt ?? ((x, z) => options.ground?.heightAt(x, z) ?? 0);
+    function groundDipsUnder(x, z, radius) {
+      const centre = heightAt(x, z);
+      for (const share of [0.25, 0.5, 0.75]) {
+        for (let ray = 0; ray < 8; ray++) {
+          const angle = ray / 8 * Math.PI * 2;
+          if (Math.abs(heightAt(x + Math.cos(angle) * radius * share, z + Math.sin(angle) * radius * share) - centre) > FLAT_TOLERANCE) return true;
+        }
+      }
+      return false;
+    }
     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 dug = options.heightAt !== void 0 && groundDipsUnder(mark.x, mark.z, radius);
+      const steps = Math.max(MIN_CONFORM_STEPS, Math.min(dug ? MAX_DUG_STEPS : MAX_FLAT_STEPS, Math.round(radius * (dug ? DUG_STEPS_PER_METRE : FLAT_STEPS_PER_METRE))));
       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;
@@ -62244,7 +63259,7 @@ void main(){
         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;
-        grid.setXYZ(index, worldX, (options.ground?.heightAt(worldX, worldZ) ?? 0) + mark.lift, worldZ);
+        grid.setXYZ(index, worldX, heightAt(worldX, worldZ) + mark.lift, worldZ);
       }
       grid.needsUpdate = true;
       geometry.computeVertexNormals();
@@ -62442,7 +63457,7 @@ void main(){
     };
   }
   var clamp5 = (value, min2, max2) => value < min2 ? min2 : value > max2 ? max2 : value;
-  function layer(container, name, blend) {
+  function layer2(container, name, blend) {
     const element = container.ownerDocument.createElement("div");
     element.dataset.vfxOverlay = name;
     Object.assign(element.style, { position: "absolute", inset: "0", pointerEvents: "none", opacity: "0" });
@@ -62451,12 +63466,12 @@ void main(){
     return element;
   }
   function createScreenOverlay(container) {
-    const flash2 = layer(container, "flash", "screen");
+    const flash2 = layer2(container, "flash", "screen");
     flash2.style.background = "#fff";
-    const white = layer(container, "white");
-    const red = layer(container, "red");
-    const sides = layer(container, "sides");
-    const gas = layer(container, "gas");
+    const white = layer2(container, "white");
+    const red = layer2(container, "red");
+    const sides = layer2(container, "sides");
+    const gas = layer2(container, "gas");
     const elements = [flash2, white, red, sides, gas];
     return {
       update(state) {
@@ -62916,7 +63931,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       decalLayer(THREE, engine.decals),
       ringLayer(THREE, engine.rings)
     ];
-    for (const layer2 of layers) group.add(layer2.object);
+    for (const layer22 of layers) group.add(layer22.object);
     const meshes = createMeshLayer(THREE, engine.meshes);
     group.add(meshes.group);
     const lights = budget ? budgetedLights(engine, lightScale, budget) : legacyLights(THREE, engine, lightScale, group);
@@ -62924,13 +63939,13 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       group,
       sync() {
         let drawCalls = 0;
-        for (const layer2 of layers) if (layer2.sync()) drawCalls++;
+        for (const layer22 of layers) if (layer22.sync()) drawCalls++;
         drawCalls += meshes.sync();
         lights.sync();
         return drawCalls;
       },
       dispose() {
-        for (const layer2 of layers) layer2.dispose();
+        for (const layer22 of layers) layer22.dispose();
         meshes.dispose();
         lights.dispose();
         group.clear();
@@ -63034,7 +64049,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, options.lights);
-    const marks = createMarkLayer(THREE, { ground: pools.ground, createCanvas: options.createCanvas, rockGeometry, plateGeometry, ...options.markLimits });
+    const marks = createMarkLayer(THREE, { ground: pools.ground, ...world.hostGroundAt ? { heightAt: world.hostGroundAt } : {}, 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;
@@ -63167,7 +64182,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         stopMarks();
         overlay?.dispose();
         workshopLayers?.dispose();
-        for (const layer2 of [puffs, sparks, glows, chunks, shocks, lights, marks, sprites]) layer2.dispose();
+        for (const layer22 of [puffs, sparks, glows, chunks, shocks, lights, marks, sprites]) layer22.dispose();
         rockGeometry.dispose();
         plateGeometry.dispose();
         options.scene.remove(root);
@@ -63201,6 +64216,38 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     };
   }
 
+  // src/fx/view-hold.ts
+  var VIEW_HOLD = {
+    /** The right hand's grip, from the eye. */
+    grip: [0.2, -0.2, -0.3],
+    /** A handgun's grip: higher and nearer the middle, the arms out in front. */
+    handgunGrip: [0.13, -0.15, -0.33],
+    /** A rocket launcher's grip: its tube rides on the shoulder, so the hands are higher. */
+    launcherGrip: [0.2, -0.14, -0.3],
+    /** A gun with no grip anchor: the rear of its bore, from the eye. */
+    rear: [0.2, -0.24, -0.12]
+  };
+  var scratch2 = { grip: null };
+  function placeInView(placement) {
+    const { THREE, hand, holder, camera: camera2, right } = placement;
+    holder.scale.setScalar(1);
+    hand.position.copy(camera2.position);
+    hand.quaternion.copy(camera2.quaternion);
+    hand.scale.setScalar(1);
+    holder.position.set(0, 0, 0);
+    hand.updateMatrixWorld(true);
+    if (!right) {
+      holder.position.set(VIEW_HOLD.rear[0], VIEW_HOLD.rear[1], VIEW_HOLD.rear[2] + placement.rear);
+      hand.updateMatrixWorld(true);
+      return;
+    }
+    scratch2.grip ?? (scratch2.grip = new THREE.Vector3());
+    const grip = hand.worldToLocal(right.part.localToWorld(scratch2.grip.copy(right.offset)));
+    const [x, y, z] = placement.kind === "handgun" ? VIEW_HOLD.handgunGrip : placement.kind === "launcher" ? VIEW_HOLD.launcherGrip : VIEW_HOLD.grip;
+    holder.position.set(x - grip.x, y - grip.y, z - grip.z);
+    hand.updateMatrixWorld(true);
+  }
+
   // src/fx/heavy.ts
   var PI14 = Math.PI;
   var ROCKET_LIGHT_NAME = "rocket-light";
@@ -64186,6 +65233,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     let triggerRest = 0;
     let feedCued = false;
     const rootQuaternion = new THREE.Quaternion();
+    const muzzleAt = new THREE.Vector3();
+    const muzzleAlong = new THREE.Vector3();
     const world = {
       kit,
       scene,
@@ -64285,6 +65334,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (model.parts.stockMove && onTool?.stock === "collapsed") rig.setPartPose("stock", collapsedStockPose(model.parts.stockMove));
       applyCondition(kit, model, condition);
       lastAmmo = options.tool?.().ammo ?? 0;
+      void audio?.loadSamples();
       hand.updateMatrixWorld(true);
       hold = holdOfModel(THREE, model, 1);
       hold = { ...hold, works: handWorkOf(THREE, model, weapon, hold.right) };
@@ -64337,12 +65387,22 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       if (!session) return;
       const family = session.model.parts.family;
       session.holderScale = 1;
+      if (options.firstPerson?.()) {
+        placeInView({ THREE, hand, holder, camera: camera2, right: hold?.right ?? null, rear: modelRear, kind: family === "pistol" || family === "revolver" ? "handgun" : family === "rocket" ? "launcher" : "long" });
+        lift = 0;
+        pullFromWall(dt);
+        return;
+      }
+      hand.scale.set(1, 1, 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);
       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;
+      pullFromWall(dt);
+    };
+    const pullFromWall = (dt) => {
+      if (!options.contact || !session) 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);
@@ -64373,7 +65433,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       }
       const action = current.def.action;
       if (action.kind === "launcher") {
-        launchRocket(heavy(current), options.flyRocket !== false);
+        if (current.model.parts.family === "rocket") launchRocket(heavy(current), options.flyRocket !== false);
         audio?.play("explosion", LAUNCH_VOLUME, distance3());
       }
       if (action.kind !== "firearm") return;
@@ -64450,6 +65510,15 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         condition = next;
         if (session) applyCondition(kit, session.model, condition);
       },
+      muzzle() {
+        const mark = session?.model.parts.muzzle;
+        if (!session || !mark) return null;
+        hand.updateMatrixWorld(true);
+        const at3 = worldPositionOf(session, mark, muzzleAt);
+        const along = muzzleAlong.set(1, 0, 0).applyQuaternion(session.model.root.getWorldQuaternion(rootQuaternion)).normalize();
+        const kind = session.def.action.kind;
+        return { position: [at3.x, at3.y, at3.z], direction: [along.x, along.y, along.z], drawsFlash: kind === "firearm" || kind === "launcher" };
+      },
       handTargets() {
         if (!session || !hold) return null;
         hand.updateMatrixWorld(true);
@@ -64504,6 +65573,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       ...options.raycast ? { raycast: options.raycast } : {},
       ...options.contact ? { contact: options.contact } : {},
       ...options.bodyHold ? { bodyHold: options.bodyHold } : {},
+      ...options.firstPerson ? { firstPerson: options.firstPerson } : {},
       ...options.effects ? { effects: options.effects } : {},
       ...options.flyRocket === void 0 ? {} : { flyRocket: options.flyRocket },
       ...options.particleLimit ? { particleLimit: options.particleLimit } : {},
@@ -64526,6 +65596,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       },
       setCondition: (condition) => model.setCondition(condition),
       handTargets: () => model.handTargets() ?? box5.handTargets(),
+      muzzle: () => model.inHand !== null ? model.muzzle() : box5.muzzle(),
       layers,
       get inHand() {
         return model.inHand ?? box5.inHand;
@@ -64550,7 +65621,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var MODEL_BODY = "body";
   function buildModeledProp(THREE, def, name, decorate, items, props = defaultWeaponProps()) {
     const model = buildWeaponModelById(THREE, def.id) ?? (() => {
-      const root = props.buildItemModel(THREE, def, items);
+      const root = props.buildItemModel(THREE, def, items) ?? buildThrowableModel(THREE, def);
       return root ? { root } : void 0;
     })();
     if (!model) return void 0;
@@ -65693,7 +66764,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   };
   var weaponItem = (def, name, items, props = defaultWeaponProps()) => {
     const id = `${WEAPON_ITEM_PREFIX}${def.id}`;
-    if (!hasWeaponModel(def.id) && !props.itemModelOf(def.id, items)) return asItem(id, name, weaponProp(def, name), { weapon: def.id, movable: true });
+    if (!hasWeaponModel(def.id) && !props.itemModelOf(def.id, items) && !hasThrowableModel(def)) return asItem(id, name, weaponProp(def, name), { weapon: def.id, movable: true });
     return {
       id,
       name,
@@ -65753,7 +66824,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const seedOption = options.seed === void 0 ? {} : { seed: options.seed };
     let audio;
     const ownAudio = () => audio === void 0 ? audio = options.sound === false ? null : createWeaponAudio(void 0, { ...seedOption, ...options.samples ? { samples: options.samples } : {} }) : audio;
-    const weaponDefs = [...arsenal.weapons.values()].filter((def) => !BODY_ACTIONS.has(def.id));
+    const generics = genericWeapons(arsenal);
+    const weaponDefs = [...arsenal.weapons.values()].filter((def) => !BODY_ACTIONS.has(def.id) && !generics.has(def.id));
     const thumbnailBase = options.thumbnailBase ?? DEFAULT_THUMBNAIL_BASE;
     const withThumbnail = (item, key2) => {
       const thumbnail = thumbnailBase === false ? void 0 : weaponThumbnailUrl(key2, thumbnailBase);
@@ -65841,7 +66913,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
             engine: lentEngine,
             ...options.samples ? { samples: options.samples } : {},
             onGunshot: (shot, input, played) => {
-              const recorded = played.kind === "sample" && played.layers.length > 0 ? fill(text.gunshotRecorded, { takes: played.layers.map((layer2) => `${layer2.role} ${layer2.take + 1}`).join(", ") }) : "";
+              const recorded = played.kind === "sample" && played.layers.length > 0 ? fill(text.gunshotRecorded, { takes: played.layers.map((layer3) => `${layer3.role} ${layer3.take + 1}`).join(", ") }) : "";
               lent.log(
                 fill(text.gunshotSound, { profile: shot.profile, take: String(shot.take + 1), pitch: `${shot.pitch >= 1 ? "+" : ""}${((shot.pitch - 1) * 100).toFixed(1)} %`, space: text.spaces[input.space ?? "outdoor"], distance: String(Math.round(input.distance ?? 0)), far: shot.closeMix < 1 ? ` (${Math.round((1 - shot.closeMix) * 100)} % far)` : "" }) + recorded,
                 { profile: shot.profile, take: shot.take, pitch: shot.pitch, space: input.space ?? "outdoor", distance: input.distance ?? 0, closeMix: shot.closeMix, delay: shot.delay, samples: shot.samples, played },
@@ -65870,6 +66942,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           // 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 } : {},
+          firstPerson: () => lent.player().cameraMode === "first",
           ...lent.effects ? { effects: lent.effects } : {},
           ...lent.particleLimit ? { particleLimit: lent.particleLimit } : {},
           ...isLightBudget(lent.lights) ? { lights: lent.lights } : {},
@@ -65920,6 +66993,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         });
         const offFrame = lent.onFrame((dt) => created.update(dt));
         const offHands = lent.setHandTargets?.(() => created.handTargets());
+        const offMuzzle = lent.setMuzzleSource?.(() => created.muzzle());
         created.handle({ type: "tool", weapon: lent.tool().weapon }, lent.tool());
         return () => {
           accessories.dispose();
@@ -65928,6 +67002,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           offFrame();
           offClock();
           offHands?.();
+          offMuzzle?.();
           created.dispose();
           audio?.dispose();
           fx = null;
@@ -66657,6 +67732,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
   var SHELTERED_MOST = 1;
   var CHEST = 1.1;
   var MIDDLE = 0.3;
+  var AIM_SEARCH = 1.5;
   var HEAVY_ITEMS = ["camp_table"];
   var PERSON_MASS = 70;
   var GROUND_FRICTION2 = 7;
@@ -66716,6 +67792,27 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         }
         const partsBefore = new Map(placed.map((body) => [body.objectId, partsOf(body.objectId)]));
         expect(placed.length > 0, fillText2(text.push_found, { n: placed.length, kinds: [...new Set(placed.map((body) => body.kind))].join(", ") }), { placed: placed.map((body) => body.itemId) });
+        const aimOf = new Map(
+          placed.map((body) => {
+            const from = origin.get(body.objectId) ?? body.from;
+            if (body.kind === "zombie" || body.kind === "survivor") return [body.objectId, [from[0], from[1] + CHEST, from[2]]];
+            const boxes = room.renderer.solidsNear?.(from[0], from[2], AIM_SEARCH).filter((box5) => box5.objectId === body.objectId) ?? [];
+            if (boxes.length === 0) return [body.objectId, [from[0], from[1] + MIDDLE, from[2]]];
+            const low = [0, 1, 2].map((axis2) => Math.min(...boxes.map((box5) => box5.min[axis2])));
+            const high = [0, 1, 2].map((axis2) => Math.max(...boxes.map((box5) => box5.max[axis2])));
+            return [body.objectId, [0, 1, 2].map((axis2) => (low[axis2] + high[axis2]) / 2)];
+          })
+        );
+        const coverAt = (point) => new Map(
+          placed.map((body) => {
+            const ignore = source ? [source, body.objectId] : [body.objectId];
+            return [body.objectId, room.world.blastReach?.(point, aimOf.get(body.objectId) ?? body.from, { ignore }) ?? 1];
+          })
+        );
+        let coverOf;
+        const stopListening = room.world.on("*", (event) => {
+          if ((event.type === "explode" || event.type === "blast") && !coverOf) coverOf = coverAt(event.point);
+        });
         if (mode === "p13") bench.actions.shoot();
         else {
           room.setTool("frag_grenade");
@@ -66728,17 +67825,11 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           step(0.05);
           waited += 0.05;
         }
+        stopListening();
         const blast = bench.lastBlast();
         expect(!!blast, text.push_told, { waited });
         if (!blast) return;
-        const coverOf = new Map(
-          placed.map((body) => {
-            const from = origin.get(body.objectId) ?? body.from;
-            const person = body.kind === "zombie" || body.kind === "survivor";
-            const ignore = source ? [source, body.objectId] : [body.objectId];
-            return [body.objectId, room.world.blastReach?.(blast.point, [from[0], from[1] + (person ? CHEST : MIDDLE), from[2]], { ignore }) ?? 1];
-          })
-        );
+        const cover = coverOf ?? coverAt(blast.point);
         step(PUSH_READ_AT);
         const rows = placed.map((body) => {
           const from = origin.get(body.objectId) ?? body.from;
@@ -66746,16 +67837,18 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const distance3 = flat(from, blast.point);
           const away = Math.max(1e-6, distance3);
           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), cover: coverOf.get(body.objectId) ?? 1 };
+          return { ...body, distance: distance3, outward, moved: flat(now, from), cover: cover.get(body.objectId) ?? 1 };
         });
         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 inReach = rows.filter((row) => row.distance < blast.radius * 0.85 && !torn(row));
+        const isPerson = (row) => row.kind === "survivor" || row.kind === "zombie";
+        const reached = inReach.filter((row) => row.cover >= SHELTERED && !isPerson(row));
         const sheltered = inReach.filter((row) => row.cover < SHELTERED);
         for (const row of sheltered) {
-          expect(row.outward < SHELTERED_MOST, fillText2(text.push_sheltered, { what: things[row.kind] ?? row.kind, distance: row.distance.toFixed(1), cover: (row.cover * 100).toFixed(0), moved: Math.max(0, row.outward).toFixed(2) }), { row: { kind: row.kind, distance: row.distance, outward: row.outward, cover: row.cover } });
+          const open = reached.filter((other) => other.kind === row.kind && other.distance <= row.distance).map((other) => other.outward);
+          const most = Math.max(SHELTERED_MOST, row.cover * Math.max(0, ...open));
+          expect(row.outward < most, fillText2(text.push_sheltered, { what: things[row.kind] ?? row.kind, distance: row.distance.toFixed(1), cover: (row.cover * 100).toFixed(0), moved: Math.max(0, row.outward).toFixed(2) }), { row: { kind: row.kind, distance: row.distance, outward: row.outward, cover: row.cover, most } });
         }
-        const isPerson = (row) => row.kind === "survivor" || row.kind === "zombie";
-        const reached = inReach.filter((row) => row.cover >= SHELTERED && !isPerson(row));
         const movedAway = reached.filter((row) => row.outward >= MOVED);
         const least = reached.length === 0 ? 0 : Math.min(...reached.map((row) => row.outward));
         expect(reached.length > 0 && movedAway.length === reached.length, fillText2(text.push_outward, { moved: movedAway.length, n: reached.length, least: least.toFixed(2) }), { rows: reached.map((row) => ({ kind: row.kind, distance: row.distance, outward: row.outward })), torn: rows.filter(torn).map((row) => row.objectId) });
@@ -66923,12 +68016,22 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
 
   // src/projectile-model.ts
   function projectileModel(THREE, query2) {
-    if (query2.kind !== "rocket") return null;
+    if (query2.kind !== "rocket") return explosiveProjectile(THREE, query2);
     const launcher = buildWeaponModelById(THREE, query2.weapon);
     if (!launcher || launcher.parts.family !== "rocket") return null;
     const round5 = launcher.parts.makeRound ? launcher.parts.makeRound() : buildFlyingRocket(modelKit(THREE), launcher.parts.launcherType);
     return { model: round5, axis: [1, 0, 0] };
   }
+  function explosiveProjectile(THREE, query2) {
+    const model = query2.explosive === void 0 ? void 0 : buildExplosiveModel(THREE, query2.explosive);
+    if (!model) return null;
+    const centre = new THREE.Box3().setFromObject(model).getCenter(new THREE.Vector3());
+    const holder = markKitOrigin(new THREE.Group(), { owner: "game-weapons-three", kind: "explosive", id: model.name });
+    holder.name = model.name;
+    model.position.sub(centre);
+    holder.add(model);
+    return { model: holder, axis: [0, 1, 0] };
+  }
 
   // src/weapon-props.ts
   function createWeaponProps(options = {}) {