@adatechnology/game-floorplan-three 0.9.0 → 0.9.2

package/dist/index.global.js

@@ -70,7 +70,7 @@ var GameFloorplanThree = (() => {
     shade: () => shade
   });
 
-  // ../game-shapes/dist/chunk-IFXQIDSA.js
+  // ../game-shapes/dist/chunk-M5N2SHNL.js
   function canonicalJson(value) {
     if (value === null) return "null";
     if (typeof value === "number") return Object.is(value, -0) ? "-0" : Number.isFinite(value) ? String(value) : JSON.stringify(String(value));
@@ -1227,13 +1227,13 @@ var GameFloorplanThree = (() => {
       uvArray.push(x);
       uvArray.push(y);
     };
-    const at = (index, axis) => verticesArray[index * 3 + axis];
+    const at2 = (index, axis) => verticesArray[index * 3 + axis];
     const f3 = (a, b, c) => {
       addVertex(a);
       addVertex(b);
       addVertex(c);
       const nextIndex = verticesArray.length / 3;
-      for (const index of [nextIndex - 3, nextIndex - 2, nextIndex - 1]) addUV(at(index, 0), at(index, 1));
+      for (const index of [nextIndex - 3, nextIndex - 2, nextIndex - 1]) addUV(at2(index, 0), at2(index, 1));
     };
     const f4 = (a, b, c, d) => {
       addVertex(a);
@@ -1247,8 +1247,8 @@ var GameFloorplanThree = (() => {
       const iB = nextIndex - 3;
       const iC = nextIndex - 2;
       const iD = nextIndex - 1;
-      const byX = Math.abs(at(iA, 1) - at(iB, 1)) < Math.abs(at(iA, 0) - at(iB, 0));
-      const uv = (index) => [byX ? at(index, 0) : at(index, 1), 1 - at(index, 2)];
+      const byX = Math.abs(at2(iA, 1) - at2(iB, 1)) < Math.abs(at2(iA, 0) - at2(iB, 0));
+      const uv = (index) => [byX ? at2(index, 0) : at2(index, 1), 1 - at2(index, 2)];
       const uvs = [uv(iA), uv(iB), uv(iC), uv(iD)];
       for (const k of [0, 1, 3, 1, 2, 3]) addUV(...uvs[k]);
     };
@@ -1353,8 +1353,8 @@ var GameFloorplanThree = (() => {
       groups: []
     };
   }
-  function make(kind, p) {
-    switch (kind) {
+  function make(p) {
+    switch (p.kind) {
       case "box": {
         const size = p.size ?? [1, 1, 1];
         const segments = p.segments ?? [1, 1, 1];
@@ -1383,7 +1383,7 @@ var GameFloorplanThree = (() => {
       case "mesh":
         return mesh(p);
       default:
-        throw new Error(`game-shapes: unknown primitive kind "${String(kind)}"`);
+        throw new Error(`game-shapes: unknown primitive kind "${String(p.kind)}"`);
     }
   }
   var templates = /* @__PURE__ */ new Map();
@@ -1391,7 +1391,7 @@ var GameFloorplanThree = (() => {
   var stats = { hits: 0, misses: 0 };
   function buildPrimitive(node, options = {}) {
     const parameters = primitiveParameters(node, options);
-    if (node.kind === "mesh" || templateLimit === 0) return make(node.kind, parameters);
+    if (node.kind === "mesh" || templateLimit === 0) return make({ ...node, ...parameters });
     const key = `${node.kind}:${canonicalJson(parameters)}`;
     const cached = templates.get(key);
     if (cached) {
@@ -1401,7 +1401,7 @@ var GameFloorplanThree = (() => {
       return cached;
     }
     stats.misses++;
-    const built = make(node.kind, parameters);
+    const built = make({ ...node, ...parameters });
     templates.set(key, built);
     if (templates.size > templateLimit) templates.delete(templates.keys().next().value);
     return built;
@@ -1499,7 +1499,7 @@ var GameFloorplanThree = (() => {
     const positions2 = new Float32Array(total * 3);
     const normals = new Float32Array(total * 3);
     const uvs = new Float32Array(total * 2);
-    let at = 0;
+    let at2 = 0;
     for (const piece2 of pieces) {
       const e = piece2.matrix;
       const nm = normalMatrix(e);
@@ -1513,15 +1513,15 @@ var GameFloorplanThree = (() => {
           if (piece2.normals) n[k * 3 + c] = piece2.normals[i * 3 + c];
         }
         if (piece2.uvs) {
-          uvs[(at + k) * 2] = piece2.uvs[i * 2];
-          uvs[(at + k) * 2 + 1] = piece2.uvs[i * 2 + 1];
+          uvs[(at2 + k) * 2] = piece2.uvs[i * 2];
+          uvs[(at2 + k) * 2 + 1] = piece2.uvs[i * 2 + 1];
         }
       }
       for (let k = 0; k < count; k++) {
         const q = transformPoint(e, p[k * 3], p[k * 3 + 1], p[k * 3 + 2]);
-        positions2[(at + k) * 3] = q[0];
-        positions2[(at + k) * 3 + 1] = q[1];
-        positions2[(at + k) * 3 + 2] = q[2];
+        positions2[(at2 + k) * 3] = q[0];
+        positions2[(at2 + k) * 3 + 1] = q[1];
+        positions2[(at2 + k) * 3 + 2] = q[2];
         const x = n[k * 3];
         const y = n[k * 3 + 1];
         const z = n[k * 3 + 2];
@@ -1529,16 +1529,17 @@ var GameFloorplanThree = (() => {
         const vy = nm[1] * x + nm[4] * y + nm[7] * z;
         const vz = nm[2] * x + nm[5] * y + nm[8] * z;
         const s = 1 / (Math.sqrt(vx * vx + vy * vy + vz * vz) || 1);
-        normals[(at + k) * 3] = vx * s;
-        normals[(at + k) * 3 + 1] = vy * s;
-        normals[(at + k) * 3 + 2] = vz * s;
+        normals[(at2 + k) * 3] = vx * s;
+        normals[(at2 + k) * 3 + 1] = vy * s;
+        normals[(at2 + k) * 3 + 2] = vz * s;
       }
-      at += count;
+      at2 += count;
     }
     return { positions: positions2, normals, uvs };
   }
 
   // ../game-contracts/dist/index.js
+  var DEFAULT_BLAST_IMPULSE = { bodyArea: 0.7, lift: 0.15, minSpeed: 0.3, tntPerJoule: 0.24 / 2e5 };
   var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
   var DEFAULT_IGNITION_RULES = {
     fillCurve: [
@@ -3408,17 +3409,17 @@ var GameFloorplanThree = (() => {
       const index = geometry2.index ? geometry2.index.array : null;
       const count = index ? index.length : position.count;
       for (let item = 0; item < count; item++) {
-        const at = index ? index[item] : item;
-        vertex.fromBufferAttribute(position, at).applyMatrix4(matrix);
+        const at2 = index ? index[item] : item;
+        vertex.fromBufferAttribute(position, at2).applyMatrix4(matrix);
         positions2.push(vertex.x, vertex.y, vertex.z);
-        if (normalAttribute) normal.fromBufferAttribute(normalAttribute, at).applyMatrix3(normalMatrix2).normalize();
+        if (normalAttribute) normal.fromBufferAttribute(normalAttribute, at2).applyMatrix3(normalMatrix2).normalize();
         else normal.set(0, 1, 0);
         normals.push(normal.x, normal.y, normal.z);
         color2.copy(material2.color || color2.set(1, 1, 1)).convertLinearToSRGB();
         if (sample && uv && material2.map) {
           const repeat = material2.map.repeat;
-          const u = (uv.getX(at) * repeat.x % 1 + 1) % 1;
-          const v = (uv.getY(at) * repeat.y % 1 + 1) % 1;
+          const u = (uv.getX(at2) * repeat.x % 1 + 1) % 1;
+          const v = (uv.getY(at2) * repeat.y % 1 + 1) % 1;
           const pixelX = Math.min(sample.width - 1, u * sample.width | 0);
           const pixelY = Math.min(sample.height - 1, (1 - v) * sample.height | 0);
           const offset = (pixelY * sample.width + pixelX) * 4;
@@ -9871,8 +9872,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     // was `maquina`
   });
   var OWN_TYPES = Object.freeze({ lamp: true, gas_piped: true });
+  var sourceOf = (result) => result;
   var ADAPTER_VERSION = "0.3.0";
   var r3 = (n) => Math.round(n * 1e3) / 1e3;
+  var at = (it) => ({ x: it.x ?? 0, z: it.z ?? 0, ry: it.ry ?? 0 });
   function mergeRegistry(base, extra) {
     const out = { ...base };
     if (extra) {
@@ -9891,14 +9894,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   });
   function create2(options = {}) {
     const opts = options || {};
-    const GI = opts.GameInteractables;
-    const HH = opts.GameInteractablesHousehold;
     const locale = opts.locale || "pt-BR";
     const msg = createTranslator2(locale, opts.messages);
-    if (!GI || !HH) throw new Error(msg("error.missingKit"));
+    if (!opts.GameInteractables || !opts.GameInteractablesHousehold) throw new Error(msg("error.missingKit"));
+    const GI = opts.GameInteractables;
+    const HH = opts.GameInteractablesHousehold;
     const region = opts.region || "br";
     const hh = HH.createHousehold({ locale, region });
     const householdTypes = new Set(hh.types.map((t) => t.id));
+    const recorderApi = () => HH.createRecorder().api;
     const worlds = /* @__PURE__ */ new WeakMap();
     const typeMap = mergeRegistry(TYPE_MAP, opts.typeMap);
     const contentMap = mergeRegistry(CONTENT_MAP, opts.contentMap);
@@ -9934,7 +9938,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function colorOf(res, color2) {
       if (color2 == null) return void 0;
       if (typeof color2 === "number") return color2;
-      const v = res.colors && res.colors[color2];
+      const v = res.colors && res.colors[String(color2)];
       return typeof v === "number" ? v : void 0;
     }
     function paletteOf(res) {
@@ -9963,17 +9967,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       drawerItem: (s) => drawerItems.has(s.itemId)
     };
     const itemOfContent = (c) => {
-      const id = contentMap[c.itemId] || (hh.items[c.itemId] ? c.itemId : null) || contentByGroup[stackGroup(c)] || contentFallback;
+      const group = stackGroup(c);
+      const id = contentMap[c.itemId] || (hh.items[c.itemId] ? c.itemId : null) || (group != null ? contentByGroup[group] : void 0) || contentFallback;
       return hh.items[id] ? id : contentFallback;
     };
     const volume = (d) => d.size[0] * d.size[1] * d.size[2];
     const candidates = (id, objectType) => {
       const def = hh.items[id];
-      const siblings = Object.values(hh.items).filter((i) => i.category === def.category && i.id !== id).sort((a, b) => volume(a) - volume(b) || (a.id < b.id ? -1 : 1));
+      const siblings = Object.values(hh.items).filter((i) => i.category === def?.category && i.id !== id).sort((a, b) => volume(a) - volume(b) || (a.id < b.id ? -1 : 1));
       return [id].concat(siblings.map((i) => i.id), substitutes[objectType] || []);
     };
     function distribute(type, probeItem, stacks) {
-      const spec = hh.build(type, probeItem, HH.createRecorder().api);
+      const spec = hh.build(type, probeItem, recorderApi());
       const conts = spec.containers || [];
       const contents = {};
       for (const c of conts) contents[c.id] = c.slots.map(() => null);
@@ -10004,8 +10009,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       return { contents, rejected };
     }
-    function plan(res, popts = {}) {
-      popts = popts || {};
+    function plan(source, options2 = {}) {
+      const res = sourceOf(source);
+      const popts = options2 || {};
       const o = { ox: popts.originX || 0, oz: popts.originZ || 0, inw: popts.inw || 1, base: popts.base || 0 };
       const K = conv(o);
       const floorSel = popts.floor;
@@ -10069,7 +10075,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const item = {
           x: K.x(m.x),
           z: K.z(m.z),
-          ry: m.frontU != null ? K.ry(m.frontU, m.frontV) : r3(m.ry || 0),
+          ry: m.frontU != null ? K.ry(m.frontU, m.frontV ?? 0) : r3(m.ry || 0),
           w: m.w,
           d: m.d,
           h: m.h,
@@ -10082,7 +10088,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return item;
       }
       function entry2(id, type, item, origin, floor, extra) {
-        return Object.assign({ id, type, item, origin, floor, floorY: floorYOf(res, o, floor), connections: {} }, extra || {});
+        const e = { id, type, item, origin, floor, floorY: floorYOf(res, o, floor), connections: {} };
+        return Object.assign(e, extra || {});
       }
       function store(targets, stacks) {
         let rest2 = stacks || [];
@@ -10095,10 +10102,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       const hidden = [];
       function distRect(c, x, z) {
-        const dx = x - c.item.x;
-        const dz = z - c.item.z;
-        const s = Math.sin(c.item.ry);
-        const co = Math.cos(c.item.ry);
+        const ci = at(c.item);
+        const dx = x - ci.x;
+        const dz = z - ci.z;
+        const s = Math.sin(ci.ry);
+        const co = Math.cos(ci.ry);
         const lx = dx * co - dz * s;
         const lz = dx * s + dz * co;
         return Math.hypot(Math.max(Math.abs(lx) - (c.item.w || 0) / 2, 0), Math.max(Math.abs(lz) - (c.item.d || 0) / 2, 0));
@@ -10106,9 +10114,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       function hideCylinders() {
         for (const b of hidden) {
           let target = null;
+          const bi = at(b.item);
           for (const c2 of result.items) {
             if (c2.type !== "kitchen_cabinet_base" || c2.floor !== b.floor) continue;
-            const dist = distRect(c2, b.item.x, b.item.z);
+            const dist = distRect(c2, bi.x, bi.z);
             if (!target || dist < target.dist) target = { c: c2, dist };
           }
           if (!target) {
@@ -10116,16 +10125,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             continue;
           }
           const c = target.c;
-          const spec = hh.build(c.type, c.item, HH.createRecorder().api);
-          const sn = Math.sin(c.item.ry);
-          const cs = Math.cos(c.item.ry);
+          const spec = hh.build(c.type, c.item, recorderApi());
+          const ci = at(c.item);
+          const sn = Math.sin(ci.ry);
+          const cs = Math.cos(ci.ry);
           let door = null;
           for (const it of spec.interactions || []) {
-            const pt = it.action && it.action.do === "toggle_part" ? (spec.parts || []).find((q) => q.id === it.action.part) : null;
-            if (!pt || pt.motion.kind !== "hinge") continue;
-            const wx = c.item.x + it.pos[0] * cs + it.pos[2] * sn;
-            const wz = c.item.z - it.pos[0] * sn + it.pos[2] * cs;
-            const dist = Math.hypot(wx - b.item.x, wz - b.item.z);
+            const action = it.action;
+            const pt = action.do === "toggle_part" ? (spec.parts || []).find((q) => q.id === action.part) : null;
+            if (!pt || !pt.motion || pt.motion.kind !== "hinge") continue;
+            const wx = ci.x + it.pos[0] * cs + it.pos[2] * sn;
+            const wz = ci.z - it.pos[0] * sn + it.pos[2] * cs;
+            const dist = Math.hypot(wx - bi.x, wz - bi.z);
             if (!door || dist < door.dist) door = { id: pt.id, dist };
           }
           if (!door) {
@@ -10155,9 +10166,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const campCylinder = firstOfType("gas_canister");
       function planFireplace(m, e, item) {
         const def = hh.types.find((t) => t.id === "fireplace");
-        const lack = (def.d - m.d) / 2;
-        item.x = r3(item.x + Math.sin(item.ry) * lack);
-        item.z = r3(item.z + Math.cos(item.ry) * lack);
+        const lack = ((def ? def.d : m.d) - m.d) / 2;
+        const p = at(item);
+        item.x = r3(p.x + Math.sin(p.ry) * lack);
+        item.z = r3(p.z + Math.cos(p.ry) * lack);
         const room = (res.rooms || []).find((c) => c.id === m.room && c.floor === m.floor);
         const f = (res.floors || []).find((x) => x.index === m.floor);
         item.h = r3(room && room.ceiling || f && f.ceiling || 2.6);
@@ -10185,7 +10197,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           e.connections.gas = m.gas || "cylinder";
           e.connections.cylinder = m.cylinder || null;
         }
-        if (map.type === "gas_bottle") result.cylinders.push({ id: e.id, stove: m.link || null, place: m.placement || null });
+        if (map.type === "gas_bottle") result.cylinders.push({ id: e.id, stove: typeof m.link === "string" ? m.link : null, place: m.placement || null });
         if (map.type === "gas_canister") {
           result.canisters.push(e.id);
           if (campCylinder && campCylinder.id === m.id && campStove) result.cylinders.push({ id: e.id, stove: campStove.id, place: null });
@@ -10209,7 +10221,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         push(e);
       }
       function planCompound(m, kind) {
-        const ry = m.frontU != null ? K.ry(m.frontU, m.frontV) : r3(m.ry || 0);
+        const ry = m.frontU != null ? K.ry(m.frontU, m.frontV ?? 0) : r3(m.ry || 0);
         const cx = K.x(m.x);
         const cz = K.z(m.z);
         const part = (id, type, w, d, h, y, lx, lz) => {
@@ -10261,11 +10273,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         } else {
           const basin = part(m.id, "sink_bathroom", m.w, m.d, m.h + 0.2, 0, 0, 0);
           list2.push(basin);
-          if (contents[m.id]) {
-            if (contents[m.id].length) {
+          const own = contents[m.id];
+          if (own) {
+            if (own.length) {
               const cabinet = part(m.id + "#cabinet", "bathroom_cabinet", Math.max(0.45, Math.min(0.6, m.w)), 0.15, 0.75, 1.3, 0, -(m.d / 2) + 0.075);
               list2.push(cabinet);
-              store([["bathroom_cabinet", cabinet.item], ["sink_bathroom", basin.item]], contents[m.id]);
+              store([["bathroom_cabinet", cabinet.item], ["sink_bathroom", basin.item]], own);
             } else {
               store([["sink_bathroom", basin.item]], []);
             }
@@ -10305,7 +10318,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       result.chairs = [];
       if (opts.chairs !== false && popts.chairs !== false) {
         const blocked = blockedOf(res, { originX: o.ox, originZ: o.oz, inw: o.inw });
-        const floorKind = (q) => !q.decor && !q.flat && (q.y || 0) < 0.9 && q.aabb;
+        const floorKind = (q) => !q.decor && !q.flat && (q.y || 0) < 0.9 && !!q.aabb;
         const placed = [];
         const free = (m, cu, cv, half) => {
           const a = [cu - half + 0.03, cv - half + 0.03, cu + half - 0.03, cv + half - 0.03];
@@ -10321,8 +10334,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const m of res.items || []) {
           const mode = chairTables[m.type];
           if (!mode || !onFloor(m.floor, m.outdoor) || m.frontU == null) continue;
-          const f = [m.frontU, m.frontV];
-          const pp = [-m.frontV, m.frontU];
+          const fv = m.frontV ?? 0;
+          const f = [m.frontU, fv];
+          const pp = [-fv, m.frontU];
           const seats = [];
           if (mode === "dining") {
             const n = Math.max(1, Math.min(3, Math.floor((m.w - 0.1) / 0.55)));
@@ -10391,8 +10405,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const item = { x: K.x(s.u), z: K.z(s.v), ry: K.ry(s.frontU, s.frontV), y: s.y, seed: seedOf2(s.id) };
           item.controls = (s.controls || []).map((id) => id + ":lamp");
           const e = entry2(s.id, "wall_switch", item, s.id, s.floor);
-          e.connections.controls = (s.controls || []).slice();
-          e.lit = e.connections.controls.some((id) => (result.items.find((x) => x.id === id) || {}).lit === true);
+          const controls = (s.controls || []).slice();
+          e.connections.controls = controls;
+          e.lit = controls.some((id) => result.items.find((x) => x.id === id)?.lit === true);
           if (floorSel == null) {
             for (const id of s.controls || []) if (!lights.has(id)) result.warnings.push(msg("warn.switchUnknownLamp", { id: s.id, lamp: id }));
           }
@@ -10432,7 +10447,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             seed: seedOf2("panel"),
             circuits: circuits.map((c) => ({ id: c.id, label: c.room }))
           };
-          if (!item.circuits.length) delete item.circuits;
+          if (!item.circuits?.length) delete item.circuits;
           const e = entry2("panel", "electrical_panel", item, "panel", q.floor);
           push(e);
           result.panel = e.id;
@@ -10454,10 +10469,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
       const piped = result.items.filter((e) => e.type === "stove" && e.connections.gas === "piped");
-      if (piped.length) {
+      const firstPiped = piped[0];
+      if (firstPiped) {
         const med = utilities.gas && utilities.gas.meter;
-        const ref = med ? { x: K.x(med.u), z: K.z(med.v), y: med.y || 1 } : { x: piped[0].item.x, z: piped[0].item.z, y: 0.3 };
-        const e = entry2("piped_gas", "gas_piped", { x: ref.x, z: ref.z, ry: 0, y: ref.y, seed: seedOf2("piped_gas") }, "piped_gas", piped[0].floor);
+        const ref = med ? { x: K.x(med.u), z: K.z(med.v), y: med.y || 1 } : { x: firstPiped.item.x, z: firstPiped.item.z, y: 0.3 };
+        const e = entry2("piped_gas", "gas_piped", { x: ref.x, z: ref.z, ry: 0, y: ref.y, seed: seedOf2("piped_gas") }, "piped_gas", firstPiped.floor);
         e.floorY = o.base;
         push(e);
         for (const f of piped) f.connections.fuel = "piped_gas:gas";
@@ -10504,9 +10520,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const dv of spec.devices || []) if (L.outlet && dv.socket === "auto") dv.socket = L.outlet + ":socket";
       } else {
         const sh = L.shower || {};
-        const heater = (spec.devices || []).find((d) => d.id === "heater");
+        const devices = spec.devices || [];
+        const heater = devices.find((d) => d.id === "heater");
         if (heater && sh.electric === false) {
-          spec.devices = spec.devices.filter((d) => d !== heater);
+          spec.devices = devices.filter((d) => d !== heater);
           for (const f of spec.fixtures || []) if (f.heater === "heater") delete f.heater;
         } else if (heater) {
           if (sh.powerW) heater.watts = sh.powerW;
@@ -10517,7 +10534,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const b of spec.burners || []) if (b.fuel === "auto") b.fuel = L.fuel;
       }
       if (entry2.type === "fireplace" && L.chimneyTop) {
-        const it = entry2.item;
+        const it = at(entry2.item);
         const dx = L.chimneyTop[0] - it.x;
         const dz = L.chimneyTop[2] - it.z;
         const lx = Math.cos(it.ry) * dx - Math.sin(it.ry) * dz;
@@ -10536,8 +10553,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       return spec;
     }
-    function createWorld(res, copts = {}) {
-      copts = copts || {};
+    function createWorld(source, options2 = {}) {
+      const res = sourceOf(source);
+      const copts = options2 || {};
       const info = { points: /* @__PURE__ */ new Map(), water: copts.water || null, lightsOn: copts.lightsOn };
       const electrical = res.utilities && res.utilities.electrical;
       const world = GI.createWorld({
@@ -10565,8 +10583,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const info = worlds.get(world);
       return info ? info.points.get(fixtureId) : void 0;
     }
-    function blockedOf(res, bopts = {}) {
-      bopts = bopts || {};
+    function blockedOf(source, options2 = {}) {
+      const res = sourceOf(source);
+      const bopts = options2 || {};
       const ox = bopts.originX || 0;
       const oz = bopts.originZ || 0;
       const inw = bopts.inw || 1;
@@ -10601,33 +10620,33 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return false;
       };
     }
-    function add(world, planned, aopts = {}) {
-      aopts = aopts || {};
+    function add(world, planned, options2 = {}) {
+      const aopts = options2 || {};
       const info = worlds.get(world);
-      const build = aopts.build || ((type, item) => hh.build(type, item, HH.createRecorder().api));
+      const build = aopts.build || ((type, item) => hh.build(type, item, recorderApi()));
       const isBlocked = aopts.isBlocked || null;
       const out = { added: 0, parts: [], hinges: {}, moved: {}, warnings: [] };
       const override = aopts.lightsOn !== void 0 ? aopts.lightsOn : info && info.lightsOn;
       if (override !== void 0) {
         for (const e of planned.items) if (e.type === "lamp") e.lit = typeof override === "function" ? !!override(e.id, e) : !!override;
         for (const e of planned.items) if (e.type === "lantern_lamp") e.lit = typeof override === "function" ? !!override(e.id, e) : !!override;
-        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 === "wall_switch") e.lit = (e.connections.controls || []).some((id) => planned.items.find((x) => x.id === id)?.lit === true);
       }
       for (const e of planned.items) if (e.type === "lantern_lamp") e.item.on = !!e.lit;
       let scratch = null;
-      function probe(e, hinge, setback) {
+      function probe(e, hinge, setback, blockedAt) {
         if (!scratch) scratch = GI.createWorld({ locale, strings: hh.strings, items: hh.items, loot: hh.loot, grid: false });
-        const it = e.item;
+        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({}, it, { hinge }), HH.createRecorder().api);
+        const spec = hh.build(e.type, Object.assign({}, e.item, { hinge }), recorderApi());
         scratch.add("__probe", spec, { x, y: e.floorY, z, ry: it.ry });
-        const blocks = (px, pz) => isBlocked(px, pz, e.floor);
+        const blocks = (px, pz) => blockedAt(px, pz, e.floor);
         let sum = 0;
         let min = 1;
         let n = 0;
         for (const p of spec.parts || []) {
-          if (p.motion.kind !== "hinge" || !(p.bounds || p.sweep)) continue;
+          if (!p.motion || p.motion.kind !== "hinge" || !(p.bounds || p.sweep)) continue;
           const t = scratch.fitSweep("__probe", p.id, blocks);
           sum += t;
           min = Math.min(min, t);
@@ -10639,12 +10658,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const better = (a, b) => a.sum > b.sum + 1e-9 || Math.abs(a.sum - b.sum) <= 1e-9 && a.min > b.min + 1e-9;
       function fitDoors(e) {
         if (!isBlocked || !householdTypes.has(e.type)) return;
-        const standard = probe(e, void 0, 0);
+        const standard = probe(e, void 0, 0, isBlocked);
         if (!standard.n || standard.min >= 1) return;
         let bestSide;
         let m = standard;
         for (const side of ["left", "right"]) {
-          const r = probe(e, side, 0);
+          const r = probe(e, side, 0, isBlocked);
           if (better(r, m)) {
             m = r;
             bestSide = side;
@@ -10657,13 +10676,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (m.min >= 1) return;
         let target = { setback: 0, r: m };
         for (const setback of [0.01, 0.02, 0.03, 0.04]) {
-          const r = probe(e, bestSide, setback);
+          const r = probe(e, bestSide, setback, isBlocked);
           if (better(r, target.r)) target = { setback, r };
           if (r.min >= 1) break;
         }
         if (target.setback > 0 && target.r.sum > m.sum + 0.2) {
-          e.item.x = r3(e.item.x + Math.sin(e.item.ry) * target.setback);
-          e.item.z = r3(e.item.z + Math.cos(e.item.ry) * target.setback);
+          const p = at(e.item);
+          e.item.x = r3(p.x + Math.sin(p.ry) * target.setback);
+          e.item.z = r3(p.z + Math.cos(p.ry) * target.setback);
           e.moved = target.setback;
           out.moved[e.id] = target.setback;
         }
@@ -10686,7 +10706,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           }
         }
         connect(e, spec);
-        world.add(e.id, spec, { x: e.item.x, y: e.floorY, z: e.item.z, ry: e.item.ry });
+        const pose = at(e.item);
+        world.add(e.id, spec, { x: pose.x, y: e.floorY, z: pose.z, ry: pose.ry });
         out.added++;
         if (!isBlocked) continue;
         for (const p of spec.parts || []) {
@@ -10926,22 +10947,22 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         A.stats.external = Ne;
         let shadows = 0;
         for (let i = 0; i < N; i++) {
-          const g = asg[i], at = slotOf(i), b0 = LZU.uRB0.value, b1 = LZU.uRB1.value, b2 = LZU.uRB2.value, by = LZU.uRBY.value, ex = LZU.uREx.value;
+          const g = asg[i], at2 = slotOf(i), b0 = LZU.uRB0.value, b1 = LZU.uRB1.value, b2 = LZU.uRB2.value, by = LZU.uRBY.value, ex = LZU.uREx.value;
           A.crates[i] = g ? { k: g.k, rects: g.rects, y: g.y, exterior: !!g.exterior, exclusion: g.exclusion || null, d: g.d } : null;
           if (!g) {
             put(i, { intensity: 0 });
-            for (const a of [b0, b1, b2, ex]) a.set(EMPTY, at * 4);
-            by.set([0, 0], at * 2);
+            for (const a of [b0, b1, b2, ex]) a.set(EMPTY, at2 * 4);
+            by.set([0, 0], at2 * 2);
             continue;
           }
           const lamp = g.exterior ? { intensity: g.lumens, distance: g.dist, decay: g.decay } : { intensity: (7 + g.range * 0.8) * lim(1 + 0.4 * (Math.sqrt(g.n) - 1), 1, 2.2), distance: Math.max(3, g.dm * 1.3 + 0.5), decay: 1.6 };
           put(i, { position: g.pos, color: g.color, ...lamp });
           const rs = g.rects;
-          b0.set(rs[0] || EMPTY, at * 4);
-          b1.set(rs[1] || EMPTY, at * 4);
-          b2.set(rs[2] || EMPTY, at * 4);
-          by.set(g.y, at * 2);
-          ex.set(g.exclusion || EMPTY, at * 4);
+          b0.set(rs[0] || EMPTY, at2 * 4);
+          b1.set(rs[1] || EMPTY, at2 * 4);
+          b2.set(rs[2] || EMPTY, at2 * 4);
+          by.set(g.y, at2 * 2);
+          ex.set(g.exclusion || EMPTY, at2 * 4);
           if (i < NS) {
             shadows++;
             const s2 = g.house.group.uuid + "|" + g.k + "|" + g.pos.map((v) => v.toFixed(2)).join(",");
@@ -11016,10 +11037,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           for (const p of list2 || []) {
             if (isDoor && !(open.has(p.id) ? open.get(p.id) : !!p.open)) continue;
             const alongU = p.axis === "u", y = house.y0(p.floor) + (isDoor ? 1 : ((p.y0 != null ? p.y0 : 0.9) + (p.y1 != null ? p.y1 : 2)) / 2);
-            const at = (side) => _p.set(alongU ? p.at : p.pos + side, y, alongU ? p.pos + side : p.at).applyMatrix4(M).clone();
-            if (at(0).distanceTo(P0) > OPENING_REACH) continue;
+            const at2 = (side) => _p.set(alongU ? p.at : p.pos + side, y, alongU ? p.pos + side : p.at).applyMatrix4(M).clone();
+            if (at2(0).distanceTo(P0) > OPENING_REACH) continue;
             for (const side of [-OPENING_SIDE, OPENING_SIDE]) {
-              const w = at(side), hit = boxAt(boxes, w.x, w.y, w.z);
+              const w = at2(side), hit = boxAt(boxes, w.x, w.y, w.z);
               if (hit) into.set(hit.c, hit);
             }
           }
@@ -11027,11 +11048,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         reach(house.r.doors, true);
         reach(house.r.windows, false);
       };
-      const clear = (at) => {
-        for (const key of ["uRB0", "uRB1", "uRB2", "uREx"]) LZU[key].value.set(EMPTY, at * 4);
-        LZU.uRBY.value.set([0, 0], at * 2);
+      const clear = (at2) => {
+        for (const key of ["uRB0", "uRB1", "uRB2", "uREx"]) LZU[key].value.set(EMPTY, at2 * 4);
+        LZU.uRBY.value.set([0, 0], at2 * 2);
       };
-      const write = (at, into) => {
+      const write = (at2, into) => {
         const rs = [];
         let lo = 1e9, hi = -1e9;
         for (const q of into.values()) {
@@ -11043,21 +11064,21 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const r23 = rs.pop(), r1 = rs[rs.length - 1];
           rs[rs.length - 1] = [Math.min(r1[0], r23[0]), Math.min(r1[1], r23[1]), Math.max(r1[2], r23[2]), Math.max(r1[3], r23[3])];
         }
-        LZU.uRB0.value.set(rs[0] || EMPTY, at * 4);
-        LZU.uRB1.value.set(rs[1] || EMPTY, at * 4);
-        LZU.uRB2.value.set(rs[2] || EMPTY, at * 4);
-        LZU.uRBY.value.set([lo, hi], at * 2);
-        LZU.uREx.value.set(EMPTY, at * 4);
+        LZU.uRB0.value.set(rs[0] || EMPTY, at2 * 4);
+        LZU.uRB1.value.set(rs[1] || EMPTY, at2 * 4);
+        LZU.uRB2.value.set(rs[2] || EMPTY, at2 * 4);
+        LZU.uRBY.value.set([lo, hi], at2 * 2);
+        LZU.uREx.value.set(EMPTY, at2 * 4);
       };
       const A = {
         /** Once per frame, after the budget's `present`: points the mask of every lit slot that is not the house's at the rooms its light reaches. */
         update(houses2) {
           const indoors = cfg.effectLightsIndoors !== false, list2 = (Array.isArray(houses2) ? houses2 : [houses2]).filter(Boolean), cache2 = /* @__PURE__ */ new Map();
-          for (let at = 0; at < size; at++) {
-            if (ours.has(at)) continue;
-            const light = budget.group.children[at];
+          for (let at2 = 0; at2 < size; at2++) {
+            if (ours.has(at2)) continue;
+            const light = budget.group.children[at2];
             if (!indoors || !light || !light.isPointLight || !(light.intensity > 0) || !light.visible) {
-              clear(at);
+              clear(at2);
               continue;
             }
             const into = /* @__PURE__ */ new Map();
@@ -11072,8 +11093,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
               if (here) into.set(here.c, here);
               openingSides(house, M, boxes, into);
             }
-            if (into.size) write(at, into);
-            else clear(at);
+            if (into.size) write(at2, into);
+            else clear(at2);
           }
         }
       };
@@ -11430,11 +11451,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     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 severAt = (inp, root, at, gap) => {
+  var severAt = (inp, root, at2, 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(at - gap / 2, -half, half), hi = clamp(at + gap / 2, -half, half);
+    const lo = clamp(at2 - gap / 2, -half, half), hi = clamp(at2 + gap / 2, -half, half);
     const out = [];
     const stub = (from, to) => {
       if (to - from < 0.02) return;
@@ -13816,7 +13837,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const typed = listeners.get(e.type);
       if (typed) for (const fn of [...typed]) fn(e);
     };
-    const base = (o, source) => source === void 0 ? { object: o.id, time } : { object: o.id, time, source };
+    let blow;
+    const base = (o, source) => ({
+      object: o.id,
+      time,
+      ...source === void 0 ? {} : { source },
+      ...blow === void 0 ? {} : { blow }
+    });
     const pendingCollapse = /* @__PURE__ */ new Map();
     let runDepth = 0;
     const drainBlasts = () => {
@@ -14086,9 +14113,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const [lo, hi] = contactBox(p, above);
       return toWorld(p.pos, p.q, [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2]);
     };
-    const overSupportAt = (o, p, at, lower) => {
+    const overSupportAt = (o, p, at2, lower) => {
       const g = p.bend;
-      const local = toLocal(p.pos, p.q, at);
+      const local = toLocal(p.pos, p.q, at2);
       const depth = g.gravity >= 0 ? g.dims[g.gravity] : Math.min(...g.depthAxes.map((a) => g.dims[a]));
       let best = -1;
       let bestGap = depth;
@@ -14242,10 +14269,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const incoming = new Array(n).fill(0);
       const bending = new Array(n).fill(0);
       const through = parts.map(() => []);
-      const pass = (k, at, mass) => {
-        const over = overSupportAt(o, parts[k], at, lowerOf.get(k) ?? []);
+      const pass = (k, at2, mass) => {
+        const over = overSupportAt(o, parts[k], at2, lowerOf.get(k) ?? []);
         if (over < 0) bending[k] += mass;
-        else through[k].push({ at, mass, over });
+        else through[k].push({ at: at2, mass, over });
       };
       for (let h = queue.length - 1; h >= 0; h--) {
         const i = queue[h];
@@ -14312,7 +14339,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const terrain = cfg.terrains.get(cfg.terrain);
       if (!terrain) throw new Error(`unknown wind terrain "${cfg.terrain}"`);
       const inputs = [];
-      const at = /* @__PURE__ */ new Map();
+      const at2 = /* @__PURE__ */ new Map();
       const keep = [];
       let ground = Infinity, foundationTop = -Infinity;
       o.parts.forEach((p, i) => {
@@ -14321,7 +14348,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const role = p.spec.structure?.role;
         const e = p.mat.strength?.elasticGPa;
         const kind = role === "wall" ? "wall" : role === "column" ? "column" : role === "beam" ? "beam" : role === "foundation" ? "foundation" : "other";
-        at.set(i, inputs.length);
+        at2.set(i, inputs.length);
         keep.push(i);
         ground = Math.min(ground, box3.min[1]);
         if (kind === "foundation") foundationTop = Math.max(foundationTop, box3.max[1]);
@@ -14332,7 +14359,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const beams = [];
         for (const j of o.byPart.get(o.parts[i].spec.id)) {
           if (j.st.open) continue;
-          const b = at.get(j.ia === i ? j.ib : j.ia);
+          const b = at2.get(j.ia === i ? j.ib : j.ia);
           if (b !== void 0 && inputs[b].kind === "beam") beams.push(b);
         }
         inputs[k].beams = beams;
@@ -15148,7 +15175,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
     };
     const tornToEdge = (o) => {
-      const { p, cell, a, b, at, crater: crater2, reach, gone } = o;
+      const { p, cell, a, b, at: at2, crater: crater2, reach, gone } = o;
       const half = p.dims[a] / 2;
       const lo = cell.center[a] - cell.size[a] / 2, hi = cell.center[a] + cell.size[a] / 2;
       const free = (side, sign2) => {
@@ -15156,8 +15183,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const probe = side + sign2 * 1e-3;
         return gridOf(p).some((c, k) => gone(k) && Math.abs(probe - c.center[a]) <= c.size[a] / 2 && Math.abs(cell.center[b] - c.center[b]) <= c.size[b] / 2);
       };
-      if (at - lo <= reach && free(lo, -1)) return [lo, Math.max(crater2[1], lo)];
-      if (hi - at <= reach && free(hi, 1)) return [Math.min(crater2[0], hi), hi];
+      if (at2 - lo <= reach && free(lo, -1)) return [lo, Math.max(crater2[1], lo)];
+      if (hi - at2 <= reach && free(hi, 1)) return [Math.min(crater2[0], hi), hi];
       return crater2;
     };
     const craterAcross = (energy) => clamp2(0.03 + 12e-4 * Math.sqrt(Math.max(0, energy)), 0.03, 0.14);
@@ -15367,7 +15394,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return;
       }
       if (ex) {
-        emit({ ...base(o, src), type: "explode", part: p.spec.id, point: c, energy: ex.energy, radius: ex.radius, ...ex.lethalRadius !== void 0 ? { lethalRadius: ex.lethalRadius } : {}, ...ex.effect !== void 0 ? { effect: ex.effect } : {} });
+        emit({ ...base(o, src), type: "explode", part: p.spec.id, point: c, energy: ex.energy, radius: ex.radius, ...ex.lethalRadius !== void 0 ? { lethalRadius: ex.lethalRadius } : {}, ...ex.tnt !== void 0 ? { tnt: ex.tnt } : {}, ...ex.effect !== void 0 ? { effect: ex.effect } : {} });
         blasts.push({ point: c, energy: ex.energy, radius: ex.radius, ...ex.lethalRadius !== void 0 ? { lethalRadius: ex.lethalRadius } : {}, source: src });
       }
       partLost(o, p, src);
@@ -15961,7 +15988,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       res.events = cur.slice(start);
       return res;
     };
-    const doHit = (o, hit, only) => {
+    const withBlow = (type, fn) => () => {
+      const outer = blow;
+      blow = type;
+      try {
+        return fn();
+      } finally {
+        blow = outer;
+      }
+    };
+    const doHit = (o, hit, only) => withBlow(hit.type, () => resolveHit(o, hit, only))();
+    const resolveHit = (o, hit, only) => {
       let point = hit.point;
       let dir = hit.direction;
       if (hit.space === "local") {
@@ -16400,6 +16437,44 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       blastProbe() {
         return { ...blastProbe };
       },
+      blastReach(point, target, options2 = {}) {
+        const L = vec.distance(point, target);
+        if (L < 1e-4) return 1;
+        const shelter = { ...SHELTER_DEFAULTS, ...options2.shelter };
+        const ignore = new Set(options2.ignore ?? []);
+        const d = vec.scale(vec.sub(target, point), 1 / L);
+        let t = 1;
+        for (const o of objects.values()) {
+          if (ignore.has(o.id) || raySphereMiss(point, d, toWorld(o.st.position, o.st.rotation, o.bc), o.br, L)) continue;
+          for (const p of o.parts) {
+            if (isLost(p) || p.st.stripped) continue;
+            const r = rayPart(o, p, point, d);
+            if (!r) continue;
+            const t0 = Math.max(r.t0, 0);
+            const path = Math.min(r.t1, L) - t0;
+            if (path < shelter.minPath) continue;
+            if (p.st.opening && insideOpening(o, p, toLocal(o.st.position, o.st.rotation, vec.madd(point, d, t0 + path / 2)))) continue;
+            t *= Math.exp(-(p.mat.hpPerKg * p.mat.density * path * (p.mat.damageScale?.shelter ?? 1)) / shelter.k);
+            if (t < 1e-4) return 0;
+          }
+        }
+        for (const im of impls.values()) {
+          if (ignore.has(im.impl.id)) continue;
+          for (const ps of im.impl.describe().parts) {
+            const mat = materials.get(ps.material);
+            if (!mat) continue;
+            const ov = im.poses.get(ps.id);
+            const r = rayPartRaw(im.position, im.rotation, ps, ov?.q ?? quatFromEuler(...ps.rotation ?? [0, 0, 0]), point, d, ov?.pos);
+            if (!r || r.t1 < 0 || r.t0 > L) continue;
+            let path = Math.min(r.t1, L) - Math.max(r.t0, 0);
+            if (ps.thickness !== void 0 && ps.thickness > 0) path = Math.min(path, 2 * ps.thickness);
+            else if (path < shelter.minPath) continue;
+            t *= Math.exp(-(mat.hpPerKg * mat.density * path * (mat.damageScale?.shelter ?? 1)) / shelter.k);
+            if (t < 1e-4) return 0;
+          }
+        }
+        return t;
+      },
       explode(point, energy, radius, source, blast) {
         blastProbe.partsTested = 0;
         blastProbe.partsNear = 0;
@@ -16424,7 +16499,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       },
       shoot(origin, direction, energy, caliber, source, round3) {
         const extras = typeof round3 === "number" ? { piercing: round3 } : round3 ?? {};
-        return withCollapses(run(() => {
+        return withCollapses(run(withBlow("ballistic", () => {
           const results = [];
           const d = vec.normalize(direction);
           const ignore = /* @__PURE__ */ new Set();
@@ -16435,10 +16510,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             if (!rh) break;
             const im = impls.get(rh.object);
             if (im) {
-              const r = implHit(im, { type: "ballistic", point: rh.point, part: rh.part, normal: rh.normal, direction: d, energy: E, caliber, ...extras, ...source !== void 0 ? { source } : {} });
+              const scaled = extras.penetration && E < energy ? { ...extras, penetration: Object.fromEntries(Object.entries(extras.penetration).map(([k, mm]) => [k, mm * (E / energy)])) } : extras;
+              const r = implHit(im, { type: "ballistic", point: rh.point, part: rh.part, normal: rh.normal, direction: d, energy: E, caliber, ...scaled, ...source !== void 0 ? { source } : {} });
               r.part = rh.part;
               r.point = rh.point;
-              r.exitEnergy = r.penetrated ? E * 0.5 : 0;
+              const left = r.events.find((e) => e.type === "hole" && e.energyLeft !== void 0);
+              r.exitEnergy = r.penetrated ? left?.energyLeft ?? E * 0.5 : 0;
               results.push(r);
               ignore.add(`${im.impl.id}\0${rh.part}`);
               if (!r.penetrated) break;
@@ -16457,7 +16534,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             E = out.exitEnergy;
           }
           return results;
-        }));
+        })));
       },
       disassemble(objectId, jointId, tool, dt) {
         const im = impls.get(objectId);
@@ -16765,8 +16842,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       list: () => defs,
       get,
       register(def) {
-        const at = defs.findIndex((a) => a.id === def.id);
-        if (at >= 0) defs[at] = def;
+        const at2 = defs.findIndex((a) => a.id === def.id);
+        if (at2 >= 0) defs[at2] = def;
         else defs.push(def);
       },
       part: (assemblyId, options) => buildAssemblyPart(get(assemblyId), assemblyId, options)
@@ -17837,9 +17914,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     if (context.isTimber && construction.roof.shape !== "slab") addCeilingJoists(context);
   }
+  var isStair = (item) => item.category === "stairs" && typeof item.link === "object" && item.link !== null;
   function flightsOf(items) {
     const flights = /* @__PURE__ */ new Map();
-    for (const item of items.filter((it) => it.category === "stairs" && it.link)) {
+    for (const item of items.filter(isStair)) {
       const key = `${item.link.from}_${item.link.to}`;
       if (!flights.has(key) || item.floor === item.link.from) flights.set(key, item);
     }
@@ -20219,17 +20297,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const { c, part, units: units2, thick, mid } of shown) {
           if (!near(c)) continue;
           const centre = mask.start + (c.a + c.b) / 2, y = (c.y0 + c.y1) / 2, len = c.b - c.a, h = c.y1 - c.y0;
-          const at = (s, dy, d, colour) => {
+          const at2 = (s, dy, d, colour) => {
             const unit = clipToBox({ x: mask.alongU ? centre : mid, y, z: mask.alongU ? mid : centre, sx: mask.alongU ? s : d, sy: dy, sz: mask.alongU ? d : s, colour }, view.bounds);
             if (unit) list2.push(unit);
           };
           const base = fragmentMaterial(part.material).color.getHex();
           const n = noise2(centre * 3.1, y * 2.7, 0.07);
           if (units2.mortar === "concrete") {
-            at(len, h, thick - 2 * COVER2, tone(base, 0.9 + 0.04 * n));
+            at2(len, h, thick - 2 * COVER2, tone(base, 0.9 + 0.04 * n));
           } else {
-            at(len, h, thick - 2 * COVER2 - 0.012, 10327948);
-            at(len - 0.012, h - 0.012, thick - 2 * COVER2, tone(base, 0.8 + 0.35 * n));
+            at2(len, h, thick - 2 * COVER2 - 0.012, 10327948);
+            at2(len - 0.012, h - 0.012, thick - 2 * COVER2, tone(base, 0.8 + 0.35 * n));
           }
         }
         if (view.units) {
@@ -20545,11 +20623,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       };
       const extract = (it) => {
         const g0 = it.mesh.geometry, src = it.mesh.userData._p0 || g0.attributes.position.array, g = new THREE.BufferGeometry();
-        const at = (name, k, arr) => g.setAttribute(name, new THREE.BufferAttribute((arr || g0.attributes[name].array).slice(it.v0 * k, it.v1 * k), k));
-        at("position", 3, src);
-        at("normal", 3);
-        at("color", 3);
-        at("uv", 2);
+        const at2 = (name, k, arr) => g.setAttribute(name, new THREE.BufferAttribute((arr || g0.attributes[name].array).slice(it.v0 * k, it.v1 * k), k));
+        at2("position", 3, src);
+        at2("normal", 3);
+        at2("color", 3);
+        at2("uv", 2);
         const ix = g0.index.array.slice(it.i0, it.i1);
         for (let k = 0; k < ix.length; k++) ix[k] -= it.v0;
         g.setIndex(new THREE.BufferAttribute(ix, 1));
@@ -21264,9 +21342,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             shared.vegMaterials.setActors(focus ? [{ x: focus.x, y: focus.y, z: focus.z, radius: 0.9 }] : []);
           }
           if (focus && cfg.lod !== false) {
-            const L = Object.assign({ interior: 45, hide: 220 }, cfg.lod), d = distance2(focus), at = h.lodCurrent;
+            const L = Object.assign({ interior: 45, hide: 220 }, cfg.lod), d = distance2(focus), at2 = h.lodCurrent;
             let n = d > L.hide ? 2 : d > L.interior ? 1 : 0;
-            if (n < at) n = d < (at === 2 ? L.hide : L.interior) * 0.92 ? n : at;
+            if (n < at2) n = d < (at2 === 2 ? L.hide : L.interior) * 0.92 ? n : at2;
             applyLod(Math.max(n, h.lodMin));
           }
         },
@@ -22017,14 +22095,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
 
   // src/test-area/scenarios.ts
   var SPECIMEN_AT = [-5, 0, -11];
-  function createHouseScenarios(text, at = SPECIMEN_AT) {
+  function createHouseScenarios(text, at2 = SPECIMEN_AT) {
     const T2 = text.steps;
     const spawn = (room, item) => {
-      const so = room.spawn(item, [at[0], at[1], at[2]], 0);
+      const so = room.spawn(item, [at2[0], at2[1], at2[2]], 0);
       const parts = so.root.userData.floorplanSpec.parts;
       const centre = (id) => {
         const p = parts.find((x) => x.id === id);
-        return [p.position[0] + at[0], p.position[1] + at[1], p.position[2] + at[2]];
+        return [p.position[0] + at2[0], p.position[1] + at2[1], p.position[2] + at2[2]];
       };
       return { oid: so.objectId, parts, centre };
     };
@@ -22399,9 +22477,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
     const eyeOf = (p) => {
       const camera = host?.camera;
-      const at = toLocal2(p, camera.position.x, camera.position.y, camera.position.z);
+      const at2 = toLocal2(p, camera.position.x, camera.position.y, camera.position.z);
       const forward = new THREE.Vector3(0, 0, -1).applyQuaternion(camera.quaternion).transformDirection(new THREE.Matrix4().copy(p.house.group.matrixWorld).invert());
-      return { x: at.x, y: at.y, z: at.z, floor: floorOf(p, camera.position.y), yaw: Math.atan2(forward.x, forward.z), pitch: Math.asin(Math.max(-1, Math.min(1, forward.y))) };
+      return { x: at2.x, y: at2.y, z: at2.z, floor: floorOf(p, camera.position.y), yaw: Math.atan2(forward.x, forward.z), pitch: Math.asin(Math.max(-1, Math.min(1, forward.y))) };
     };
     const blocked = (x, z, radius) => {
       for (const p of placed) {
@@ -22469,7 +22547,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const doorReach = (p, fo) => {
       const g = fo.gs[0];
       const pivot = fo.handles[0].pivot;
-      const at = (angle) => {
+      const at2 = (angle) => {
         const c = Math.cos(angle);
         const s = Math.sin(angle);
         const v = new THREE.Vector3(pivot[0] * c + pivot[2] * s, pivot[1], -pivot[0] * s + pivot[2] * c).add(g.position);
@@ -22478,8 +22556,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const camera = host?.camera;
       const eye = new THREE.Vector3(camera.position.x, 0, camera.position.z);
       const flat = (v) => Math.hypot(v.x - eye.x, v.z - eye.z);
-      const closed = at(0);
-      const open = at(fo.rot);
+      const closed = at2(0);
+      const open = at2(fo.rot);
       const opening = !fo.open;
       return {
         handle: () => {
@@ -23187,8 +23265,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       facadeExtra: (f, rng2, w, d, op) => {
         f.roof = "slab";
         f.finish = rng2() < 0.55 ? "exposed_block" : "partial_plaster";
-        f.slab = { exposedRebar: true, waterTank: { u: r22(0.5 + rng2() * (w - 1.5)), v: r22(1 + rng2() * (d - 2)) }, annex: rng2() < 0.55 ? { rect: [0, 0, r22(w * (0.5 + rng2() * 0.3)), r22(d * 0.4)], state: "exposed_brick" } : null };
-        if (floorsOf(op) > 1) f.slab.exposedRebar = rng2() < 0.6;
+        const slab = { exposedRebar: true, waterTank: { u: r22(0.5 + rng2() * (w - 1.5)), v: r22(1 + rng2() * (d - 2)) }, annex: rng2() < 0.55 ? { rect: [0, 0, r22(w * (0.5 + rng2() * 0.3)), r22(d * 0.4)], state: "exposed_brick" } : null };
+        f.slab = slab;
+        if (floorsOf(op) > 1) slab.exposedRebar = rng2() < 0.6;
       }
     };
   }
@@ -23900,13 +23979,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   function apartment(strip, floor, k, from, to, plate, ceiling, win) {
     const wide = to - from, depth = strip.depth, facade = r22(depth * 0.56);
     const id = (name) => `apt_${floor}_${strip.id}_${k}_${name}`;
-    const at = (f0, f1, b0, b1) => boxOf2(strip, r22(from + wide * f0), r22(from + wide * f1), b0, b1);
+    const at2 = (f0, f1, b0, b1) => boxOf2(strip, r22(from + wide * f0), r22(from + wide * f1), b0, b1);
     const rooms = [
-      { id: id("living"), type: "living", label: "living", library: "living_tower", rect: at(0, 0.58, 0, facade) },
-      { id: id("bedroom"), type: "bedroom", label: "bedroom", rect: at(0.58, 1, 0, facade) },
-      { id: id("kitchen"), type: "kitchen", label: "kitchen", library: "kitchen_integrated", rect: at(0, 0.4, facade, depth) },
-      { id: id("hall"), type: "hall", label: "hall", rect: at(0.4, 0.78, facade, depth) },
-      { id: id("bath"), type: "bathroom", label: "bathroom", library: "bathroom_wc", rect: at(0.78, 1, facade, depth) }
+      { id: id("living"), type: "living", label: "living", library: "living_tower", rect: at2(0, 0.58, 0, facade) },
+      { id: id("bedroom"), type: "bedroom", label: "bedroom", rect: at2(0.58, 1, 0, facade) },
+      { id: id("kitchen"), type: "kitchen", label: "kitchen", library: "kitchen_integrated", rect: at2(0, 0.4, facade, depth) },
+      { id: id("hall"), type: "hall", label: "hall", rect: at2(0.4, 0.78, facade, depth) },
+      { id: id("bath"), type: "bathroom", label: "bathroom", library: "bathroom_wc", rect: at2(0.78, 1, facade, depth) }
     ];
     const doors = [
       stripDoor(id("hall"), strip, floor, 0.95),
@@ -23939,8 +24018,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     if (strip.id !== "south") return apartments(plan)(strip, context);
     const { floor, plate, ceiling } = context;
     const lobby = `lobby_${floor}_entrance`, concierge = `concierge_${floor}`, bikes = `bike_room_${floor}`;
-    const at = (f0, f1) => boxOf2(strip, r22(strip.length * f0), r22(strip.length * f1), 0, strip.depth);
-    const [left, middle, right] = [at(0, 0.3), at(0.3, 0.7), at(0.7, 1)];
+    const at2 = (f0, f1) => boxOf2(strip, r22(strip.length * f0), r22(strip.length * f1), 0, strip.depth);
+    const [left, middle, right] = [at2(0, 0.3), at2(0.3, 0.7), at2(0.7, 1)];
     const rooms = [
       { id: concierge, type: "office", label: "concierge", rect: left },
       { id: lobby, type: "hall", label: "lobby_entrance", rect: middle },