@adatechnology/game-floorplan-three 0.9.3 → 0.10.1

package/dist/index.global.js

@@ -3,6 +3,7 @@ var GameFloorplanThree = (() => {
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,6 +17,7 @@ var GameFloorplanThree = (() => {
     return to;
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
   // src/index.ts
   var index_exports = {};
@@ -70,7 +72,7 @@ var GameFloorplanThree = (() => {
     shade: () => shade
   });
 
-  // ../game-shapes/dist/chunk-M5N2SHNL.js
+  // ../game-shapes/dist/chunk-FZQTELDQ.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));
@@ -982,17 +984,19 @@ var GameFloorplanThree = (() => {
     if (p.prevZ) p.prevZ.nextZ = p.nextZ;
     if (p.nextZ) p.nextZ.prevZ = p.prevZ;
   }
-  function Node(i, x, y) {
-    this.i = i;
-    this.x = x;
-    this.y = y;
-    this.prev = null;
-    this.next = null;
-    this.z = 0;
-    this.prevZ = null;
-    this.nextZ = null;
-    this.steiner = false;
-  }
+  var Node = class {
+    constructor(i, x, y) {
+      this.i = i;
+      this.x = x;
+      this.y = y;
+      this.prev = null;
+      this.next = null;
+      this.z = 0;
+      this.prevZ = null;
+      this.nextZ = null;
+      this.steiner = false;
+    }
+  };
   function signedArea(data, start, end, dim) {
     let sum = 0;
     for (let i = start, j = end - dim; i < end; i += dim) {
@@ -1817,6 +1821,9 @@ var GameFloorplanThree = (() => {
       return mesh2;
     });
   }
+  function isMesh(o) {
+    return !!o && o.isMesh === true;
+  }
 
   // ../game-props3d/dist/index.js
   function rng(seed) {
@@ -3691,6 +3698,20 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const WITH_MAP = { roughcast: 1, block: 1 };
     class Accumulator {
       constructor() {
+        __publicField(this, "cv");
+        __publicField(this, "ci");
+        __publicField(this, "p");
+        __publicField(this, "n");
+        __publicField(this, "c");
+        __publicField(this, "u");
+        __publicField(this, "i");
+        __publicField(this, "nv");
+        __publicField(this, "ni");
+        __publicField(this, "lim");
+        __publicField(this, "cur");
+        __publicField(this, "piece0");
+        __publicField(this, "mat", "");
+        __publicField(this, "group", "");
         this.cv = 2048;
         this.ci = 3072;
         this.p = new Float32Array(this.cv * 3);
@@ -3753,7 +3774,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       g.position.copy(u.pose0.p);
       g.quaternion.copy(u.pose0.q);
       g.scale.copy(u.pose0.s);
-      const e = new THREE.Vector3(...a.axis || [0, 1, 0]);
+      const [ax, ay, az] = a.axis || [0, 1, 0];
+      const e = new THREE.Vector3(ax, ay, az);
       if (a.type === "swing" || a.type === "toggle") g.rotateOnAxis(e, (a.angle || 0) * t);
       else if (a.type === "slide") g.translateOnAxis(e, (a.dist || 0) * t);
       else if (a.type === "scale") {
@@ -3848,7 +3870,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         if (uvr) {
           let gu = G.u[k * 2], gv = G.u[k * 2 + 1];
-          for (let r = uvr.rot | 0; r > 0; r--) {
+          for (let r = (uvr.rot ?? 0) | 0; r > 0; r--) {
             const t = gu;
             gu = gv;
             gv = 1 - t;
@@ -3946,14 +3968,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       A.nv += n;
     }
     let bxImpl = bxBase;
-    function bx(...a) {
-      return bxImpl(...a);
-    }
-    K.getBx = () => bxImpl;
-    K.setBx = (f) => {
+    const bx = (...a) => bxImpl(...a);
+    const getBx = () => bxImpl;
+    const setBx = (f) => {
       bxImpl = f;
     };
-    Object.assign(K, { GEO, UV_SCALE, WITH_MAP, Accumulator, cursor, PARTS, MIRRORS, part, applyPart, _Y, _qa, _qb, pieceRecord, structurePiece, accFor, _q, _e, _col, rgbOf, put, boxC, bx, cylBase, polyFace });
+    const defined = { GEO, UV_SCALE, WITH_MAP, Accumulator, cursor, PARTS, MIRRORS, part, applyPart, _Y, _qa, _qb, pieceRecord, structurePiece, accFor, _q, _e, _col, rgbOf, put, boxC, bx, getBx, setBx, cylBase, polyFace };
+    Object.assign(K, defined);
   }
 
   // src/kernel/noise.ts
@@ -3971,17 +3992,20 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const n = 0.5 * vnoise(x / 5.5, z / 5.5) + 0.32 * vnoise(x / 1.9 + 31, z / 1.9) + 0.18 * vnoise(x / 0.8 + 7, z / 0.8), m = vnoise(x / 9 + 100, z / 9 + 50) - 0.5, f = 0.76 + 0.5 * n;
       return type === "dirt" ? [f * (1 + 0.14 * m), f * (1 + 0.03 * m), f * (1 - 0.18 * m)] : [f * (1 + 0.1 * m), f * (1 + 0.05 * m), f * (1 - 0.1 * m)];
     }
-    Object.assign(K, { _h2, vnoise, macroGround });
+    const defined = { _h2, vnoise, macroGround };
+    Object.assign(K, defined);
   }
 
   // src/materials/textures.ts
   function installMaterialsTextures(K, _shared) {
     const { DOC, THREE, cfg } = K;
     function texture(n, f, rep = true, rx = 1, ry = 1) {
+      if (!DOC) throw new Error("game-floorplan-three: the procedural textures need a document (options.document)");
       const c = DOC.createElement("canvas");
       c.width = n;
       c.height = n;
       const g = c.getContext("2d");
+      if (!g) throw new Error("game-floorplan-three: no 2d canvas context");
       f(g, n);
       const t = new THREE.CanvasTexture(c);
       t.colorSpace = THREE.SRGBColorSpace;
@@ -4100,10 +4124,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const TEX = {};
     for (const k of Object.keys(TEXGEN)) TEX[k] = cfg.textures && cfg.textures[k] || TEXGEN[k]();
     const ATLAS = {};
-    Object.assign(K, { texture, rngTexture, TEXGEN, TEX, ATLAS });
+    const defined = { texture, rngTexture, TEXGEN, TEX, ATLAS };
+    Object.assign(K, defined);
   }
 
   // src/materials/materials.ts
+  function context2d(c) {
+    const g = c.getContext("2d");
+    if (!g) throw new Error("game-floorplan-three: no 2d canvas context");
+    return g;
+  }
   function installMaterialsMaterials(K, _shared) {
     const { THREE, cfg, ATLAS, TEX, rngTexture } = K;
     function createMaterials(props) {
@@ -4115,7 +4145,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return t;
       };
       if (!(cfg.atlas && cfg.atlas.floorKind)) {
-        const pc = props.atlas("floor").canvas, g = pc.getContext("2d");
+        const pc = props.atlas("floor").canvas, g = context2d(pc);
         for (const c of [0, 1]) {
           g.save();
           g.globalCompositeOperation = "screen";
@@ -4130,7 +4160,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         g.restore();
       }
       if (!(cfg.atlas && cfg.atlas.floorKind)) {
-        const pc = props.atlas("floor").canvas, g = pc.getContext("2d");
+        const pc = props.atlas("floor").canvas, g = context2d(pc);
         g.save();
         g.fillStyle = "rgba(128,92,62,0.52)";
         g.fillRect(256, 256, 256, 256);
@@ -4227,7 +4257,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     const ORDER = { glass: 3, water: 2, screen: 3, building: 4 };
     const NO_SHADOW = /* @__PURE__ */ new Set(["dirt", "glass", "water", "screen", "building", "picture", "floor", "emissive"]);
-    Object.assign(K, { createMaterials, antiTile, dirtMaterial, CLOTHES_UNIFORMS, clothesMaterial, ORDER, NO_SHADOW });
+    const defined = { createMaterials, antiTile, dirtMaterial, CLOTHES_UNIFORMS, clothesMaterial, ORDER, NO_SHADOW };
+    Object.assign(K, defined);
   }
 
   // src/kernel/close-scene.ts
@@ -4238,15 +4269,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const assembleVegetation = (...a) => K.assembleVegetation(...a);
     function markMesh(m, A) {
       const L = A.lim, fx = [];
+      const pieces = shared.ctx.pieces;
       for (let k = 0; k < L.length; k++) {
-        if (!L[k].pc) continue;
-        const v1 = k + 1 < L.length ? L[k + 1].v : A.nv, i1 = k + 1 < L.length ? L[k + 1].i : A.ni;
-        if (v1 > L[k].v) fx.push({ id: L[k].pc.id, v0: L[k].v, v1, i0: L[k].i, i1 });
+        const lim = L[k], pc = lim.pc;
+        if (!pc) continue;
+        const next = L[k + 1];
+        const v1 = next ? next.v : A.nv, i1 = next ? next.i : A.ni;
+        if (v1 > lim.v) fx.push({ id: pc.id, v0: lim.v, v1, i0: lim.i, i1 });
       }
       if (!fx.length) return;
       const u = m.userData, ids = [...new Set(fx.map((f) => f.id))], weight = {};
       for (const f of fx) {
-        const mt = shared.ctx.pieces.get(f.id).mat;
+        const mt = pieces.get(f.id).mat;
         weight[mt] = (weight[mt] || 0) + f.v1 - f.v0;
       }
       u.ranges = fx;
@@ -4254,7 +4288,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       u.destructionMaterial = Object.keys(weight).sort((a, b) => weight[b] - weight[a])[0];
       if (ids.length === 1) {
         u.destructionPart = ids[0];
-        const pc = shared.ctx.pieces.get(ids[0]);
+        const pc = pieces.get(ids[0]);
         if (pc.role) u.structuralRole = pc.role;
       }
     }
@@ -4305,7 +4339,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       assembleVegetation(groups);
       return groups;
     }
-    Object.assign(K, { markMesh, closeScene });
+    const defined = { markMesh, closeScene };
+    Object.assign(K, defined);
   }
 
   // src/house/helpers.ts
@@ -4343,8 +4378,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       for (const h of holes) L = L.flatMap((r) => subRect(r, h));
       return L;
     }
-    const wallColor = (c) => c && c.color && colorOf(c.color.wall) != null ? colorOf(c.color.wall) : 14999768;
-    const floorColor = (c) => c && c.color && colorOf(c.color.floor) != null ? colorOf(c.color.floor) : 11577496;
+    const wallColor = (c) => {
+      const k = c && c.color ? colorOf(c.color.wall) : null;
+      return k != null ? k : 14999768;
+    };
+    const floorColor = (c) => {
+      const k = c && c.color ? colorOf(c.color.floor) : null;
+      return k != null ? k : 11577496;
+    };
     function stairFootprint(m) {
       const c = Math.cos(m.ry), s = Math.sin(m.ry), pts = [[-m.w / 2, -m.d / 2], [m.w / 2, -m.d / 2], [m.w / 2, m.d / 2], [-m.w / 2, m.d / 2]].map(([a, b]) => [m.x + a * c + b * s, m.z - a * s + b * c]);
       return [Math.min(...pts.map((p) => p[0])), Math.min(...pts.map((p) => p[1])), Math.max(...pts.map((p) => p[0])), Math.max(...pts.map((p) => p[1]))];
@@ -4355,12 +4396,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const pitch = A[f + 1].y0 - A[f].y0;
       return h > pitch && h - pitch <= 0.45 ? pitch : h;
     }
-    Object.assign(K, { OPEN_ROOM_TYPES: OPEN_ROOM_TYPES3, NO_CEILING, OPEN_AREA, EPS: EPS3, Y0, colorOf, rectsOf: rectsOf2, roomAt, subRect, subRects, wallColor, floorColor, stairFootprint, effectiveHeight });
+    const defined = { OPEN_ROOM_TYPES: OPEN_ROOM_TYPES3, NO_CEILING, OPEN_AREA, EPS: EPS3, Y0, colorOf, rectsOf: rectsOf2, roomAt, subRect, subRects, wallColor, floorColor, stairFootprint, effectiveHeight };
+    Object.assign(K, defined);
   }
 
   // src/house/walls.ts
   function installHouseWalls(K, shared) {
     const { EPS: EPS3, Y0, boxC, bx, cursor, effectiveHeight, pieceRecord, structurePiece, wallColor } = K;
+    const sh = (...a) => K.sh(...a);
     function wallBox2(alongU, L, a, b, ya, yb, th, cL, cH, mL, mH) {
       if (yb - ya < 1e-4 || b - a < 1e-4) return;
       if (alongU) {
@@ -4404,8 +4447,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function walls() {
       const R = shared.ctx.r, cut = shared.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;
+        const f = w.floor, colliders = shared.ctx.colliders;
         cursor.group = "f" + f;
         cursor.pc = pieceOf(w);
         const y0 = Y0(f), pitch = f + 1 < nA ? Y0(f + 1) - y0 : Infinity, th = w.thickness || 0.15, alongU = w.axis === "u";
@@ -4413,7 +4457,11 @@ 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);
-        shared.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.id) {
+          const face = sideL.exterior ? sideL : sideH;
+          looks.set(w.id, { mat: face.mat, color: face.color, top: y0 + hh });
+        }
+        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 = shared.ctx.colors.metal != null ? shared.ctx.colors.metal : 9080466;
           const sx = alongU ? 1 : 0, sz = alongU ? 0 : 1, len = s1 - s0, n = Math.max(1, Math.round(len / 1.4));
@@ -4459,8 +4507,28 @@ 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 (shared.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(shared.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: wallBox2, sideOf, pieceOf, nearestWall, walls });
+    const defined = { wallBox: wallBox2, sideOf, pieceOf, nearestWall, walls, wallPillars };
+    Object.assign(K, defined);
   }
 
   // src/house/doors.ts
@@ -4479,7 +4547,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     shared.doorState = /* @__PURE__ */ new Map();
     function doors() {
-      shared.ctx.leaves = [];
+      const leaves = shared.ctx.leaves = [], doorState = shared.doorState, colliders = shared.ctx.colliders;
       const R = shared.ctx.r, cut = shared.ctx.cut, C = shared.ctx.colors, wood = C.wood != null ? C.wood : 8016948, frame2 = sh(wood, 0.55);
       for (const p of R.doors) {
         const f = p.floor;
@@ -4510,21 +4578,21 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         const leaf = (u0, u1, y_0, y_1, tt, color2, mat = "wood") => alongU ? bx(mat, u0, y0 + y_0, L - tt / 2, u1, y0 + y_1, L + tt / 2, color2) : bx(mat, L - tt / 2, y0 + y_0, u0, L + tt / 2, y0 + y_1, u1, color2);
         const extC = wood;
-        const open0 = p.blocked ? false : shared.doorState.has(p.id) ? shared.doorState.get(p.id) : !!p.open;
-        shared.doorState.set(p.id, open0);
+        const open0 = p.blocked ? false : doorState.has(p.id) ? doorState.get(p.id) === true : !!p.open;
+        doorState.set(p.id, open0);
         const dc = alongU ? [p.at, L] : [L, p.at];
-        const fo = { id: p.id, floor: f, type: p.model === "steel" ? "steel" : "swing", open: open0, t: open0 ? 1 : 0, blockedFlag: !!p.blocked, locked: R.state === "fortified" && !!p.exterior, handleNames: [], hT: 0, cx: dc[0], cz: dc[1], visH, groups: [], col: null };
+        const fo = { id: p.id, floor: f, type: p.model === "steel" ? "steel" : "swing", open: open0, t: open0 ? 1 : 0, blockedFlag: !!p.blocked, locked: R.state === "fortified" && !!p.exterior, handleNames: [], hT: 0, cx: dc[0], cz: dc[1], visH, groups: [], gs: [], col: null };
         const colR = { type: "door", f, x0: alongU ? a : L - th / 2, z0: alongU ? L - th / 2 : a, x1: alongU ? b : L + th / 2, z1: alongU ? L + th / 2 : b, off: open0 };
-        shared.ctx.colliders.push(colR);
+        colliders.push(colR);
         fo.col = colR;
         const leafBox = (hu, d0, d1, y_0, y_1, tt, color2, mat) => alongU ? bx(mat, d0, y_0, -tt / 2, d1, y_1, tt / 2, color2) : bx(mat, -tt / 2, y_0, d0, tt / 2, y_1, d1, color2);
-        const newGroup = (k, hu, topY) => {
+        const newGroup2 = (k, hu, topY) => {
           cursor.group = "dyn:" + p.id + ":" + k;
           fo.groups.push({ name: cursor.group, pos: alongU ? [hu, topY != null ? y0 + topY : y0, L] : [L, topY != null ? y0 + topY : y0, hu] });
         };
         if (p.model === "steel") {
-          const light = [14276044, 13223615, 14999766], pal = ((R.seed | 0) + p.id.length * 7) % 4, color2 = pal === 3 ? wood : light[pal], mid = (a + b) / 2;
-          newGroup(0, mid, visH);
+          const light = [14276044, 13223615, 14999766], pal = ((Number(R.seed) | 0) + p.id.length * 7) % 4, color2 = pal === 3 ? wood : light[pal], mid = (a + b) / 2;
+          newGroup2(0, mid, visH);
           const la = a + jw - mid, lb = b - jw - mid, nSec = Math.max(4, Math.round(visH / 0.5)), hs = visH / nSec, grv = sh(color2, 0.55);
           leafBox(0, la, lb, -visH, 0, 0.05, color2, "metal");
           for (let k = 1; k < nSec; k++) leafBox(0, la, lb, -k * hs - 0.012, -k * hs + 0.012, 0.07, grv, "metal");
@@ -4539,7 +4607,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           for (let k = 0; k < nf; k++) {
             const u0 = nf === 2 ? k ? (aa + bb) / 2 : aa : aa, u1 = nf === 2 ? k ? bb : (aa + bb) / 2 : bb, color2 = p.exterior ? extC : wood;
             const hingeAt = nf === 2 ? k ? u1 : u0 : p.hinge === "end" ? u1 : u0, dir = hingeAt === u0 ? 1 : -1, len = u1 - u0;
-            newGroup(k, hingeAt);
+            newGroup2(k, hingeAt);
             const d0 = dir > 0 ? 5e-3 : -len + 5e-3, d1 = dir > 0 ? len - 5e-3 : -5e-3;
             leafBox(hingeAt, d0, d1, 0, visH, 0.04, color2, PMAT);
             {
@@ -4575,7 +4643,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             fo.rot = Math.atan2(n[0] * A[1] - n[1] * A[0], A[0] * n[0] + A[1] * n[1]);
           }
         }
-        shared.ctx.leaves.push(fo);
+        leaves.push(fo);
         cursor.group = "f" + f;
         if (p.blocked) {
           part("window_boards", [0, 0, 0], () => {
@@ -4603,11 +4671,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
               }
             }
           }, { id: "boards:" + p.id }, "f" + f);
-          shared.ctx.colliders.push({ type: "board", f, x0: alongU ? a : L - th / 2, z0: alongU ? L - th / 2 : a, x1: alongU ? b : L + th / 2, z1: alongU ? L + th / 2 : b });
+          colliders.push({ type: "board", f, x0: alongU ? a : L - th / 2, z0: alongU ? L - th / 2 : a, x1: alongU ? b : L + th / 2, z1: alongU ? L + th / 2 : b });
         }
       }
     }
-    Object.assign(K, { doorLineSides, doors });
+    const defined = { doorLineSides, doors };
+    Object.assign(K, defined);
   }
 
   // src/house/windows.ts
@@ -4667,7 +4736,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
     }
-    Object.assign(K, { FRAME_COLORS, SILL_COLORS, windows });
+    const defined = { FRAME_COLORS, SILL_COLORS, windows };
+    Object.assign(K, defined);
   }
 
   // src/house/floors.ts
@@ -4677,7 +4747,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (shared.ctx._flights && shared.ctx._flights.r === shared.ctx.r) return shared.ctx._flights.l;
       const R = shared.ctx.r, mp = /* @__PURE__ */ new Map();
       for (const m of R.items) {
-        if (m.type !== "stairs" || !m.link) continue;
+        if (m.type !== "stairs" || !m.link || typeof m.link !== "object") continue;
         const k = [m.link.from, m.link.to, m.x.toFixed(2), m.z.toFixed(2), (m.ry || 0).toFixed(2)].join("|");
         if (!mp.has(k)) mp.set(k, { m, from: m.link.from, to: m.link.to, rect: stairFootprint(m) });
       }
@@ -4696,7 +4766,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     const panelRects = (p) => p.footprint && p.footprint.length ? p.footprint : [p.aabb];
     function tilesOf(parent, rc) {
-      const ps = parent && shared.ctx.panelsOf && shared.ctx.panelsOf.get(parent);
+      const ps = parent ? shared.ctx.panelsOf && shared.ctx.panelsOf.get(parent) : void 0;
       if (!ps) return [[parent ? structurePiece(parent) : null, rc]];
       const out = [], taken = [];
       for (const p of ps) for (const q of panelRects(p)) {
@@ -4760,13 +4830,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const { rectsOf: rectsOf2, Y0, boxC, bx, cursor, flights, stairFootprint, structurePiece } = K;
     const sh = (...a) => K.sh(...a);
     function buildStairs() {
-      const R = shared.ctx.r;
-      shared.ctx.stairs = [];
+      const R = shared.ctx.r, stairs = shared.ctx.stairs = [];
       for (const vo of flights()) {
         const m = vo.m, f = vo.from, Dr = m.d - (vo.LP || 0);
         cursor.group = "f" + f;
         cursor.pc = structurePiece("stairs_" + vo.from + "_" + vo.to);
-        const y0 = Y0(f), H = Y0(m.link.to) - y0, n = Math.max(8, Math.round(H / 0.18)), c = Math.cos(m.ry), s = Math.sin(m.ry);
+        const y0 = Y0(f), H = Y0(vo.to) - y0, n = Math.max(8, Math.round(H / 0.18)), c = Math.cos(m.ry), s = Math.sin(m.ry);
         const wood = shared.ctx.colors.wood != null ? shared.ctx.colors.wood : 9071176, under = sh(wood, 0.7);
         const P = (lx, lz) => [m.x + lx * c + lz * s, m.z - lx * s + lz * c];
         const boxL = (mat, lx, y, lz, w, h, d, color2, rx = 0) => {
@@ -4789,7 +4858,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           }
         }
         cursor.pc = null;
-        shared.ctx.stairs.push({ m, f, to: vo.to, y0, H, rect: stairFootprint(m), landingPoint: (vo.LP || 0) / m.d });
+        stairs.push({ m, f, to: vo.to, y0, H, rect: stairFootprint(m), landingPoint: (vo.LP || 0) / m.d });
       }
     }
     function elevator() {
@@ -4806,7 +4875,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
     }
-    Object.assign(K, { buildStairs, elevator });
+    const defined = { buildStairs, elevator };
+    Object.assign(K, defined);
   }
 
   // src/lights/fixtures.ts
@@ -4846,14 +4916,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         c: (mat, x, y, z, r, h, color2, seg) => api.cylinder(M, mat, x, y0 + y, z, r, h, color2, 0, 0, seg),
         e: (mat, x, y, z, r, h, color2) => api.cylinder(M, mat, x, y0 + y - h / 2, z, r, h, color2, 0, 0, "sphere"),
         t(mat, p, q, r, color2, seg) {
+          const tc = color2 ?? NaN;
           const dx = q[0] - p[0], dy = q[1] - p[1], dz = q[2] - p[2], L = Math.hypot(dx, dy, dz);
           if (L < 1e-5) return;
           const nx = dx / L, ny = dy / L, nz = dz / L;
           if (Math.abs(nx) < 1e-4 && Math.abs(nz) < 1e-4) {
-            api.cylinder(M, mat, p[0], y0 + Math.min(p[1], q[1]), p[2], r, L, color2, 0, 0, seg);
+            api.cylinder(M, mat, p[0], y0 + Math.min(p[1], q[1]), p[2], r, L, tc, 0, 0, seg);
             return;
           }
-          api.cylinder(M, mat, (p[0] + q[0]) / 2, y0 + (p[1] + q[1]) / 2, (p[2] + q[2]) / 2, r, L, color2, Math.atan2(nz, ny), -Math.asin(nx), seg);
+          api.cylinder(M, mat, (p[0] + q[0]) / 2, y0 + (p[1] + q[1]) / 2, (p[2] + q[2]) / 2, r, L, tc, Math.atan2(nz, ny), -Math.asin(nx), seg);
         },
         polyFace: (mat, pts, color2, hint) => polyFace(mat, pts.map((p) => W(p[0], p[1], p[2])), color2, hint && [hint[0] * c + hint[2] * s, hint[1], -hint[0] * s + hint[2] * c]),
         part(type, lx, ly, lz, fn, meta) {
@@ -5032,7 +5103,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         K2.part("light_switch", x, 0, 0.011, () => K2.b("plain", x, -0.018, 0.0125, two ? 0.03 : 0.036, 0.034, 8e-3, 16513782, 0, -0.12), { id: "sw_" + M.seed + "_" + i, room: M.room, target: M.target || M.room, opens: { type: "toggle", axis: [1, 0, 0], angle: 0.24 }, on: !!M.on, t0: M.on ? 1 : 0 });
       }
     }
-    Object.assign(K, { hashString, rngString, SEED, STYLE, kit2, arcPoints, TEMP_WARM, TEMP_NEUTRAL, TEMP_COOL, colorTemperature, lightStyle, ceilingLamp, tableLamp, floorLamp, sconce, outdoorLamp, lightSwitch });
+    const defined = { hashString, rngString, SEED, STYLE, kit2, arcPoints, TEMP_WARM, TEMP_NEUTRAL, TEMP_COOL, colorTemperature, lightStyle, ceilingLamp, tableLamp, floorLamp, sconce, outdoorLamp, lightSwitch };
+    Object.assign(K, defined);
   }
 
   // src/lights/decor.ts
@@ -5099,7 +5171,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         void sd;
       }
     }
-    Object.assign(K, { decorLights });
+    const defined = { decorLights };
+    Object.assign(K, defined);
   }
 
   // src/lot/terrain.ts
@@ -5152,7 +5225,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (x < b) out.push([x, b]);
       return out.filter((q) => q[1] - q[0] > 0.3);
     }
-    Object.assign(K, { terrain, freeSpans });
+    const defined = { terrain, freeSpans };
+    Object.assign(K, defined);
   }
 
   // src/lot/perimeter.ts
@@ -5172,7 +5246,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       for (const s of lt.perimeter) {
         const alongU = Math.abs(s.v1 - s.v0) < EPS3, L = alongU ? s.v0 : s.u0, a = Math.min(alongU ? s.u0 : s.v0, alongU ? s.u1 : s.v1), b = Math.max(alongU ? s.u0 : s.v0, alongU ? s.u1 : s.v1);
         cursor.pc = pieceRecord("lot_wall:" + s.id, s.type === "wall" ? "brick" : s.type === "fence" ? "wood_soft" : "steel", null, { tags: ["wall"] });
-        const th = s.thickness || 0.15, h = s.height, color2 = colorOf(s.color) != null ? colorOf(s.color) : C.wall || 12104874, len = b - a;
+        const th = s.thickness || 0.15, h = s.height, color2 = colorOf(s.color) ?? (C.wall || 12104874), len = b - a;
         const B = (mat, u0, y0, u1, y1, t, c, off = 0) => alongU ? bx(mat, u0, y0, L + off - t / 2, u1, y1, L + off + t / 2, c) : bx(mat, L + off - t / 2, y0, u0, L + off + t / 2, y1, u1, c);
         const col = { type: "lot_wall", f: -1, x0: alongU ? a : L - th / 2, z0: alongU ? L - th / 2 : a, x1: alongU ? b : L + th / 2, z1: alongU ? L + th / 2 : b };
         shared.ctx.colliders.push(col);
@@ -5246,7 +5320,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
     }
-    Object.assign(K, { perimeter, paths });
+    const defined = { perimeter, paths };
+    Object.assign(K, defined);
   }
 
   // src/lot/gates.ts
@@ -5262,7 +5337,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       cursor.group = "lot";
       const structure = R.style, auto = structure !== "budget", wall = colorOf("wall") || 12104874, cu = (lt.rect[0] + lt.rect[2]) / 2, cz = (lt.rect[1] + lt.rect[3]) / 2;
       for (const g of lt.gates) {
-        const gc = colorOf(g.color) != null ? colorOf(g.color) : C.gate != null ? C.gate : 2763310, a = g.u - g.width / 2, b = g.u + g.width / 2, v = g.v, h = g.height, t = 0.05, ped = g.model === "pedestrian", tilt = g.model === "tilting";
+        const gc = colorOf(g.color) ?? (C.gate != null ? C.gate : 2763310), a = g.u - g.width / 2, b = g.u + g.width / 2, v = g.v, h = g.height, t = 0.05, ped = g.model === "pedestrian", tilt = g.model === "tilting";
         const sd = cz - v >= 0 ? 1 : -1;
         const pil = (x0, x1, high) => {
           bx("plaster", x0, 0, v - 0.13, x1, high, v + 0.13, wall);
@@ -5334,7 +5409,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (!g.open || ped) shared.ctx.colliders.push({ type: "gate", f: -1, x0: a, z0: v - 0.1, x1: b, z1: v + 0.1 });
       }
     }
-    Object.assign(K, { slideDirection, gates });
+    const defined = { slideDirection, gates };
+    Object.assign(K, defined);
   }
 
   // src/roof/roofs.ts
@@ -5348,13 +5424,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function roofs() {
       const R = shared.ctx.r, F = R.facade, C = shared.ctx.colors, nA = R.floors.length, type = F.roof;
       cursor.group = "roof";
-      shared.ctx.roofRects = [];
-      shared.ctx.gutter = gutterConfig();
-      shared.ctx.gutter.ncond = 0;
-      shared.ctx.gutter.nbuz = 0;
-      shared.ctx.gutter.bz = /* @__PURE__ */ new Set();
+      const roofRects = shared.ctx.roofRects = [];
+      const G = shared.ctx.gutter = gutterConfig();
+      G.ncond = 0;
+      G.nbuz = 0;
+      G.bz = /* @__PURE__ */ new Set();
       shared.ctx.gutterInfo = { gutters: [], downpipes: [], drains: [] };
-      const roofColor = C.roof != null ? C.roof : 11031610, gable = (R.seed | 0) % 2 === 0;
+      const roofColor = C.roof != null ? C.roof : 11031610, gable = (Number(R.seed) | 0) % 2 === 0;
       for (let f = 0; f < nA; f++) {
         const rs = R.rooms.filter((c) => c.floor === f && c.type !== "void" && !c.outbuilding && !OPEN_AREA(c)).flatMap(rectsOf2), up = R.rooms.filter((c) => c.floor === f + 1 && c.type !== "void").flatMap(rectsOf2);
         if (!rs.length) continue;
@@ -5376,7 +5452,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           return Y0(f) + Math.max(...cs.map((c) => c.ceiling)) + 0.2;
         };
         if (type === "slab") {
-          for (let j = 0; j < nz; j++) for (let i = 0; i < nx; i++) if (O(j, i)) shared.ctx.roofRects.push({ f, r: [xs[i], zs[j], xs[i + 1], zs[j + 1]], slab: true, yb: pe(xs[i], zs[j], xs[i + 1], zs[j + 1]) + 0.03 });
+          for (let j = 0; j < nz; j++) for (let i = 0; i < nx; i++) if (O(j, i)) roofRects.push({ f, r: [xs[i], zs[j], xs[i + 1], zs[j + 1]], slab: true, yb: pe(xs[i], zs[j], xs[i + 1], zs[j + 1]) + 0.03 });
           slabs(f, xs, zs, O, U, nx, nz, full, pe, C);
           cursor.pc = null;
           continue;
@@ -5399,16 +5475,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             if (U(q.j0 - 1, i)) touchesU[1] = 1;
             if (U(q.j1 + 1, i)) touchesU[3] = 1;
           }
-          shared.ctx.roofRects.push({ f, r: [x0, z0, x1, z1], touchesU });
+          roofRects.push({ f, r: [x0, z0, x1, z1], touchesU });
           const ybq = pe(x0, z0, x1, z1);
           roofRect(type, x0, z0, x1, z1, ybq, roofColor, gable && single, F, touchesU);
           cursor.pc = null;
-          if (shared.ctx.gutter.on) gutter(type, f, x0, z0, x1, z1, ybq, touchesU);
+          if (G.on) gutter(type, f, x0, z0, x1, z1, ybq, touchesU);
         }
       }
       for (const e of shared.ctx.outbuildingList || []) {
         const [x0, z0, x1, z1] = e.aabb, yb = Y0(0) + (e.ceiling || 2.6) + 0.2;
-        shared.ctx.roofRects.push({ f: 0, r: [x0, z0, x1, z1], outbuilding: e.id });
+        roofRects.push({ f: 0, r: [x0, z0, x1, z1], outbuilding: e.id });
         if (type === "slab") {
           const c = C.facade != null ? C.facade : 14209216;
           bx("plaster", x0 - 0.08, yb, z0 - 0.08, x1 + 0.08, yb + 0.03, z1 + 0.08, sh(C.ceiling != null ? C.ceiling : 12104876, 0.85));
@@ -5419,13 +5495,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         roofRect(type, x0, z0, x1, z1, yb, roofColor, true, F, [0, 0, 0, 0]);
         cursor.pc = null;
         shared.ctx.noPiece = false;
-        if (shared.ctx.gutter.on) gutter(type, 0, x0, z0, x1, z1, yb, [0, 0, 0, 0]);
+        if (G.on) gutter(type, 0, x0, z0, x1, z1, yb, [0, 0, 0, 0]);
       }
     }
-    Object.assign(K, { roofs });
+    const defined = { roofs };
+    Object.assign(K, defined);
   }
 
   // src/roof/gutters.ts
+  var paletteMeta = (colors) => colors.meta;
   function installRoofGutters(K, shared) {
     const { boxC, bx, cursor, roomAt } = K;
     const sh = (...a) => K.sh(...a);
@@ -5442,7 +5520,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const draw2 = rnd() < p, light = rnd() < 0.6;
       void draw2;
       const on = true;
-      return { on, rnd, color: high ? 3816770 : light ? 15527921 : 10857392, bad: (shared.ctx.colors.meta && shared.ctx.colors.meta.state) === "abandoned" || R.state === "abandoned", fallback: false };
+      return { on, rnd, color: high ? 3816770 : light ? 15527921 : 10857392, bad: paletteMeta(shared.ctx.colors)?.state === "abandoned" || R.state === "abandoned", fallback: false };
     }
     function gutter(type, f, X0, Z0, X1, Z1, yb, touchesU) {
       const G = shared.ctx.gutter, o = type === "fiber_cement" ? 0.3 : 0.45, x0 = X0 - (touchesU[0] ? 0 : o), x1 = X1 + (touchesU[2] ? 0 : o), z0 = Z0 - (touchesU[1] ? 0 : o), z1 = Z1 + (touchesU[3] ? 0 : o), c = G.color, y = yb - 0.05;
@@ -5484,7 +5562,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const px = cx + sx * 0.06, pz = cz + sz * 0.06;
         if (!freeAt(px, pz, sx, sz)) return false;
         const floats = G.bad && G.ncond === 1, yt = yb - 0.1, ybx = floats ? 0.7 : 0.04;
-        G.ncond++;
+        G.ncond = (G.ncond ?? 0) + 1;
         if (run2 >= 2) boxC("plain", (sides[run2][4] + px) / 2, yt, pz, Math.abs(sides[run2][4] - px), 0.07, 0.07, c);
         else boxC("plain", px, yt, (sides[run2][4] + pz) / 2, 0.07, 0.07, Math.abs(sides[run2][4] - pz), c);
         boxC("plain", px, (ybx + yt) / 2, pz, 0.08, yt - ybx, 0.08, c);
@@ -5518,7 +5596,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function drain(x, z, px, pz, c) {
       const g0 = cursor.group;
       cursor.group = "f0";
-      if (px != null) boxC("plain", (px + x) / 2, 0.075, (pz + z) / 2, Math.abs(x - px) + 0.05, 0.05, Math.abs(z - pz) + 0.05, sh(c, 0.85));
+      if (px != null && pz != null && c != null) boxC("plain", (px + x) / 2, 0.075, (pz + z) / 2, Math.abs(x - px) + 0.05, 0.05, Math.abs(z - pz) + 0.05, sh(c, 0.85));
       const t = 0.045;
       bx("plain", x - 0.12, 0, z - 0.12, x + 0.12, t - 6e-3, z + 0.12, 12170668);
       bx("metal", x - 0.11, t, z - 0.11, x + 0.11, t + 0.012, z + 0.11, 5922145);
@@ -5529,7 +5607,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       bx("metal", x - 0.085, t + 0.012, z - 6e-3, x + 0.085, t + 0.02, z + 6e-3, 9080466);
       cursor.group = g0;
     }
-    Object.assign(K, { gutterConfig, gutter, drain });
+    const defined = { gutterConfig, gutter, drain };
+    Object.assign(K, defined);
   }
 
   // src/roof/slabs.ts
@@ -5563,15 +5642,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         side(free(j, i + 1), x1 + o - t, z0 - ez0, x1 + o, z1 + ez1);
         side(free(j - 1, i), x0 - ex0, z0 - o, x1 + ex1, z0 - o + t);
         side(free(j + 1, i), x0 - ex0, z1 + o - t, x1 + ex1, z1 + o);
-        if (shared.ctx.gutter && shared.ctx.gutter.on) for (const [ok, dx, dz] of [[free(j - 1, i), 0, -1], [free(j + 1, i), 0, 1], [free(j, i - 1), -1, 0], [free(j, i + 1), 1, 0]]) {
+        const G = shared.ctx.gutter;
+        if (G && G.on && G.bz) for (const [ok, dx, dz] of [[free(j - 1, i), 0, -1], [free(j + 1, i), 0, 1], [free(j, i - 1), -1, 0], [free(j, i + 1), 1, 0]]) {
           const kd = f + ":" + dx + ":" + dz;
-          if (!ok || shared.ctx.gutter.bz.has(kd)) continue;
-          shared.ctx.gutter.bz.add(kd);
-          shared.ctx.gutter.nbuz++;
-          const mx = (x0 + x1) / 2, mz = (z0 + z1) / 2, ex = dx ? dx < 0 ? x0 - o : x1 + o : mx, ez = dz ? dz < 0 ? z0 - o : z1 + o : mz, cc = shared.ctx.gutter.color;
+          if (!ok || G.bz.has(kd)) continue;
+          G.bz.add(kd);
+          G.nbuz = (G.nbuz ?? 0) + 1;
+          const mx = (x0 + x1) / 2, mz = (z0 + z1) / 2, ex = dx ? dx < 0 ? x0 - o : x1 + o : mx, ez = dz ? dz < 0 ? z0 - o : z1 + o : mz, cc = G.color;
           boxC("plain", ex + dx * 0.15, yb + 0.1, ez + dz * 0.15, dx ? 0.42 : 0.14, 0.1, dz ? 0.42 : 0.14, cc);
           boxC("plain", ex + dx * 0.36, yb + 0.1, ez + dz * 0.36, dx ? 0.04 : 0.18, 0.14, dz ? 0.04 : 0.18, sh(cc, 0.8));
-          if (shared.ctx.gutter.bad) boxC("plain", ex + dx * 0.05, yb + 0.5 * 0, ez + dz * 0.05, dx ? 0.06 : 0.3, 0.02, dz ? 0.06 : 0.3, 4868674);
+          if (G.bad) boxC("plain", ex + dx * 0.05, yb + 0.5 * 0, ez + dz * 0.05, dx ? 0.06 : 0.3, 0.02, dz ? 0.06 : 0.3, 4868674);
           {
             const tx = ex + dx * 0.38, tz = ez + dz * 0.38;
             let lv = true;
@@ -5591,7 +5671,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
     }
-    Object.assign(K, { slabs });
+    const defined = { slabs };
+    Object.assign(K, defined);
   }
 
   // src/roof/tiles.ts
@@ -5724,7 +5805,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       return m ? structurePiece(m.id) : null;
     }
-    Object.assign(K, { R_STYLE, tileRelief, ridge, pieceOfPane });
+    const defined = { R_STYLE, tileRelief, ridge, pieceOfPane };
+    Object.assign(K, defined);
   }
 
   // src/roof/rect.ts
@@ -5770,7 +5852,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       const rm = alongX ? dz / 2 : dx / 2;
       {
-        const rr = shared.ctx.roofRects[shared.ctx.roofRects.length - 1];
+        const roofRects = shared.ctx.roofRects, rr = roofRects[roofRects.length - 1];
         if (rr && !rr.yb) Object.assign(rr, { yb, tp, gable: !!gable, alongX, exterior: [x0, z0, x1, z1], rm });
       }
       if (gable) {
@@ -5807,7 +5889,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
     }
-    Object.assign(K, { roofRect });
+    const defined = { roofRect };
+    Object.assign(K, defined);
   }
 
   // src/mirrors.ts
@@ -5818,9 +5901,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function mirrorEnv() {
       if (shared.mirrorEnv) return shared.mirrorEnv;
       const mk = (f) => {
+        if (!DOC) throw new Error("game-floorplan-three: the mirrors need a document (options.document)");
         const c = DOC.createElement("canvas");
         c.width = c.height = 64;
         const g = c.getContext("2d");
+        if (!g) throw new Error("game-floorplan-three: no 2d canvas context");
         f(g);
         return c;
       };
@@ -5879,7 +5964,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             B.N.push(v.x, v.y, v.z);
             B.U.push(ua.getX(i), ua.getY(i));
           }
-          for (const k of geo.index.array) B.I.push(B.nv + k);
+          for (const k of geo.index?.array ?? []) B.I.push(B.nv + k);
           B.nv += pa.count;
           geo.dispose();
         }
@@ -5957,7 +6042,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         m.fake.visible = !on;
       }
     }
-    Object.assign(K, { mirrorEnv, newMirrorState, assembleMirrors, floorAtY, chooseMirror });
+    const defined = { mirrorEnv, newMirrorState, assembleMirrors, floorAtY, chooseMirror };
+    Object.assign(K, defined);
   }
 
   // src/cars.ts
@@ -5970,13 +6056,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       high: ["electric_hatch", "hybrid_suv", "midsize_suv", "v8_coupe", "large_suv", "midsize_pickup", "crossover_pickup", "fastback_sedan"]
     }, K.cfg.carKinds);
     const CAR_CACHE = /* @__PURE__ */ new Map();
-    function materialSignature(m) {
+    function materialSignature(material) {
+      const m = material;
       const f = (v) => v == null ? "" : typeof v === "number" ? v.toFixed(3) : v.isColor ? v.getHexString() : v.uuid || String(v);
       return [m.type, f(m.color), f(m.roughness), f(m.metalness), f(m.opacity), m.transparent ? 1 : 0, m.side, f(m.map), f(m.emissive), f(m.emissiveIntensity), m.vertexColors ? 1 : 0, m.flatShading ? 1 : 0, f(m.envMapIntensity), f(m.alphaTest)].join("|");
     }
     const BUCKETS = /* @__PURE__ */ new Map();
-    function bucketMaterial(m) {
-      if (m.type !== "MeshStandardMaterial" || m.map || m.alphaTest || m.vertexColors || !m.color) return null;
+    function bucketMaterial(material) {
+      if (material.type !== "MeshStandardMaterial") return null;
+      const m = material;
+      if (m.map || m.alphaTest || m.vertexColors || !m.color) return null;
       const mt = m.metalness > 0.5 ? 2 : m.metalness > 0.2 ? 1 : 0, rg = m.roughness < 0.3 ? 0 : m.roughness < 0.6 ? 1 : 2, tr = m.transparent || m.opacity < 1, op = tr ? Math.max(0.2, Math.min(0.9, Math.round(m.opacity * 5) / 5)) : 1, sig = "bucket" + mt + rg + "s" + m.side + (tr ? "t" + op : "");
       let b = BUCKETS.get(sig);
       if (!b) {
@@ -5988,7 +6077,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     function carModel(k, seed) {
       const kc = k + "|" + shared.quality + "|" + (seed || 0);
-      if (CAR_CACHE.has(kc)) return CAR_CACHE.get(kc);
+      if (CAR_CACHE.has(kc)) return CAR_CACHE.get(kc) ?? null;
       if (!FLEET) return null;
       let res = null;
       try {
@@ -5996,8 +6085,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         c.root.updateMatrixWorld(true);
         const inv = new THREE.Matrix4();
         const byMaterial = /* @__PURE__ */ new Map(), tmp = new THREE.Matrix4(), v = new THREE.Vector3(), nm = new THREE.Matrix3(), bb = new THREE.Box3();
-        c.g.traverse((o) => {
-          if (!o.isMesh || o.isInstancedMesh || o.isSkinnedMesh || !o.geometry || !o.geometry.attributes.position) return;
+        c.g.traverse((node) => {
+          if (!isMesh(node)) return;
+          const o = node;
+          if (o.isInstancedMesh || o.isSkinnedMesh || !o.geometry || !o.geometry.attributes.position) return;
           for (let p = o; p; p = p.parent) if (p.visible === false) return;
           const mats = Array.isArray(o.material) ? o.material : [o.material];
           let geo = o.geometry;
@@ -6011,7 +6102,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const pa = geo.attributes.position, na = geo.attributes.normal, ua = geo.attributes.uv, total = pa.count;
           const grs = Array.isArray(o.material) && o.geometry.groups.length ? o.geometry.groups : [{ start: 0, count: total, materialIndex: 0 }];
           for (const gr of grs) {
-            const m = mats[gr.materialIndex] || mats[0];
+            const m = (gr.materialIndex != null ? mats[gr.materialIndex] : void 0) || mats[0];
             if (!m) continue;
             const a0 = Math.min(gr.start, total), n0 = Math.min(gr.count, total - a0) - Math.min(gr.count, total - a0) % 3;
             if (n0 < 3) continue;
@@ -6112,7 +6203,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return g;
     }
     function assembleCars(groups) {
-      if (shared.quality === "game") return assembleMergedCars(groups);
+      if (shared.quality === "game") {
+        assembleMergedCars(groups);
+        return;
+      }
       for (const C of CARS) {
         const g = carGroup(C.k, C.w, C.d, C.seed);
         if (!g) continue;
@@ -6163,7 +6257,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         (groups[B.parent] || (groups[B.parent] = new THREE.Group())).add(m);
       }
     }
-    Object.assign(K, { CARS, CAR_BY_STYLE, CAR_CACHE, materialSignature, BUCKETS, bucketMaterial, carModel, carGroup, assembleCars, assembleMergedCars });
+    const defined = { CARS, CAR_BY_STYLE, CAR_CACHE, materialSignature, BUCKETS, bucketMaterial, carModel, carGroup, assembleCars, assembleMergedCars };
+    Object.assign(K, defined);
   }
 
   // src/house/building.ts
@@ -6219,14 +6314,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       bx("plaster", Math.min(hall[0] - 3, color2[0]), ytop, Math.min(un[1] ? unitBox(un[1])[1] : 0, el[1]), Math.max(color2[2], un0[2]), ytop + 0.2, Math.max(un0[3], un[1] ? unitBox(un[1])[3] : 0), 11841704);
       shared.ctx.limits = { x0: Math.min(hall[0] - 3, color2[0]), z0: Math.min(el[1], un[1] ? unitBox(un[1])[1] : 0), x1: Math.max(color2[2], un0[2]), z1: Math.max(un0[3], un[1] ? unitBox(un[1])[3] : 0) };
     }
-    Object.assign(K, { building });
+    const defined = { building };
+    Object.assign(K, defined);
   }
 
   // src/utilities/water.ts
   function installUtilitiesWater(K, shared) {
     const { THREE, _Y, _q, cursor, cylBase, part, pieceRecord, put } = K;
     function createWater(r, state) {
-      const H = r.utilities.plumbing, cap = H ? +H.capacityL || 0 : 0, ls = { dry: [], full: [] }, points = {}, itemPoint = {};
+      const H = r.utilities?.plumbing, cap = H ? +H.capacityL || 0 : 0, ls = { dry: [], full: [] }, points = {}, itemPoint = {};
       if (H) for (const p of H.points) {
         points[p.id] = p;
         itemPoint[p.item] = p.id;
@@ -6315,14 +6411,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     const _v3 = new THREE.Vector3();
     function waterPipes() {
-      const H = shared.ctx.r.utilities.plumbing;
+      const H = shared.ctx.r.utilities?.plumbing;
       if (!H || !H.visibleRuns) return;
       const nA = shared.ctx.r.floors.length;
       const groupOf = (c) => c && c.floor >= 0 ? "f" + Math.min(c.floor, nA - 1) : "lot", xyz = (p) => [p[0], p[2], p[1]];
       for (const tr of H.visibleRuns) {
         const pts = tr.points.map(xyz), d = tr.diameter || 0.025;
         if (tr.exposed === "wall") {
-          const pt = H.points.find((p) => p.run === tr.id), com = shared.ctx.roomById[tr.to], g2 = groupOf(com || pt && { floor: pt.floor });
+          const pt = H.points.find((p) => p.run === tr.id), com = tr.to != null ? shared.ctx.roomById[tr.to] : void 0, g2 = groupOf(com || pt && { floor: pt.floor });
           part("wall_pipe", [0, 0, 0], () => {
             for (let i = 0; i + 1 < pts.length; i++) pipe(pts[i], pts[i + 1], d, PIPE_COLOR);
             for (const p of pts) cylBase("plain", p[0], p[1] - d, p[2], d * 0.7, d * 2, PIPE_COLOR);
@@ -6344,7 +6440,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         cursor.pc = null;
       }
     }
-    Object.assign(K, { createWater, PIPE_COLOR, pipe, _v3, waterPipes });
+    const defined = { createWater, PIPE_COLOR, pipe, _v3, waterPipes };
+    Object.assign(K, defined);
   }
 
   // src/utilities/electrical.ts
@@ -6352,10 +6449,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const { _Y, _q, _v3, bx, cursor, cylBase, pieceRecord, put } = K;
     const sh = (...a) => K.sh(...a);
     function electricalStructure() {
-      const E = shared.ctx.r.utilities.electrical;
+      const R = shared.ctx.r, E = R.utilities?.electrical;
       shared.ctx.electricalInfo = null;
       if (!E) return;
-      const R = shared.ctx.r, nA = R.floors.length, lotGroup = R.lot ? "lot" : "f0", concreteColor = 11973547, iron = 4869200, wireRun = 1842206, info = { pole: null, meter: null, panel: null, conduits: [], outlets: [], switches: [], circuits: E.circuits || [], exposed: !!E.exposed };
+      const nA = R.floors.length, lotGroup = R.lot ? "lot" : "f0", concreteColor = 11973547, iron = 4869200, wireRun = 1842206, info = { pole: null, meter: null, panel: null, conduits: [], outlets: [], switches: [], circuits: E.circuits || [], exposed: !!E.exposed };
       const en3 = E.serviceEntrance, KV = shared.ctx.iv ? shared.ctx.iv.plane : null;
       const wireL = (a, b, r_ = 8e-3) => {
         const L = Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
@@ -6460,7 +6557,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       _q.setFromUnitVectors(_Y, _v3.set(dx / L, dy / L, dz / L));
       put("plain", "cyl", (a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2, _q, diameter, L, diameter, color2);
     }
-    Object.assign(K, { electricalStructure, pipe2 });
+    const defined = { electricalStructure, pipe2 };
+    Object.assign(K, defined);
   }
 
   // src/house/baseboard.ts
@@ -6498,7 +6596,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         strip(W, y0, y0 + 0.045, 0, W, "sidewalk", cal);
       }
     }
-    Object.assign(K, { baseboardAndSidewalk });
+    const defined = { baseboardAndSidewalk };
+    Object.assign(K, defined);
   }
 
   // src/utilities/solar.ts
@@ -6513,6 +6612,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           if (u >= a - 0.05 && u <= c + 0.05 && v >= b - 0.05 && v <= d + 0.05) y = Math.max(y == null ? -1e9 : y, rr.yb);
           continue;
         }
+        if (!rr.exterior || rr.tp == null || rr.rm == null) continue;
         const [x0, z0, x1, z1] = rr.exterior;
         if (u < x0 || u > x1 || v < z0 || v > z1) continue;
         const dz = Math.min(v - z0, z1 - v), dx = Math.min(u - x0, x1 - u), dd = rr.gable ? rr.alongX ? dz : dx : Math.min(dx, dz), h = rr.yb + rr.tp * Math.min(dd, rr.rm);
@@ -6521,7 +6621,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return y;
     }
     function solar() {
-      const R = shared.ctx.r, S = R.utilities.solar;
+      const R = shared.ctx.r, S = R.utilities?.solar;
       shared.ctx.solarInfo = null;
       if (!S || !S.panels || !S.panels.length) return;
       cursor.group = "roof";
@@ -6564,13 +6664,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           bx("plain", iv.u - W * 0.6, y0 + 0.05, iv.v + fa0, iv.u + W * 0.6, y0 + 0.17, iv.v + fa1, 2106924);
           bx("emissive", iv.u - 0.03, y0 - 0.12, iv.v + fa0, iv.u + 0.03, y0 - 0.09, iv.v + fa1, 6479994);
         }
-        const top = Math.max(...(shared.ctx.roofRects || []).filter((t2) => t2.yb != null).map((t2) => t2.yb), Y0(fa) + 2.8);
+        const top = Math.max(...(shared.ctx.roofRects || []).flatMap((t2) => t2.yb != null ? [t2.yb] : []), Y0(fa) + 2.8);
         cylBase("plain", iv.u, y0 + h / 2, iv.v, 0.016, Math.max(0.2, top - 0.2 - (y0 + h / 2)), 15262936);
         info.inverter = { id: iv.id, pos: [iv.u, y0, iv.v], side: iv.side, link: iv.link };
       }
       shared.ctx.solarInfo = info;
     }
-    Object.assign(K, { roofHeightAt, solar });
+    const defined = { roofHeightAt, solar };
+    Object.assign(K, defined);
   }
 
   // src/house/outbuildings.ts
@@ -6585,7 +6686,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         counts.set(w.floor, i + 1);
         return w.id ? w : Object.assign({}, w, { id: `wall_${w.floor}_${i}` });
       }) });
-      const E = (r.outbuildings || []).filter((e) => e && e.walls && e.walls.length && e.interior && e.interior.length);
+      const E = (r.outbuildings || []).filter((e) => !!(e && e.walls && e.walls.length && e.interior && e.interior.length));
       if (!E.length) return r;
       const rooms = r.rooms.slice(), walls = r.walls.slice(), doors = r.doors.slice(), windows = r.windows.slice(), items = r.items.filter((m) => m.type !== "outbuilding");
       for (const e of E) {
@@ -6599,7 +6700,22 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const alongU = p.axis === "u", below = p.pos < (alongU ? cz : cx);
           doors.push({ id: p.id, floor: 0, u: p.u, v: p.v, axis: p.axis, pos: p.pos, at: p.at, width: p.width, a: below ? "outside" : e.id, b: below ? e.id : "outside", opensTo: e.id, exterior: true, side: p.side, leaves: 1, model: "single", hinge: "start", zones: [], blocked: false, outbuilding: e.id });
         }
-        for (const j of e.windows || []) windows.push({ id: j.id, floor: 0, u: j.u, v: j.v, axis: j.axis, pos: j.pos, at: j.at, width: j.width, y0: j.y0, y1: j.y1, room: e.id, side: j.side, outbuilding: e.id });
+        for (const j of e.windows || []) windows.push({
+          id: j.id,
+          floor: 0,
+          u: j.u,
+          v: j.v,
+          axis: j.axis,
+          pos: j.pos,
+          at: j.at,
+          width: j.width,
+          y0: j.y0 ?? 1,
+          y1: j.y1 ?? 2,
+          /* the structure always gives a window its sill and head (1.0, 2.0) */
+          room: e.id,
+          side: j.side,
+          outbuilding: e.id
+        });
         (e.items || []).forEach((m, i) => items.push({ id: e.id + "." + m.type + i, type: m.type, category: m.category, x: m.u, z: m.v, ry: m.ry || 0, w: m.w, d: m.d, h: m.h, y: 0.04, frontU: m.frontU, frontV: m.frontV, room: e.id, floor: 0, outdoor: false, aabb: m.aabb, color: "wood" }));
         items.push({ id: e.id + ".ceiling_light", type: "ceiling_light", category: "ceiling_light", x: cx, z: cz, ry: 0, w: 0.35, d: 0.35, h: 0.1, y: pe - 0.1, room: e.id, floor: 0, outdoor: false, assembly: "ceiling", color: "metal", decor: true });
       }
@@ -6620,7 +6736,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
     }
-    Object.assign(K, { OUTBUILDING_USE, applyOutbuildings, outbuildings });
+    const defined = { OUTBUILDING_USE, applyOutbuildings, outbuildings };
+    Object.assign(K, defined);
   }
 
   // src/furniture/api.ts
@@ -6685,7 +6802,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return { b: (mat, x, y, z, w, h, d, color2, ry, rx, rz) => A.box(M, mat, x, y0 + y, z, w, h, d, color2, ry || 0, rx || 0, rz || 0), c: (mat, x, y, z, r, h, color2, rx, rz, seg) => A.cylinder(M, mat, x, y0 + y, z, r, h, color2, rx || 0, rz || 0, seg), rnd: rngOf(M), wood: paletteColor(M, "wood", 8016948), met: paletteColor(M, "metal", 10133154) };
     }
     const PE = Math.PI / 2;
-    Object.assign(K, { MATERIAL_MAP: MATERIAL_MAP2, mm, LIGHTS, makeApi, sh, paletteColor, rngOf, kk, PE });
+    const defined = { MATERIAL_MAP: MATERIAL_MAP2, mm, LIGHTS, makeApi, sh, paletteColor, rngOf, kk, PE };
+    Object.assign(K, defined);
   }
 
   // src/furniture/builders.ts
@@ -6813,7 +6931,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (let s = 0; s < np; s++) lb("fabric", np === 1 ? 0 : (s ? 1 : -1) * w * 0.23, 0.5, -d / 2 + 0.3, w * (np === 1 ? 0.6 : 0.4), 0.12, 0.34, 15789798, (s ? 1 : -1) * 0.08);
       },
       wardrobe(M, A) {
-        const { b: lb } = kk(M, A), w = M.w, d = M.d, h = M.h, wood = M.color != null && false ? M.color : paletteColor(M, "wood", 5980208), np = Math.max(2, Math.round(w / 0.7));
+        const { b: lb } = kk(M, A), w = M.w, d = M.d, h = M.h, wood = paletteColor(M, "wood", 5980208), np = Math.max(2, Math.round(w / 0.7));
         lb("wood", 0, 0.06, 0, w, h - 0.06, d, wood);
         lb("wood", 0, h, 0, w + 0.04, 0.04, d + 0.04, sh(wood, 0.8));
         lb("wood", 0, 0, 0, w - 0.04, 0.06, d - 0.04, sh(wood, 0.4));
@@ -7205,7 +7323,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         lb("metal", 0, h - 0.04, d / 2, w, 0.03, 0.03, 3815994);
       }
     };
-    Object.assign(K, { FURNITURE });
+    const defined = { FURNITURE };
+    Object.assign(K, defined);
   }
 
   // src/furniture/type-table.ts
@@ -7215,7 +7334,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function typeTable(props) {
       const B = props.builders, T2 = {};
       const mv = (type, id) => {
-        if (B[id || type]) T2[type] = { f: B[id || type], source: "props3d" };
+        const f = B[id || type];
+        if (f) T2[type] = { f, source: "props3d" };
       };
       const mine = (type, f, source = "game") => {
         T2[type] = { f, source };
@@ -7354,7 +7474,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       extraTypes(T2, props);
       return T2;
     }
-    Object.assign(K, { typeTable });
+    const defined = { typeTable };
+    Object.assign(K, defined);
   }
 
   // src/furniture/taps.ts
@@ -7418,7 +7539,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }, { id: id + "_a", target: id, hidden: true, fluid: "water" });
       return id;
     }
-    Object.assign(K, { counterTap, wallTap });
+    const defined = { counterTap, wallTap };
+    Object.assign(K, defined);
   }
 
   // src/furniture/fixtures.ts
@@ -7531,7 +7653,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const a = rnd() * 6.283, u = Math.sqrt(rnd()), ph = (rnd() - 0.2) * 1.2, dx = Math.cos(a) * u * R * 0.75, dz = Math.sin(a) * u * R * 0.75, dy = (o.flatten ? 0.35 : 0.55) * R * (Math.sin(ph) * 0.5 + 0.5) * 1.5 - R * 0.15;
         const r = R * (0.34 + rnd() * 0.22) * (1 - u * 0.25), alt = r * 2 * (o.flatten ? 0.75 : 0.95), f = 0.72 + Math.min(1, (dy + R * 0.2) / (R * 1.2)) * 0.32 + rnd() * 0.12;
         K2.e("plant", cx + dx, cy + dy + r * 0.5, cz + dz, r, alt, sh(green2, f));
-        if (o.flower && rnd() < o.flower) {
+        if (o.flower && o.flowers && rnd() < o.flower) {
           const fa = rnd() * 6.283;
           K2.e("plain", cx + dx + Math.cos(fa) * r * 0.78, cy + dy + r * 0.5 + rnd() * r * 0.5, cz + dz + Math.sin(fa) * r * 0.78, 0.028 + rnd() * 0.012, 0.05, o.flowers[rnd() * o.flowers.length | 0]);
         }
@@ -7644,7 +7766,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         else blobs(K2, x, bh - 0.05, z, 0.24 + rnd() * 0.08, 6, green2, rnd, { flatten: true, flower: tp === "flower" ? 0.9 : 0.25, flowers: FLOWERS.slice(i % 3, i % 3 + 3) });
       }
     }
-    Object.assign(K, { GREENS: GREENS2, FLOWERS, blobs, potModel, arcLeaf, tuft, palm_tree, treeModel, shrubModel, potPlant, tablePot, planterModel });
+    const defined = { GREENS: GREENS2, FLOWERS, blobs, potModel, arcLeaf, tuft, palm_tree, treeModel, shrubModel, potPlant, tablePot, planterModel };
+    Object.assign(K, defined);
   }
 
   // src/furniture/yard.ts
@@ -7800,7 +7923,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
     FURNITURE.mailbox = function(M, A) {
       const K2 = kit2(M, A, 0), w = M.w || 0.3, d = M.d || 0.22, h = M.h || 0.3, y = M.y != null && M.y > 0 ? M.y : 1, structure = STYLE(), pc = structure === "high" ? 2763824 : structure === "mid" ? 13676640 : 13126202, rnd = rngString(SEED() + "|" + seedKey(M.seed) + "|correio");
-      if (M.pole !== false && !(M.y > 0)) {
+      if (M.pole !== false && !(M.y != null && M.y > 0)) {
         K2.b("plain", 0, 0, -d / 2 - 0.1, 0.12, y, 0.12, 12104874);
       }
       K2.b("metal", 0, y, 0, w, h * 0.78, d, pc);
@@ -7820,7 +7943,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       );
       K2.b("plain", 0, y + h * 0.62, d / 2 + 4e-3, 0.08, 0.05, 4e-3, 15921386);
     };
-    Object.assign(K, { CLOTHES_COLORS, strip, garment });
+    const defined = { CLOTHES_COLORS, strip, garment };
+    Object.assign(K, defined);
   }
 
   // src/furniture/extra-types.ts
@@ -7880,7 +8004,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         tuft(K2, 0, 0, 0, Math.max(0.2, (M.w || 0.4) / 2), 16, 5212738, rnd);
       });
     }
-    Object.assign(K, { extraTypes });
+    const defined = { extraTypes };
+    Object.assign(K, defined);
   }
 
   // src/furniture/place-items.ts
@@ -7902,8 +8027,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (m.type === "stairs") continue;
         const exterior = m.outdoor || m.floor < 0, f = exterior ? -1 : Math.min(m.floor, R.floors.length - 1);
         cursor.group = exterior ? "lot" : "f" + f;
-        const com = shared.ctx.roomById[m.room], base = exterior ? 0 : Y0(f);
-        const M = { x: m.x, z: m.z, ry: m.ry || 0, w: m.w, d: m.d, h: m.h, y: m.y || 0, base, floor: exterior ? -1 : f, palette: shared.ctx.colors, color: m.category === "ground_cover" ? void 0 : colorOf(m.color) != null ? colorOf(m.color) : void 0, seed: m.id, room: m.room, typeWith: com ? com.type : null, ceiling: com ? com.ceiling : 2.9, on: shared.ctx.night, light: shared.ctx.night, lit: shared.ctx.night, open: !!m.doorOpen, overhead: m.overhead, assembly: m.assembly, hose: m.hose };
+        const com = m.room != null ? shared.ctx.roomById[m.room] : void 0, base = exterior ? 0 : Y0(f);
+        const M = { x: m.x, z: m.z, ry: m.ry || 0, w: m.w, d: m.d, h: m.h, y: m.y || 0, base, floor: exterior ? -1 : f, palette: shared.ctx.colors, color: m.category === "ground_cover" ? void 0 : colorOf(m.color) ?? void 0, seed: m.id, room: m.room, typeWith: com ? com.type : null, ceiling: com ? com.ceiling : 2.9, on: shared.ctx.night, light: shared.ctx.night, lit: shared.ctx.night, open: !!m.doorOpen, overhead: m.overhead, assembly: m.assembly, hose: m.hose };
         if (m.category === "ground_cover" && m.polygon) {
           const xs = m.polygon.map((p) => p[0]), zs = m.polygon.map((p) => p[1]);
           M.x = (Math.min(...xs) + Math.max(...xs)) / 2;
@@ -7980,7 +8105,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       boxC("plain", m.x, M.base + (m.y || 0) + h / 2, m.z, m.w, h, m.d, color2, 0, m.ry || 0, 0);
       shared.ctx.labels.push({ pos: new THREE.Vector3(m.x, M.base + (m.y || 0) + h + 0.15, m.z), text: m.type, group, type: "no_model" });
     }
-    Object.assign(K, { houseItems, waterTankOfHouse, hashColor, labeledBox });
+    const defined = { houseItems, waterTankOfHouse, hashColor, labeledBox };
+    Object.assign(K, defined);
   }
 
   // src/vegetation/bridge.ts
@@ -8015,7 +8141,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const ids = VEG_MAP[m.type], can = VEG_PLANTER[m.type];
       if (!ids && !can) return false;
       const rnd = rngString(SEED() + "|" + seedKey(m.id) + "|veg"), pick2 = (l) => l[Math.min(l.length - 1, rnd() * l.length | 0)], ok = (id) => {
-        if (V.ok.has(id)) return V.ok.get(id);
+        if (V.ok.has(id)) return V.ok.get(id) === true;
         let r = true;
         try {
           V.S.toSpec(id);
@@ -8061,7 +8187,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         obj.position.y = G.y;
         obj.name = "vegetation";
         obj.traverse((o) => {
-          if (o.isMesh) {
+          if (isMesh(o)) {
             o.castShadow = true;
             o.receiveShadow = true;
             o.name = "veg/" + o.name;
@@ -8076,7 +8202,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       shared.ctx.vegInfo = { plants: pl, triangles: tri, colliders: col, lodCounts: lod, materials: mats };
     }
-    Object.assign(K, { VEG_POT, VEG_CACTUS, VEG_MAP, VEG_PLANTER, vegItem, assembleVegetation });
+    const defined = { VEG_POT, VEG_CACTUS, VEG_MAP, VEG_PLANTER, vegItem, assembleVegetation };
+    Object.assign(K, defined);
   }
 
   // src/interaction/state.ts
@@ -8144,12 +8271,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       shared.inter.msg = { text, until: performance.now() + MESSAGE_MS };
       if (cfg.onMessage) cfg.onMessage(text);
     };
-    function definePiece(name, def) {
+    const I = () => shared.inter;
+    function definePiece(name, definition) {
+      const def = definition;
       def.name = name;
       def.meshes = [];
       def.t = def.target = shared.partState.has(name) ? shared.partState.get(name) : def.t0 || 0;
-      shared.inter.defs.set(name, def);
-      shared.inter.pieces.push(def);
+      I().defs.set(name, def);
+      I().pieces.push(def);
       return def;
     }
     const localOf = (M, lx, lz) => {
@@ -8161,17 +8290,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return true;
     }
     function assembleInteractive(gs) {
-      for (const [name, def] of shared.inter.defs) {
+      const inter = I();
+      for (const [name, def] of inter.defs) {
         const g = gs[name];
         if (!g) continue;
         delete gs[name];
         const outer = new THREE.Group();
-        outer.position.set(...def.pivot);
+        outer.position.fromArray(def.pivot);
         outer.rotation.y = def.ry || 0;
         outer.updateMatrix();
-        const inv = new THREE.Matrix4().compose(new THREE.Vector3(...def.pivot), new THREE.Quaternion().setFromAxisAngle(_EY, def.ry || 0), _UM3).invert();
+        const inv = new THREE.Matrix4().compose(new THREE.Vector3().fromArray(def.pivot), new THREE.Quaternion().setFromAxisAngle(_EY, def.ry || 0), _UM3).invert();
         g.traverse((o) => {
-          if (o.isMesh) {
+          if (isMesh(o)) {
             o.geometry.applyMatrix4(inv);
             o.userData.piece = def;
             def.meshes.push(o);
@@ -8183,13 +8313,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const parent = def.leaf ? def.leaf.gs[def.k] : gs[def.parent] || (gs[def.parent] = new THREE.Group());
         if (parent) parent.add(outer);
         if (def.roomId) {
-          if (!shared.inter.lights.has(def.roomId)) shared.inter.lights.set(def.roomId, []);
-          shared.inter.lights.get(def.roomId).push(def);
+          let lamps = inter.lights.get(def.roomId);
+          if (!lamps) inter.lights.set(def.roomId, lamps = []);
+          lamps.push(def);
         }
         applyPiece(def);
       }
-      for (const roomId of shared.inter.litRooms) applyLight(roomId);
-      shared.inter.defs.forEach((d) => {
+      for (const roomId of inter.litRooms) applyLight(roomId);
+      inter.defs.forEach((d) => {
         if (d.col) d.col.off = d.t > 0.5;
       });
     }
@@ -8197,6 +8328,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const n = p.inner;
       if (!n) return;
       switch (p.kind) {
+        /* each kind always sets its dimensions (sgn, angle, travel, k, axis) */
         case "swing":
           n.rotation.y = p.sgn * p.t * p.angle;
           break;
@@ -8229,8 +8361,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     const DURATION = { swing: 0.55, drawer: 0.4, curtain: 0.9, gate_swing: 0.9, gate_tilt: 1.4, gate_slide: 1.6, lightSwitch: 0.12, part: 0.4 };
     function animateInteractive(dt) {
-      if (!shared.inter.anim.size) return;
-      for (const p of shared.inter.anim) {
+      const inter = I();
+      if (!inter.anim.size) return;
+      for (const p of inter.anim) {
         const step = dt / (DURATION[p.kind] || 0.5), d = p.target - p.t;
         p.t = Math.abs(d) <= step ? p.target : p.t + Math.sign(d) * step;
         applyPiece(p);
@@ -8238,7 +8371,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           p.col.off = p.target > 0.5;
           colliderChanged(p.col);
         }
-        if (p.t === p.target) shared.inter.anim.delete(p);
+        if (p.t === p.target) inter.anim.delete(p);
       }
       invalidateShadow();
     }
@@ -8249,7 +8382,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         p.col.off = p.target > 0.5;
         colliderChanged(p.col);
       }
-      shared.inter.anim.add(p);
+      I().anim.add(p);
     }
     const lightBase = (roomId) => roomId == null ? true : shared.partState.has("light:" + roomId) ? !!shared.partState.get("light:" + roomId) : !!shared.ctx.night;
     const lightOn = (roomId) => {
@@ -8257,20 +8390,21 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return S ? S.ef : lightBase(roomId);
     };
     function applyLight(roomId) {
-      const on = lightOn(roomId);
-      for (const d of shared.inter.lights.get(roomId) || []) for (const m of d.meshes) if (m.name.endsWith("/emissive")) m.material = on ? shared.mats.emissive : shared.mats.off;
-      const sw = shared.inter.defs.get("ix:int:" + roomId);
+      const on = lightOn(roomId), inter = I(), mats = shared.mats;
+      for (const d of inter.lights.get(roomId) || []) for (const m of d.meshes) if (m.name.endsWith("/emissive")) m.material = on ? mats.emissive : mats.off;
+      const sw = inter.defs.get("ix:int:" + roomId);
       if (sw) {
         sw.target = on ? 1 : 0;
-        if (sw.t !== sw.target) shared.inter.anim.add(sw);
+        if (sw.t !== sw.target) inter.anim.add(sw);
       }
       invalidate();
     }
     function toggleLight(roomId) {
       const S = shared.ctx.iv && shared.ctx.iv.roomStates.get(roomId);
       if (S) {
-        ivRoomLight(shared.ctx.iv, roomId, !S.ef);
-        const ef = ivRoomEffective(shared.ctx.iv, S);
+        const IV = shared.ctx.iv;
+        ivRoomLight(IV, roomId, !S.ef);
+        const ef = ivRoomEffective(IV, S);
         if (ef !== S.ef) {
           S.ef = ef;
           applyLight(roomId);
@@ -8282,11 +8416,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       applyLight(roomId);
       if (cfg.onLight) cfg.onLight(roomId, lightOn(roomId));
     }
-    Object.assign(K, { newInteractiveState, MESSAGE_MS, createInteractiveMaterials, _EY, _UM3, hudMessage, definePiece, localOf, visibleChain, assembleInteractive, applyPiece, DURATION, animateInteractive, togglePiece, lightBase, lightOn, applyLight, toggleLight });
+    const defined = { newInteractiveState, MESSAGE_MS, createInteractiveMaterials, _EY, _UM3, hudMessage, definePiece, localOf, visibleChain, assembleInteractive, applyPiece, DURATION, animateInteractive, togglePiece, lightBase, lightOn, applyLight, toggleLight };
+    Object.assign(K, defined);
   }
 
   // src/interaction/collision.ts
   function installInteractionCollision(K, shared) {
+    const inter = () => shared.inter;
     const NO_COLLIDE = /(^|_)(rug|floor|concrete|dirt|lawn|deck|ceiling_light|pendant|chandelier|spot|picture|curtain|blinds|wall_shelving|plank_shelf|wall_ac|ac_condenser|pool|soaking_tub|pergola|stairs|mirror)/;
     function registerCollision(m, M) {
       const h = m.h || 0, y = M.y || 0;
@@ -8296,7 +8432,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         w = Math.min(w, 0.5);
         d = Math.min(d, 0.5);
       }
-      shared.inter.objs.push({ f: M.floor, cx: m.x, cz: m.z, c: Math.cos(M.ry), s: Math.sin(M.ry), hw: w / 2, hd: d / 2, type: m.type });
+      inter().objs.push({ f: M.floor, cx: m.x, cz: m.z, c: Math.cos(M.ry), s: Math.sin(M.ry), hw: w / 2, hd: d / 2, type: m.type });
     }
     function objectDistance(o, x, z) {
       const dx = x - o.cx, dz = z - o.cz, lx = dx * o.c - dz * o.s, lz = dx * o.s + dz * o.c, ex = Math.abs(lx) - o.hw, ez = Math.abs(lz) - o.hd;
@@ -8304,7 +8440,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     function collideObject(x, z, fx, fz, floor) {
       const R = 0.2;
-      for (const o of shared.inter.objs) {
+      for (const o of inter().objs) {
         if (o.f !== -1 ? o.f !== floor : floor !== 0) continue;
         const d1 = objectDistance(o, x, z);
         if (d1 < R && d1 < objectDistance(o, fx, fz) - 1e-6) return true;
@@ -8324,7 +8460,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const de = opt.from || [x + 1e4, z + 1e4];
       return collideObject(x, z, de[0], de[1], floor);
     }
-    Object.assign(K, { NO_COLLIDE, registerCollision, objectDistance, collideObject, collideAt });
+    const defined = { NO_COLLIDE, registerCollision, objectDistance, collideObject, collideAt };
+    Object.assign(K, defined);
   }
 
   // src/interaction/items.ts
@@ -8333,6 +8470,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const DOOR_ITEM = /^(tv_unit|tv_unit_small|tv_unit_large|sideboard|china_cabinet|filing_cabinet|pantry|laundry_cabinet|wardrobe|wardrobe_small|wardrobe_large|closet_wardrobe|kitchen_cabinet|kitchen_cabinet_large|kitchen_cabinet_small|fridge|fridge_large|display_fridge_medium|display_fridge)$/;
     const DRAWER_ITEM = /^(console_table|dresser|nightstand|vanity_table)$/;
     const LIGHT_TYPES = /* @__PURE__ */ new Set(["ceiling_light", "pendant", "chandelier", "track_spot", "hanging_plant"]);
+    const I = () => shared.inter;
     function objectName(type, drawer) {
       return drawer ? "drawer" : /^wardrobe/.test(type) ? "wardrobe" : /fridge|refrig|freezer/.test(type) ? "fridge" : /pantry/.test(type) ? "pantry" : "cabinet";
     }
@@ -8361,8 +8499,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         cursor.group = parent;
       }
       for (let i = n0; i < LIGHTS.length; i++) LIGHTS[i].roomId = m.room;
-      if (!shared.inter.defs.has(name)) definePiece(name, { kind: "light", pivot: [0, 0, 0], ry: 0, parent, roomId: m.room });
-      shared.inter.litRooms.add(m.room);
+      if (!I().defs.has(name)) definePiece(name, { kind: "light", pivot: [0, 0, 0], ry: 0, parent, roomId: m.room });
+      I().litRooms.add(m.room);
     }
     function curtainItem(m, M, ent, api, parent) {
       M.open = false;
@@ -8390,12 +8528,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       for (const c of body) api[c[0]](M, ...c[1]);
       if (!parts.length) return;
       const [ax, az] = localOf(M, 0, 0.2);
-      shared.inter.items.push({ type: "curtain", id: m.id, floor: M.floor, anchor: [ax, M.base + (M.y || 0) + (m.h || 2) * 0.5, az], range: 2.4, angle: 1, pieces: parts, text: () => t(parts[0].target > 0.5 ? "prompt.close" : "prompt.open", { what: t("what.curtain") }), action: () => {
-        const al = parts[0].target > 0.5 ? 0 : 1;
+      const first = parts[0];
+      I().items.push({ type: "curtain", id: m.id, floor: M.floor, anchor: [ax, M.base + (M.y || 0) + (m.h || 2) * 0.5, az], range: 2.4, angle: 1, pieces: parts, text: () => t(first.target > 0.5 ? "prompt.close" : "prompt.open", { what: t("what.curtain") }), action: () => {
+        const al = first.target > 0.5 ? 0 : 1;
         for (const p of parts) {
           p.target = al;
           shared.partState.set(p.name, al);
-          shared.inter.anim.add(p);
+          I().anim.add(p);
         }
       } });
     }
@@ -8416,7 +8555,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       calls.forEach((c, i) => {
         if (owner.has(i)) return;
         const a = c[1];
-        let x0, x1, y0, y1, ok = false, grip = 0, wide = false;
+        let x0 = 0, x1 = 0, y0 = 0, y1 = 0, ok = false, grip = 0, wide = false;
         if (c[0] === "box") {
           const [mat, x, y, z, w, h, d, , ry, rx, rz] = a;
           if (ry || rx || rz || d > 0.05 || z + d / 2 < front - 5e-3 || w > M.w * 1.01) return;
@@ -8448,8 +8587,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           return;
         }
         candidate.sort((p, q) => overlap(x0, x1, q.x0, q.x1) - overlap(x0, x1, p.x0, p.x1));
-        owner.set(i, candidate[0]);
-        if (grip) candidate[0].grip = grip;
+        const best = candidate[0];
+        owner.set(i, best);
+        if (grip) best.grip = grip;
       });
       const name = objectName(m.type, drawer), parts = [];
       panels.forEach((p, k) => {
@@ -8465,8 +8605,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         p.def = def;
         parts.push(def);
         const [ax, az] = localOf(M, cx, front + 0.08);
-        shared.inter.items.push({ type: drawer ? "drawer" : "cabinet", id: m.id, floor: M.floor, anchor: [ax, M.base + (M.y || 0) + (p.y0 + p.y1) / 2, az], range: 1.6, angle: 0.4, pieces: [def], text: () => t(def.target > 0.5 ? "prompt.close" : "prompt.open", { what: t("what." + name) }), action: () => togglePiece(def) });
-        def.item = shared.inter.items[shared.inter.items.length - 1];
+        I().items.push({ type: drawer ? "drawer" : "cabinet", id: m.id, floor: M.floor, anchor: [ax, M.base + (M.y || 0) + (p.y0 + p.y1) / 2, az], range: 1.6, angle: 0.4, pieces: [def], text: () => t(def.target > 0.5 ? "prompt.close" : "prompt.open", { what: t("what." + name) }), action: () => togglePiece(def) });
+        def.item = I().items[I().items.length - 1];
       });
       calls.forEach((c, i) => {
         const p = owner.get(i);
@@ -8480,14 +8620,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       cursor.group = parent;
     }
-    Object.assign(K, { DOOR_ITEM, DRAWER_ITEM, LIGHT_TYPES, objectName, recordApi, buildItem, lightItem, curtainItem, furnitureItem });
+    const defined = { DOOR_ITEM, DRAWER_ITEM, LIGHT_TYPES, objectName, recordApi, buildItem, lightItem, curtainItem, furnitureItem };
+    Object.assign(K, defined);
   }
 
   // src/interaction/fittings.ts
   function installInteractionFittings(K, shared) {
     const { t, EPS: EPS3, OPEN_AREA, Y0, applyPiece, bx, cursor, definePiece, gates, lightOn, roomAt, slideDirection, toggleLight, togglePiece } = K;
+    const I = () => shared.inter;
+    const house = () => shared.ctx.r;
     function gatesInteractive() {
-      const lt = shared.ctx.r.lot;
+      const lt = house().lot;
       if (!lt) return;
       const cz0 = (lt.rect[1] + lt.rect[3]) / 2;
       const orig = K.getBx(), gs = lt.gates, opening = gs.map((g) => g.open), reg = gs.map((g) => {
@@ -8507,9 +8650,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             return;
           }
         }
-        return orig(mat, x0, y0, z0, x1, y1, z1, color2);
+        orig(mat, x0, y0, z0, x1, y1, z1, color2);
       });
-      const n0 = shared.ctx.colliders.length;
+      const colliders = shared.ctx.colliders, n0 = colliders.length;
       try {
         gs.forEach((g) => {
           g.open = false;
@@ -8521,7 +8664,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           g.open = opening[i];
         });
       }
-      const cols = shared.ctx.colliders.slice(n0), cz = (lt.rect[1] + lt.rect[3]) / 2, cu = (lt.rect[0] + lt.rect[2]) / 2;
+      const cols = colliders.slice(n0), cz = (lt.rect[1] + lt.rect[3]) / 2, cu = (lt.rect[0] + lt.rect[2]) / 2;
       reg.forEach((r, i) => {
         const g = r.g;
         if (!isFinite(r.x0)) return;
@@ -8530,25 +8673,25 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const p = ped ? definePiece(name, Object.assign(base, { kind: "gate_swing", pivot: [r.x0, 0, g.v], angle: -sd * 1.65 })) : tilt ? definePiece(name, Object.assign(base, { kind: "gate_tilting", pivot: [(r.x0 + r.x1) / 2, r.y1, g.v], angle: -sd * 1.45 })) : definePiece(name, Object.assign(base, { kind: "gate_sliding", pivot: [r.x0, 0, r.zm], travel: r.dx * g.width }));
         if (p.col) p.col.off = p.target > 0.5;
         const text = () => t(p.target > 0.5 ? "prompt.close" : "prompt.open", { what: t(ped ? "what.pedestrianGate" : "what.garageGate") });
-        shared.inter.items.push({ type: "gate", id: g.id, floor: -1, anchor: [g.u, 1, g.v + sd * 0.4], range: 2.8, angle: 0.9, pieces: [p], text, action: () => togglePiece(p), noWall: true });
+        I().items.push({ type: "gate", id: g.id, floor: -1, anchor: [g.u, 1, g.v + sd * 0.4], range: 2.8, angle: 0.9, pieces: [p], text, action: () => togglePiece(p), noWall: true });
       });
     }
     function mailboxInteractive() {
-      for (const m of shared.ctx.r.items) {
+      for (const m of house().items) {
         if (m.type !== "mailbox") continue;
         const g = shared.ctx.parts && shared.ctx.parts["mailbox_" + m.id];
         if (!g) continue;
         const name = "ix:correio:" + m.id, def = definePiece(name, { kind: "part", pivot: [0, 0, 0], ry: 0, parent: "lot" });
         def.inner = g;
         const fx = Math.sin(m.ry || 0), fz = Math.cos(m.ry || 0), ay = (m.y || 1) + (m.h || 0.3) * 0.4;
-        shared.inter.items.push({ type: "mailbox", id: m.id, floor: -1, anchor: [m.x + fx * 0.2, ay, m.z + fz * 0.2], range: 2.2, angle: 0.7, pieces: [def], text: () => t(def.target > 0.5 ? "prompt.close" : "prompt.open", { what: t("what.mailbox") }), action: () => togglePiece(def), noWall: true });
+        I().items.push({ type: "mailbox", id: m.id, floor: -1, anchor: [m.x + fx * 0.2, ay, m.z + fz * 0.2], range: 2.2, angle: 0.7, pieces: [def], text: () => t(def.target > 0.5 ? "prompt.close" : "prompt.open", { what: t("what.mailbox") }), action: () => togglePiece(def), noWall: true });
         applyPiece(def);
       }
     }
     function placeSwitches() {
-      const R = shared.ctx.r, used = /* @__PURE__ */ new Set();
+      const R = house(), used = /* @__PURE__ */ new Set();
       for (const c of R.rooms) {
-        if (c.type === "void" || OPEN_AREA(c) || !shared.inter.litRooms.has(c.id) || used.has(c.id) || shared.ctx.iv && shared.ctx.iv.switchRooms.has(c.id)) continue;
+        if (c.type === "void" || OPEN_AREA(c) || !I().litRooms.has(c.id) || used.has(c.id) || shared.ctx.iv && shared.ctx.iv.switchRooms.has(c.id)) continue;
         const doors = R.doors.filter((p) => p.floor === c.floor && (p.a === c.id || p.b === c.id));
         doors.sort((p, q) => ((q.exterior ? 1 : 0) - (p.exterior ? 1 : 0)) * (c.type === "living" ? 1 : -1));
         for (const p of doors) if (putSwitch(c, p)) {
@@ -8558,11 +8701,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
     }
     function putSwitch(c, p) {
-      const R = shared.ctx.r, f = p.floor, alongU = p.axis === "u", L = p.pos, a = p.at - p.width / 2, b = p.at + p.width / 2;
+      const R = house(), f = p.floor, alongU = p.axis === "u", L = p.pos, a = p.at - p.width / 2, b = p.at + p.width / 2;
       const wref = R.walls.find((w) => w.floor === f && w.axis === p.axis && Math.abs((alongU ? w.v0 : w.u0) - L) < EPS3), th = wref ? wref.thickness || 0.15 : 0.15;
       const inside2 = (sd2) => {
         const cc = roomAt(f, alongU ? p.at : L + sd2 * 0.4, alongU ? L + sd2 * 0.4 : p.at);
-        return cc && cc.id === c.id;
+        return !!cc && cc.id === c.id;
       };
       const sd = inside2(1) ? 1 : inside2(-1) ? -1 : 0;
       if (!sd) return false;
@@ -8585,19 +8728,22 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const piece2 = definePiece("ix:int:" + roomId, { kind: "light_switch", pivot: pv, ry: 0, parent: "f" + f, axis: alongU ? "x" : "z", sgn: alongU ? sd : -sd, t0: lightOn(roomId) ? 1 : 0 });
         piece2.t = piece2.target = lightOn(roomId) ? 1 : 0;
         const an = alongU ? [u, yc, face + sd * 0.12] : [face + sd * 0.12, yc, u];
-        shared.inter.items.push({ type: "light_switch", id: roomId, floor: f, anchor: an, range: 1.5, angle: 0.45, pieces: [piece2], text: () => t(lightOn(roomId) ? "prompt.lightOff" : "prompt.lightOn"), action: () => toggleLight(roomId) });
+        I().items.push({ type: "light_switch", id: roomId, floor: f, anchor: an, range: 1.5, angle: 0.45, pieces: [piece2], text: () => t(lightOn(roomId) ? "prompt.lightOff" : "prompt.lightOn"), action: () => toggleLight(roomId) });
         return true;
       }
       return false;
     }
-    Object.assign(K, { gatesInteractive, mailboxInteractive, placeSwitches, putSwitch });
+    const defined = { gatesInteractive, mailboxInteractive, placeSwitches, putSwitch };
+    Object.assign(K, defined);
   }
 
   // src/interaction/doors.ts
   function installInteractionDoors(K, shared) {
     const { t, colliderChanged, invalidateShadow, applyPiece, hudMessage } = K;
+    const leaves = () => shared.ctx.leaves;
     function linkDoorLeaves() {
-      for (const fo of shared.ctx.leaves) fo.handles = (fo.handleNames || []).map((n) => shared.inter.defs.get(n)).filter(Boolean);
+      const I = shared.inter;
+      for (const fo of leaves()) fo.handles = (fo.handleNames || []).map((n) => I.defs.get(n)).filter((d) => !!d);
     }
     function handleApply(fo) {
       for (const mc of fo.handles || []) {
@@ -8607,11 +8753,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     function toggleDoor(fo) {
       if (fo.phase === "rattle") return;
+      const col = fo.col;
       if (fo.phase === "handle" || fo.phase === "swing") {
         fo.open = !fo.open;
         shared.doorState.set(fo.id, fo.open);
-        fo.col.off = fo.open;
-        colliderChanged(fo.col);
+        col.off = fo.open;
+        colliderChanged(col);
         fo.anim = true;
         fo.phase = "swing";
         return;
@@ -8625,8 +8772,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       fo.open = !fo.open;
       shared.doorState.set(fo.id, fo.open);
-      fo.col.off = fo.open;
-      colliderChanged(fo.col);
+      col.off = fo.open;
+      colliderChanged(col);
       fo.anim = true;
       shared.ctx.animateDoorsOn = true;
       if (fo.handles && fo.handles.length) {
@@ -8637,7 +8784,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function animateDoors(dt) {
       if (!shared.ctx.animateDoorsOn) return;
       let active = false;
-      for (const fo of shared.ctx.leaves) {
+      for (const fo of leaves()) {
         if (!fo.phase) continue;
         active = true;
         if (fo.phase === "handle") {
@@ -8657,7 +8804,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           handleApply(fo);
           if (fo.hT <= 0) fo.phase = null;
         } else if (fo.phase === "rattle") {
-          fo.jig -= dt;
+          fo.jig = (fo.jig ?? 0) - dt;
           fo.hT = fo.jig > 0 ? 0.55 * Math.abs(Math.sin(fo.jig * 26)) : 0;
           handleApply(fo);
           if (fo.jig <= 0) {
@@ -8671,9 +8818,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       invalidateShadow();
     }
     function wallBlocks(ex, ez, ax, az, floor) {
-      const n = shared.ctx.wallColliders != null ? shared.ctx.wallColliders : 0;
+      const n = shared.ctx.wallColliders != null ? shared.ctx.wallColliders : 0, colliders = shared.ctx.colliders;
       for (let i = 0; i < n; i++) {
-        const c = shared.ctx.colliders[i];
+        const c = colliders[i];
         if (c.f !== floor && !(c.f === -1 && floor === 0)) continue;
         let t0 = 0, t1 = 1;
         const dx = ax - ex, dz = az - ez;
@@ -8703,7 +8850,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         g.updateMatrix();
       }
     }
-    Object.assign(K, { linkDoorLeaves, handleApply, toggleDoor, animateDoors, wallBlocks, doorText, applyLeaf });
+    const defined = { linkDoorLeaves, handleApply, toggleDoor, animateDoors, wallBlocks, doorText, applyLeaf };
+    Object.assign(K, defined);
   }
 
   // src/interaction/target.ts
@@ -8713,6 +8861,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function targetOf(o, opt) {
       if (!o) return null;
       opt = opt || {};
+      const I = shared.inter;
       const ex = o.x, ey = o.y, ez = o.z, floor = o.floor, cp = Math.cos(o.pitch || 0), vx = Math.sin(o.yaw) * cp, vy = Math.sin(o.pitch || 0), vz = Math.cos(o.yaw) * cp;
       let best = null;
       const tries = (score, text, action, target) => {
@@ -8726,16 +8875,16 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (angle > 1.35 && d > 0.9) continue;
         tries(angle * 1.6 + d * 0.5 + (angle < 0.25 ? 0 : 0.6), doorText(fo), () => toggleDoor(fo), fo);
       }
-      const vis = shared.inter.pieces.flatMap((p) => p.meshes).filter(visibleChain), hit = vis.length && opt.strike ? opt.strike(vis) : null;
+      const vis = I.pieces.flatMap((p) => p.meshes).filter(visibleChain), hit = vis.length && opt.strike ? opt.strike(vis) : null;
       const kitA = shared.ctx.iv ? ivTarget(shared.ctx.iv, o, opt && opt.interactives) : null;
       const nearKit = kitA && hit && Math.hypot(kitA.target.pos[0] - ex, kitA.target.pos[1] - ey, kitA.target.pos[2] - ez) < hit.distance + 0.1;
       const pieceHit = hit && !nearKit && hit.object.userData.piece;
-      for (const it of shared.inter.items) {
+      for (const it of I.items) {
         if (it.floor !== floor && !(it.floor === -1 && floor === 0)) continue;
         const [ax, ay, az] = it.anchor, dx = ax - ex, dy = ay - ey, dz = az - ez, d = Math.hypot(dx, dy, dz), dh = Math.hypot(dx, dz);
         if (dh > it.range + 0.4) continue;
         const angle = Math.acos(Math.max(-1, Math.min(1, (dx * vx + dy * vy + dz * vz) / (d || 1))));
-        const byRay = pieceHit && it.pieces.includes(pieceHit) && hit.distance <= it.range + 0.5;
+        const byRay = !!hit && pieceHit && it.pieces.includes(pieceHit) && hit.distance <= it.range + 0.5;
         if (!byRay && !(dh <= it.range && angle <= it.angle)) continue;
         if (!it.noWall && wallBlocks(ex, ez, ax, az, it.floor < 0 ? 0 : it.floor)) continue;
         tries((byRay ? 0 : angle * 2) + d * 0.3 - (byRay ? 1.5 : 0), it.text(), it.action, it);
@@ -8743,7 +8892,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (kitA) tries(kitA.score - (nearKit ? 0.5 : 0), kitA.text, kitA.action, kitA.target);
       return best;
     }
-    Object.assign(K, { targetOf });
+    const defined = { targetOf };
+    Object.assign(K, defined);
   }
 
   // src/interactables/bridge.ts
@@ -8800,7 +8950,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function ivBuild(h, water) {
       const ik = K.IVK, r = shared.ctx.r, A = ik.A, world0 = null;
       void world0;
-      const plane2 = A.plan(r, { seed: r.seed });
+      const source = r;
+      const plane2 = A.plan(source, { seed: r.seed });
       const IV = { k: ik, plane: plane2, world: null, water, entries: /* @__PURE__ */ new Map(), roots: [], replace: /* @__PURE__ */ new Set(), roomStates: /* @__PURE__ */ new Map(), lampRoom: /* @__PURE__ */ new Map(), anim: /* @__PURE__ */ new Map(), screens: /* @__PURE__ */ new Map(), efx: null, items: null, itemsDirty: true, itemsT: 0, dirty: true, list: null, listT: 0, t: 0, circuits: [], switchRooms: /* @__PURE__ */ new Set(), warnings: [], tBuild: 0 };
       h.IV = IV;
       const t0 = performance.now();
@@ -8819,9 +8970,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const wants = (roomId) => lightBase(roomId);
       const entById = new Map(plane2.items.map((e) => [e.id, e]));
       const entByItem = new Map(plane2.items.map((e) => [e.item, e]));
-      IV.mats = { plain: shared.mats.plain, metal: shared.mats.metal, wood: shared.mats.wood, glass: shared.mats.glass, fabric: shared.mats.fabric, plant: shared.mats.plant, water: shared.mats.water, emissive: shared.mats.emissive, atlas_picture: shared.mats.picture, atlas_floor: shared.mats.floor };
+      const mats = shared.mats;
+      IV.mats = { plain: mats.plain, metal: shared.mats.metal, wood: shared.mats.wood, glass: shared.mats.glass, fabric: shared.mats.fabric, plant: shared.mats.plant, water: shared.mats.water, emissive: shared.mats.emissive, atlas_picture: shared.mats.picture, atlas_floor: shared.mats.floor };
       const ev = (e) => ivEvent(h, e);
-      const world = IV.world = A.createWorld(r, { water, seed: r.seed, onEvent: ev });
+      const world = IV.world = A.createWorld(source, { water, seed: r.seed, onEvent: ev });
       const add0 = world.add;
       world.add = (id, spec, tr) => {
         const e = entById.get(id);
@@ -8838,7 +8990,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         return add0(id, spec, tr);
       };
-      const added = A.add(world, plane2, { isBlocked: A.blockedOf(r), build: (type, item) => ivDraw(IV, entByItem.get(item), type, item) });
+      const added = A.add(world, plane2, { isBlocked: A.blockedOf(source), build: (type, item) => ivDraw(IV, entByItem.get(item), type, item) });
       world.add = add0;
       IV.warnings = added.warnings;
       IV.added = added;
@@ -8885,14 +9037,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     function ivDraw(IV, ent, type, item) {
       const ik = IV.k, loc = Object.assign({}, item, { x: 0, z: 0, ry: 0 });
+      const ix = item.x, iz = item.z, iry = item.ry;
       const mesh2 = ik.gfx.createMeshApi({ quality: "game", materials: IV.mats, shadows: true, mergeParts: true, swayAmplitude: 0.03 });
       const spec = ik.A.household.build(type, loc, mesh2.api);
       const out = mesh2.finish(spec);
       for (const l of out.lights) l.removeFromParent();
       const group = ivGroup(ent), g0 = cursor.group, root = new THREE.Group();
       root.name = "iv:" + ent.id;
-      root.position.set(item.x, ent.floorY, item.z);
-      root.rotation.y = item.ry;
+      root.position.set(ix, ent.floorY, iz);
+      root.rotation.y = iry;
       root.userData.iv = ent.id;
       const screen = spec.devices && spec.devices.some((d) => d.kind === "screen");
       let body = null;
@@ -8901,7 +9054,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (type === "gas_bottle") {
         cursor.pc = pieceRecord("gas_cylinder:" + ent.id, "steel", null, { floor: ent.floor, mass: 11, form: "cyl", thickness: 3e-3, fill: 0.03, contains: { fluid: "gas", liters: 13, pressurized: true }, explodes: { energy: 12e4, radius: 5, atC: 300 }, tags: ["gas_bottle"] });
         for (const m of out.group.children) if (!m.name.startsWith("static:")) m.traverse((o) => {
-          if (o.isMesh) {
+          if (isMesh(o)) {
             o.userData.destructionPart = cursor.pc.id;
             o.userData.destructionMaterial = "steel";
           }
@@ -8909,13 +9062,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       try {
         for (const m of out.group.children.slice()) {
-          if (m.isMesh && m.name.startsWith("static:")) {
+          if (isMesh(m) && m.name.startsWith("static:")) {
             if (screen && m.userData.material === "emissive") {
               body = m;
               root.add(m);
               continue;
             }
-            ivAccumulate(IV_MATERIAL[m.userData.material] || "plain", m.geometry, item.x, ent.floorY, item.z, item.ry, null);
+            ivAccumulate(IV_MATERIAL[m.userData.material] || "plain", m.geometry, ix, ent.floorY, iz, iry, null);
             m.geometry.dispose();
           } else root.add(m);
         }
@@ -8925,7 +9078,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       const base = new Set(Object.values(IV.mats));
       root.traverse((o) => {
-        if (!o.isMesh) return;
+        if (!isMesh(o)) return;
         o.userData.iv = ent.id;
         if (o.castShadow) {
           if (!o.geometry.boundingSphere) o.geometry.computeBoundingSphere();
@@ -8936,7 +9089,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           roomLightMask(m);
         }
       });
-      const E = { id: ent.id, type, entry: ent, floor: ent.floor, group, root, parts: out.parts, spec, screen: body, pos: [item.x, ent.floorY, item.z], ry: item.ry, origin: ent.origin };
+      const E = { id: ent.id, type, entry: ent, floor: ent.floor, group, root, parts: out.parts, spec, screen: body, pos: [ix, ent.floorY, iz], ry: iry, origin: ent.origin };
       IV.entries.set(ent.id, E);
       if (root.children.length) IV.roots.push(E);
       return spec;
@@ -8964,7 +9117,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             const wire = (spec.wires || []).find((x) => x.id === d.id + "_cord"), pts = (wire ? wire.points : [d.plug]).map((p) => wl(o, p));
             const sid = w.power.pluggedInto(E.id, d.id);
             if (sid) {
-              const cut = sid.indexOf(":"), so = w.get(sid.slice(0, cut)), sk = so && so.spec.sockets.find((s) => s.id === sid.slice(cut + 1));
+              const cut = sid.indexOf(":"), so = w.get(sid.slice(0, cut)), sk = so && (so.spec.sockets || []).find((s) => s.id === sid.slice(cut + 1));
               if (so && sk) {
                 const sp = wl(so, sk.pos), dir = [Math.sin(so.transform.ry), Math.cos(so.transform.ry)], last = pts[pts.length - 1];
                 if (last[1] < 0.3 + E.pos[1]) {
@@ -8999,9 +9152,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         roomLightMask(sc.material);
         IV.screens.set(E.id, sc);
       }
-      E.screen.material = sc.material;
-      E.screen.castShadow = false;
-      E.screen.receiveShadow = false;
+      const mesh2 = E.screen;
+      mesh2.material = sc.material;
+      mesh2.castShadow = false;
+      mesh2.receiveShadow = false;
     }
     function ivEvent(h, e) {
       const IV = h.IV;
@@ -9037,16 +9191,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           IV.itemsDirty = true;
           break;
       }
-      if (K.IVK.onEvent) {
+      const ik = K.IVK;
+      if (ik.onEvent) {
         try {
-          K.IVK.onEvent(e, h.IV.pub);
+          ik.onEvent(e, IV.pub);
         } catch (err) {
           console.warn("interactables.onEvent", err);
         }
       }
-      if (e.type === "seat" && K.IVK.onSeat && e.actor === "player") {
+      if (e.type === "seat" && ik.onSeat && e.actor === "player") {
         try {
-          K.IVK.onSeat(e.seated ? ivSeat(IV) : null, e);
+          ik.onSeat(e.seated ? ivSeat(IV) : null, e);
         } catch (err) {
           console.warn("interactables.onSeat", err);
         }
@@ -9055,7 +9210,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function ivSeat(IV) {
       const w = IV.world, s = w.seatOf("player");
       if (!s) return null;
-      const o = w.get(s.object), seat = o.spec.seats.find((q) => q.id === s.seat), L = IV.k.GI.localToWorld, tr = o.transform, E = IV.entries.get(s.object);
+      const o = w.get(s.object), seat = (o.spec.seats || []).find((q) => q.id === s.seat), L = IV.k.GI.localToWorld, tr = o.transform, E = IV.entries.get(s.object);
       const eye = L(tr, [seat.pos[0], seat.pos[1] + (seat.eye === void 0 ? seat.pose === "lie" ? 0.18 : 0.62 : seat.eye), seat.pos[2]]);
       return { object: s.object, seatInfo: s.seat, pose: seat.pose, eye, yaw: tr.ry + seat.ry, pitch: seat.pose === "lie" ? 0.55 : -0.08, exitPoint: L(tr, seat.exit), floor: E ? E.floor : 0, type: E ? E.type : null };
     }
@@ -9097,18 +9252,19 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
       const em = w.emitters();
-      if (em.length && !IV.efx && K.IVK.effects) {
+      const ivk = K.IVK;
+      if (em.length && !IV.efx && ivk.effects) {
         const g = h.houseGroup;
-        IV.efx = ik.gfx.createEffects(g, { maxParticles: 1400, seed: 11, document: DOC, ...K.IVK.effectSink ? { effects: K.IVK.effectSink } : {} });
+        IV.efx = ik.gfx.createEffects(g, { maxParticles: 1400, seed: 11, document: DOC, ...ivk.effectSink ? { effects: ivk.effectSink } : {} });
       }
       if (IV.efx) {
         const alive = IV.efx.stats().alive;
         if (em.length || alive) {
-          IV.efx.update(dt, em, K.IVK.camera ? typeof K.IVK.camera === "function" ? K.IVK.camera() : K.IVK.camera : void 0);
+          IV.efx.update(dt, em, ivk.camera ? typeof ivk.camera === "function" ? ivk.camera() : ivk.camera : void 0);
           invalidate();
         }
       }
-      if (K.IVK.items && IV.itemsDirty && IV.t - IV.itemsT > 0.1 && !IV.anim.size) ivItems(IV, h);
+      if (ivk.items && IV.itemsDirty && IV.t - IV.itemsT > 0.1 && !IV.anim.size) ivItems(IV, h);
     }
     const IV_SHAPE = {
       can: [["cyl", 1, 1, 1, 0, 1]],
@@ -9143,7 +9299,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           if (c.access && w.partT(E.id, c.access) < 0.02) continue;
           const st = w.contents(E.id, c.id);
           for (let i = 0; i < st.length; i++) {
-            if (st[i] && items[st[i].type]) list2.push([E, c.id, i, items[st[i].type]]);
+            const stack = st[i];
+            if (stack && items[stack.type]) list2.push([E, c.id, i, items[stack.type]]);
           }
         }
       }
@@ -9172,12 +9329,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         gm.setIndex(new THREE.BufferAttribute(A.i.slice(0, A.ni), 1));
         gm.computeBoundingSphere();
         if (!IV.items) {
-          IV.items = new THREE.Mesh(gm, shared.mats.plain);
-          IV.items.name = "iv-items";
-          IV.items.castShadow = false;
-          IV.items.receiveShadow = true;
-          IV.items.frustumCulled = false;
-          h.houseGroup.add(IV.items);
+          const mesh2 = new THREE.Mesh(gm, shared.mats.plain);
+          IV.items = mesh2;
+          mesh2.name = "iv-items";
+          mesh2.castShadow = false;
+          mesh2.receiveShadow = true;
+          mesh2.frustumCulled = false;
+          h.houseGroup.add(mesh2);
         } else {
           IV.items.geometry.dispose();
           IV.items.geometry = gm;
@@ -9311,7 +9469,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       };
       return IV.pub;
     }
-    Object.assign(K, { IV_MATERIAL, IV_WIRE, IV_DOOR, ivGroup, ivAccumulate, ivBuild, ivRoomEffective, ivDraw, ivCords, ivAssemble, ivScreen, ivEvent, ivSeat, ivUpdate, IV_SHAPE, ivItems, ivTarget, ivRoomLight, ivParts, ivDispose, ivPublish });
+    const defined = { IV_MATERIAL, IV_WIRE, IV_DOOR, ivGroup, ivAccumulate, ivBuild, ivRoomEffective, ivDraw, ivCords, ivAssemble, ivScreen, ivEvent, ivSeat, ivUpdate, IV_SHAPE, ivItems, ivTarget, ivRoomLight, ivParts, ivDispose, ivPublish };
+    Object.assign(K, defined);
   }
 
   // src/animation/clotheslines.ts
@@ -9336,7 +9495,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       invalidate();
     }
-    Object.assign(K, { WIND, animateClotheslines });
+    const defined = { WIND, animateClotheslines };
+    Object.assign(K, defined);
   }
 
   // src/build/instance.ts
@@ -9361,7 +9521,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       shared.quality = h.quality;
     }
     const tagDamage = (type) => ({ type, hp: HP[type], hpMax: HP[type] });
-    Object.assign(K, { props, TYPES, newState, enter, tagDamage });
+    const defined = { props, TYPES, newState, enter, tagDamage };
+    Object.assign(K, defined);
   }
 
   // ../game-floorplan-interactables/dist/index.js
@@ -10748,17 +10909,20 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       for (const k of ["wood", "foliage", "flowers", "fruit", "spines"]) roomLightMask(m[k]);
       return m;
     })());
-    Object.assign(K, { IVK, VEG, vegMaterials });
+    const defined = { IVK, VEG, vegMaterials };
+    Object.assign(K, defined);
   }
 
   // src/lights/room-light.ts
+  var newGroup = (k, house, exterior) => ({ k, house, ls: [], exterior, pos: [0, 0, 0], color: 0, n: 0, range: 0, rects: [], y: [0, 0], exclusion: null, lumens: 0, dist: 0, decay: 0, floor: 0, roomId: null, dm: 0, d: 0 });
   function installLightsRoomLight(K, shared) {
     const { THREE, rectsOf: rectsOf2, cfg } = K;
     const MAX_LIGHTS = 12, EMPTY = [1e9, 1e9, -1e9, -1e9];
     const LZU = { uRB0: { value: new Float32Array(MAX_LIGHTS * 4) }, uRB1: { value: new Float32Array(MAX_LIGHTS * 4) }, uRB2: { value: new Float32Array(MAX_LIGHTS * 4) }, uRBY: { value: new Float32Array(MAX_LIGHTS * 2) }, uREx: { value: new Float32Array(MAX_LIGHTS * 4) }, uIndK: { value: 0.06 } };
     for (let i = 0; i < MAX_LIGHTS; i++) for (const k of ["uRB0", "uRB1", "uRB2", "uREx"]) LZU[k].value.set(EMPTY, i * 4);
-    function roomLightMask(m) {
-      if (!m || m.userData && m.userData.roomLightMask || !(m.isMeshLambertMaterial || m.isMeshPhongMaterial || m.isMeshStandardMaterial || m.isMeshPhysicalMaterial)) return m;
+    function roomLightMask(material) {
+      const m = material;
+      if (!m || m.userData && m.userData.roomLightMask || !(m.isMeshLambertMaterial || m.isMeshPhongMaterial || m.isMeshStandardMaterial || m.isMeshPhysicalMaterial)) return material;
       m.userData = m.userData || {};
       m.userData.roomLightMask = true;
       const prev = m.onBeforeCompile, pk = m.customProgramCacheKey;
@@ -10786,12 +10950,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         return (pk ? pk.call(this) : "") + "|rm1";
       };
       m.needsUpdate = true;
-      return m;
+      return material;
     }
-    function lighting(o) {
-      o = o || {};
+    function lighting(options) {
+      const o = options || {};
       const scene = o.scene, N = Math.max(1, Math.min(MAX_LIGHTS, o.n || 6)), NS = Math.max(0, Math.min(N, o.shadows != null ? o.shadows : 2)), size = o.shadowSize || 512, MAX_EXTERNAL = o.external != null ? o.external : 2;
-      for (const k of Object.keys(shared.mats)) roomLightMask(shared.mats[k]);
+      const mats = shared.mats;
+      for (const k of Object.keys(mats)) roomLightMask(mats[k]);
       const budget = o.budget, lease = budget ? budget.lease({ owner: "floorplan.rooms", point: N, shadows: NS }) : null;
       if (budget && !lease) throw new Error("lighting: the LightBudget has no " + N + " free point slots (" + NS + " with shadow) for the rooms");
       if (budget) for (const [key, width] of [["uRB0", 4], ["uRB1", 4], ["uRB2", 4], ["uRBY", 2], ["uREx", 4]]) {
@@ -10842,9 +11007,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         for (let i = 0; i < NS; i++) PL[i].shadow.needsUpdate = true;
       };
-      A.update = function(houses2, focus, op) {
-        op = op || {};
-        houses2 = (Array.isArray(houses2) ? houses2 : [houses2]).filter(Boolean);
+      A.update = function(houseOrList, focus, options2) {
+        const op = options2 || {}, houses2 = (Array.isArray(houseOrList) ? houseOrList : [houseOrList]).filter((h) => !!h);
         _f.set(focus.x, focus.y, focus.z);
         const rooms = [], exterior = [];
         for (const house of houses2) {
@@ -10856,7 +11020,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             if (!house.lightOn(l.roomId)) continue;
             const k = l.type === "outdoor" ? "ext:" + (l.id || exterior.length) : l.roomId != null ? l.roomId : l.room;
             let g = by.get(k);
-            if (!g) by.set(k, g = { k, house, ls: [], exterior: l.type === "outdoor" });
+            if (!g) by.set(k, g = newGroup(k, house, l.type === "outdoor"));
             g.ls.push(l);
           }
           for (const g of by.values()) {
@@ -10891,9 +11055,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
                 }
               }
               g.exclusion = [x0 + 0.03, z0 + 0.03, x1 - 0.03, z1 - 0.03];
-              g.lumens = ls[0].lumens != null ? ls[0].lumens : 3.2;
-              g.dist = ls[0].dist != null ? ls[0].dist : 5.5;
-              g.decay = ls[0].decay != null ? ls[0].decay : 2;
+              const l0 = ls[0];
+              g.lumens = l0.lumens != null ? l0.lumens : 3.2;
+              g.dist = l0.dist != null ? l0.dist : 5.5;
+              g.decay = l0.decay != null ? l0.decay : 2;
             } else {
               const c = house.r.rooms.find((q) => q.id === g.k);
               if (!c) continue;
@@ -10994,8 +11159,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     const effectsByBudget = /* @__PURE__ */ new WeakMap();
     const OPENING_REACH = 2.5, OPENING_SIDE = 0.6;
-    function effectLights(o) {
-      o = o || {};
+    function effectLights(options) {
+      const o = options || {};
       const budget = o.budget;
       if (!budget) throw new Error("effectLights: a LightBudget is required");
       const known = effectsByBudget.get(budget);
@@ -11073,7 +11238,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       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();
+          const indoors = cfg.effectLightsIndoors !== false, list2 = (Array.isArray(houses2) ? houses2 : [houses2]).filter((h) => !!h), cache2 = /* @__PURE__ */ new Map();
           for (let at2 = 0; at2 < size; at2++) {
             if (ours.has(at2)) continue;
             const light = budget.group.children[at2];
@@ -11101,7 +11266,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (!o.ours) effectsByBudget.set(budget, A);
       return A;
     }
-    Object.assign(K, { MAX_LIGHTS, EMPTY, LZU, roomLightMask, lighting, effectLights });
+    const defined = { MAX_LIGHTS, EMPTY, LZU, roomLightMask, lighting, effectLights };
+    Object.assign(K, defined);
   }
 
   // ../game-destruction/dist/index.js
@@ -11433,6 +11599,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 = (box3, count, axis, rnd) => {
+    const shares = Array.from({ length: count }, () => 0.25 + 1.5 * rnd());
+    const total = shares.reduce((sum, share) => sum + share, 0);
+    const out = [];
+    let from = box3.c[axis] - box3.s[axis] / 2;
+    for (const share of shares) {
+      const length = box3.s[axis] * share / total;
+      const c = [box3.c[0], box3.c[1], box3.c[2]];
+      const size = [box3.s[0], box3.s[1], box3.s[2]];
+      c[axis] = from + length / 2;
+      size[axis] = length;
+      out.push({ c, s: size });
+      from += length;
+    }
+    return out;
+  };
   var splinterBox = (inp, box3, limit = inp.maxFragments) => {
     const { rnd } = inp;
     const dims = box3.s;
@@ -11442,35 +11624,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(box3, c, [a, b], rnd);
+    const cells = [];
+    for (const cell of bsp(box3, c, [a, b], rnd)) {
+      const wide = cell.s[a] >= cell.s[b] ? a : b;
+      if (rnd() < 0.4 && cell.s[wide] > fmin * 0.5) for (const part of splitAlong(cell, 2, wide, rnd)) cells.push(part);
+      else cells.push(cell);
+    }
     const pieces = [];
     for (const cell of cells) {
-      const extra = rnd() < 0.4 ? 1 : 0;
+      const extra = Math.floor(rnd() * 3);
       const k = Math.max(1, Math.ceil(dims[g] / maxLen)) + extra;
-      for (const p of bsp(cell, k, [g], rnd)) pieces.push(p);
+      for (const p of splitAlong(cell, k, g, rnd)) 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 } = 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 across = 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 layer = { c: [root.c[0], root.c[1], root.c[2]], s: [dims[0], dims[1], dims[2]] };
+      layer.c[t] = root.c[t] + (-dims[t] / 2 + (k + 0.5) * pitch) * (pitch > PLY_SHEET ? 1 : 1 + PLY_GAP);
+      layer.s[t] = th;
+      for (const cell of bsp(layer, per, [u, v], rnd)) {
+        if (out.length >= limit) return out;
+        if (rnd() < 0.35) {
+          const strand = cell.s[across] * (0.15 + 0.2 * rnd());
+          out.push({ center: cell.c, size: [cell.s[along], strand, th * 0.7], q: frame(along, across, 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, (rnd() - 0.5) * 0.5), shape: "scrap", weight: cell.s[u] * cell.s[v] * th });
+        }
+      }
+    }
+    return out;
+  };
+  var granules = (inp, box3, count) => bsp(box3, 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, 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(at2 - gap / 2, -half, half), hi = clamp(at2 + 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;
   };
@@ -11503,8 +11731,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(rnd() * 3));
       for (const b of bsp(root, n2, [0, 1, 2], rnd)) out.push({ center: b.c, size: b.s, q: idq, shape: "slab", weight: b.s[0] * b.s[1] * b.s[2] });
+      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") {
@@ -11611,6 +11849,88 @@ 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 key = rowOf(cell.center[v] - cell.size[v] / 2);
+      const row = rows.get(key);
+      if (row) row.push(i);
+      else rows.set(key, [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 key = `${Math.floor((cell.center[u] - lo0) / side)}:${Math.floor((cell.center[v] - lo1) / side)}`;
+        const bin = bins.get(key) ?? { 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(key, 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 });
@@ -12590,6 +12910,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "wood_soft",
+      splitForm: "slivers",
       density: 500,
       hpPerKg: 90,
       penetration: 9,
@@ -12635,6 +12956,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "wood_hard",
+      splitForm: "slivers",
       density: 750,
       hpPerKg: 140,
       penetration: 14,
@@ -12679,6 +13001,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "plywood",
+      splitForm: "plies",
       density: 600,
       hpPerKg: 70,
       penetration: 7,
@@ -12726,6 +13049,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "mdf",
+      splitForm: "granules",
       density: 750,
       hpPerKg: 45,
       penetration: 6,
@@ -12892,6 +13216,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           floor: 60
         }
       },
+      ricochetDeg: 12,
       hitDebris: "chips",
       breakDebris: "dust",
       visual: { innerColor: 10197652 },
@@ -12923,6 +13248,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         0.04,
         0.12
       ],
+      ricochetDeg: 10,
       hitDebris: "chips",
       breakDebris: "dust",
       visual: { innerColor: 12085567 },
@@ -12980,6 +13306,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         0.06,
         0.3
       ],
+      ricochetDeg: 15,
       hitDebris: "chips",
       breakDebris: "dust",
       visual: { innerColor: 9407364 },
@@ -13237,6 +13564,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "green_wood",
+      splitForm: "slivers",
       density: 650,
       hpPerKg: 5,
       penetration: 10,
@@ -13407,6 +13735,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         0.03,
         0.15
       ],
+      ricochetDeg: 8,
       hitDebris: "chips",
       breakDebris: "dust",
       thermal: {
@@ -13506,6 +13835,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         0.02,
         0.08
       ],
+      ricochetDeg: 8,
       hitDebris: "chips",
       breakDebris: "dust",
       thermal: {
@@ -13517,6 +13847,127 @@ 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
+      ],
+      ricochetDeg: 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
+      ],
+      ricochetDeg: 12,
+      hitDebris: "chips",
+      breakDebris: "chips",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 35e4
     }
   ];
   var material_hints_default = {
@@ -13729,6 +14180,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;
@@ -14981,7 +15437,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;
@@ -15109,6 +15565,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];
@@ -15167,6 +15624,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         emit({ ...base(o, src), type: "chip", part: p.spec.id, center, size: [cell.size[0], cell.size[1], cell.size[2]], rotation: q, fragments });
         debris(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)) {
@@ -15270,10 +15728,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);
       debris(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, dist, src) => {
+      var _a, _b;
+      if (!p.staged || p.st.stripped || isLost(p) || chipEnergy <= 0) return false;
+      const reach = blastReachOf(p, energy);
+      if (dist >= reach) return false;
+      const radius = Math.sqrt(reach * reach - dist * dist);
+      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 = [rnd() * 2 * Math.PI, rnd() * 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 * (rnd() - 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((sum, cell) => sum + 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]] }));
+      emit({ ...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 });
+      debris(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((sum, cell) => sum + 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]] }));
+      emit({ ...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 });
+      debris(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;
@@ -15340,6 +15910,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const unitPlan = p.spec.units ? unitFragmentPlan(p, maxFragments * UNIT_FRAGMENT_FACTOR) : [];
       const axis = style === "splinter" || style === "snap" ? severAxis(p) : -1;
       const cutAt2 = axis < 0 ? void 0 : p.rt.cutAt ?? (origin ? hitLocal[axis] : void 0);
+      const planRnd = p.mat.splitForm ? splitStream(o.id, p.spec.id, hitLocal) : rnd;
       const plan = unitPlan.length > 0 ? unitPlan : planFragments({
         style,
         dims: p.dims,
@@ -15348,8 +15919,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         hit: hitLocal,
         fragmentSize: p.mat.fragmentSize ?? [0.04, 0.2],
         maxFragments,
-        rnd,
+        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) : [];
@@ -15488,7 +16060,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 * rnd() : 3 + 4 * rnd()), w = scale * (0.8 + 0.8 * rnd()), t = scale * (fibre ? 0.7 + 0.6 * rnd() : 0.4 + 0.4 * rnd());
+        const plies = p.mat.splitForm === "plies";
+        const len = scale * (fibre ? 1.2 + 1.2 * rnd() : 3 + 4 * rnd()), w = scale * (0.8 + 0.8 * rnd()), t = scale * (fibre ? 0.7 + 0.6 * rnd() : plies ? 0.15 + 0.15 * rnd() : 0.4 + 0.4 * rnd());
         const size = [w, w, w];
         size[along] = len;
         size[(along + 1) % 3] = w;
@@ -15649,7 +16222,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 && dist > 0 && mat.tags?.includes("glass")) {
         frontQueue.push({ o, p, due: time + dist / blastFrontSpeed, amount, fragEnergy: Ein * 0.3, point, ...src !== void 0 ? { src } : {} });
@@ -15659,7 +16232,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 (dist <= 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, dist, src);
+      else if (p.spec.reinforcement && p.spec.units && dist > MEMBER_CUT_REACH * breachReach) blastUnits(o, p, wp, energy, dist, src);
+      else if (dist <= breachReach) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
       return reach;
     };
     const blastProbe = { partsTested: 0, partsNear: 0 };
@@ -15905,6 +16481,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 = createRng(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]);
@@ -17118,8 +17699,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
 
   // ../game-floorplan-structure/dist/index.js
   var __defProp2 = Object.defineProperty;
-  var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
   var uniform = (joint) => ({ wall: joint, slab: joint, beam: joint, column: joint, truss: joint });
   var CONSTRUCTION_SYSTEMS = /* @__PURE__ */ new Map([
     ["masonry", { walls: "brick_wall_plastered", joints: { wall: "mortar", slab: "rebar", beam: "mortar", column: "rebar", truss: "bolt" }, slabThickness: 0.12, plateThickness: 0.2, timber: false, wallRole: "rules", wallFill: 1 }],
@@ -17253,9 +17834,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var densityOf = (material) => DENSITY[material] ?? DEFAULT_DENSITY;
   var StructureBuilder = class {
     constructor() {
-      __publicField(this, "parts", []);
-      __publicField(this, "supports", []);
-      __publicField(this, "ids", /* @__PURE__ */ new Set());
+      __publicField2(this, "parts", []);
+      __publicField2(this, "supports", []);
+      __publicField2(this, "ids", /* @__PURE__ */ new Set());
     }
     add(draft, options = {}) {
       const { id, role, material, aabb, y0, y1 } = draft;
@@ -17321,12 +17902,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       builder,
       porchRoofOnPostsOnly: options.porchRoofOnPostsOnly,
       rafterRoof: options.rafterRoof,
+      wallPillarSpacing: options.wallPillarSpacing,
+      visorSections: options.visorSections,
       floorCount: floorCount2,
       isUnit,
       elevation,
       isTimber: system.timber,
       walls: [],
       wallParts: /* @__PURE__ */ new Map(),
+      groundBeams: /* @__PURE__ */ new Map(),
       carriers: /* @__PURE__ */ new Map(),
       plates: /* @__PURE__ */ new Map(),
       pillars: /* @__PURE__ */ new Map(),
@@ -17397,7 +17981,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         builder.rest(deck, base, system.joints.slab);
         continue;
       }
-      const pillar = builder.add({ id: `balcony_column_${room.id}`, role: "column", material: construction.frame.pillars, aabb: [box22[0] - 0.08, box22[1] - 0.08, box22[0] + 0.08, box22[1] + 0.08], y0: 0, y1: context.level(floor) - system.slabThickness }, { floor: 0 });
+      const half = context.visorSections ? 0.08 : 0.1;
+      const pillar = builder.add({ id: `balcony_column_${room.id}`, role: "column", material: construction.frame.pillars, aabb: [box22[0] - half, box22[1] - half, box22[0] + half, box22[1] + half], y0: 0, y1: context.level(floor) - system.slabThickness }, { floor: 0 });
       builder.rest(pillar, GROUND, "rebar");
       builder.rest(deck, pillar, "rebar");
     }
@@ -17462,8 +18047,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const top = context.level(floor) - thickness * 0.15;
     const out = [];
     for (let k = 0; k < count; k++) {
-      const centre = (alongU ? box22[0] : box22[1]) + 0.05 + k * (span - 0.1) / (count - 1);
-      const aabb = alongU ? [centre - 0.025, box22[1], centre + 0.025, box22[3]] : [box22[0], centre - 0.025, box22[2], centre + 0.025];
+      const centre2 = (alongU ? box22[0] : box22[1]) + 0.05 + k * (span - 0.1) / (count - 1);
+      const aabb = alongU ? [centre2 - 0.025, box22[1], centre2 + 0.025, box22[3]] : [box22[0], centre2 - 0.025, box22[2], centre2 + 0.025];
       const joist = context.builder.add({ id: `joist_${floor}${suffix}_${k}`, role: "beam", material, aabb, y0: context.level(floor) - thickness, y1: top }, { floor, fill: 1, spacing: JOIST_PITCH });
       out.push(joist);
       const below = carriers.filter((carrier) => carrier.y0 <= top + 0.05);
@@ -17551,8 +18136,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const at2 = alongU ? box22[1] + line * (box22[3] - box22[1]) / (rows - 1) : box22[0] + line * (box22[2] - box22[0]) / (columns - 1);
       const aabb = alongU ? [box22[0], at2 - 0.07, box22[2], at2 + 0.07] : [at2 - 0.07, box22[1], at2 + 0.07, box22[3]];
       const beam = builder.add({ id: `base_beam_${line}`, role: "beam", material: construction.frame.timber, aabb, y0: height, y1: elevation - context.system.slabThickness }, { floor: 0 });
-      const centre = (q) => alongU ? (q.aabb[1] + q.aabb[3]) / 2 : (q.aabb[0] + q.aabb[2]) / 2;
-      for (const pier of piers.filter((q) => Math.abs(centre(q) - at2) < 0.05)) builder.rest(beam, pier, "bolt");
+      const centre2 = (q) => alongU ? (q.aabb[1] + q.aabb[3]) / 2 : (q.aabb[0] + q.aabb[2]) / 2;
+      for (const pier of piers.filter((q) => Math.abs(centre2(q) - at2) < 0.05)) builder.rest(beam, pier, "bolt");
       beams.push(beam);
     }
     return beams;
@@ -17572,17 +18157,110 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     else if (type === "crawl_space" || type === "piles" || type === "basement") addRaisedFloor(context);
     else if (context.isTimber && type !== "ground") context.base0 = raft(context, Math.max(0.12, context.elevation), "concrete");
   }
+  var GROUND_BEAM_DEPTH = 0.3;
+  function addGroundBeams(context) {
+    const { builder, construction } = context;
+    if (construction.system !== "masonry" || context.isUnit || construction.foundation.type !== "strip_footing") return;
+    const top = context.level(0);
+    for (const wall of context.walls) {
+      if (wall.floor !== 0 || wall.type !== "wall") continue;
+      const beam = builder.add({ id: `ground_beam_${context.groundBeams.size}`, role: "beam", material: construction.frame.beams, aabb: wall.box, y0: top - GROUND_BEAM_DEPTH, y1: top }, { floor: 0, beamKind: "ground_beam" });
+      builder.rest(beam, GROUND, "rebar");
+      context.groundBeams.set(wall.id, beam);
+    }
+  }
+  var WALL_PILLAR_SPACING = 4;
+  var WALL_PILLAR_SIDE = 0.2;
+  var MERGE_DISTANCE = 0.45;
+  var HALF = WALL_PILLAR_SIDE / 2;
+  var TOLERANCE = 0.03;
+  var alongRange = (wall) => wall.axis === "u" ? [Math.min(wall.u0, wall.u1), Math.max(wall.u0, wall.u1)] : [Math.min(wall.v0, wall.v1), Math.max(wall.v0, wall.v1)];
+  var acrossOf = (wall) => wall.axis === "u" ? wall.v0 : wall.u0;
+  function stretchesOf(context, wall) {
+    const [low, high] = alongRange(wall);
+    const windows = (context.source.windows ?? []).filter((w) => w.floor === wall.floor && w.axis === wall.axis && Math.abs(w.pos - acrossOf(wall)) <= TOLERANCE && w.at + w.width / 2 > low && w.at - w.width / 2 < high).map((w) => [w.at - w.width / 2, w.at + w.width / 2]).sort((a, b) => a[0] - b[0]);
+    const out = [];
+    let cursor = low;
+    for (const [from, to] of windows) {
+      if (from - cursor > TOLERANCE) out.push({ wall, from: cursor, to: from });
+      cursor = Math.max(cursor, to);
+    }
+    if (high - cursor > TOLERANCE) out.push({ wall, from: cursor, to: high });
+    return out;
+  }
+  function junctionsOf(context, wall) {
+    const [low, high] = alongRange(wall);
+    const line = acrossOf(wall);
+    const out = [];
+    for (const other of context.walls) {
+      if (other === wall || other.floor !== wall.floor || other.axis === wall.axis || other.type !== "wall") continue;
+      const at2 = acrossOf(other);
+      const [a, b] = alongRange(other);
+      const meets = Math.abs(a - line) <= (wall.thickness ?? 0.15) / 2 + TOLERANCE || Math.abs(b - line) <= (wall.thickness ?? 0.15) / 2 + TOLERANCE;
+      if (meets && at2 > low + HALF && at2 < high - HALF) out.push(at2);
+    }
+    return out;
+  }
+  function pillarStations(from, to, junctions, spacing) {
+    const length = to - from;
+    if (length < WALL_PILLAR_SIDE - 1e-6) return [];
+    if (length < 2 * WALL_PILLAR_SIDE) return [(from + to) / 2];
+    if (length < WALL_PILLAR_SIDE + MERGE_DISTANCE) return [from + HALF, to - HALF];
+    const fixed = [from + HALF, ...junctions.filter((at2) => at2 > from + HALF + MERGE_DISTANCE && at2 < to - HALF - MERGE_DISTANCE), to - HALF].sort((a, b) => a - b);
+    const out = [];
+    fixed.forEach((at2, k) => {
+      out.push(at2);
+      const next = fixed[k + 1];
+      if (next === void 0) return;
+      const spans = Math.ceil((next - at2) / spacing - 1e-6);
+      for (let s = 1; s < spans; s++) out.push(at2 + (next - at2) * s / spans);
+    });
+    return out;
+  }
+  function addWallPillars(context, walls, floor, plates, taken, spacing) {
+    const { builder } = context;
+    const pillars = [];
+    const placed = taken.map((p) => [(p.aabb[0] + p.aabb[2]) / 2, (p.aabb[1] + p.aabb[3]) / 2]);
+    const base = context.baseOf(floor);
+    for (const wall of walls) {
+      if (!wall.exterior || wall.type !== "wall") continue;
+      const top = context.wallParts.get(wall.id).y1;
+      const across = acrossOf(wall);
+      const junctions = junctionsOf(context, wall);
+      for (const stretch of stretchesOf(context, wall)) {
+        const standing = (end) => placed.map(([pu, pv]) => wall.axis === "u" ? [pu, pv] : [pv, pu]).find(([a, c]) => Math.abs(c - across) <= TOLERANCE && Math.abs(a - end) < MERGE_DISTANCE + HALF)?.[0];
+        const first = standing(stretch.from);
+        const last = standing(stretch.to);
+        const from = first === void 0 ? stretch.from : Math.min(stretch.from, first - HALF);
+        const to = last === void 0 ? stretch.to : Math.max(stretch.to, last + HALF);
+        for (const along of pillarStations(from, to, junctions, spacing)) {
+          const [u, v] = wall.axis === "u" ? [along, across] : [across, along];
+          const end = Math.abs(along - stretch.from) < Math.abs(along - stretch.to) ? stretch.from : stretch.to;
+          const endPoint = wall.axis === "u" ? [end, across] : [across, end];
+          const isEnd = Math.abs(along - end) <= HALF + TOLERANCE;
+          if (placed.some(([pu, pv]) => Math.hypot(pu - u, pv - v) < MERGE_DISTANCE && (!isEnd || Math.hypot(pu - endPoint[0], pv - endPoint[1]) < MERGE_DISTANCE))) continue;
+          placed.push([u, v]);
+          const box22 = [u - HALF, v - HALF, u + HALF, v + HALF];
+          const pillar = builder.add({ id: `wall_column_${floor}_${pillars.length}`, role: "column", material: context.construction.frame.pillars, aabb: box22, y0: context.level(floor), y1: top }, { floor });
+          builder.rest(pillar, base === GROUND || !base ? GROUND : base, "rebar");
+          for (const plate of plates.filter((p) => touches(p.aabb, box22, 0.01))) builder.rest(plate, pillar, "rebar");
+          pillars.push(pillar);
+        }
+      }
+    }
+    return pillars;
+  }
   var MAX_GAP_WITHIN_RUN = 3.2;
   var POST_SPACING = 2.4;
   var POST_SIDE = 0.05;
   var alongOf = (wall, pick2) => wall.axis === "u" ? pick2(wall.u0, wall.u1) : pick2(wall.v0, wall.v1);
-  var acrossOf = (wall) => wall.axis === "u" ? wall.v0 : wall.u0;
+  var acrossOf2 = (wall) => wall.axis === "u" ? wall.v0 : wall.u0;
   function runsOf(context, walls, floor) {
     const lines = /* @__PURE__ */ new Map();
     for (const wall of walls) {
       if (!wall.exterior || wall.type !== "wall") continue;
       const top = round2(context.wallParts.get(wall.id).y1);
-      const key = `${floor}|${wall.axis}|${acrossOf(wall).toFixed(2)}|${top.toFixed(2)}`;
+      const key = `${floor}|${wall.axis}|${acrossOf2(wall).toFixed(2)}|${top.toFixed(2)}`;
       lines.set(key, [...lines.get(key) ?? [], wall]);
     }
     return [...lines.values()].map((line) => {
@@ -17602,7 +18280,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   function addShackPosts(context, run, plate, floor, index) {
     const first = run.walls[0];
-    const across = acrossOf(first);
+    const across = acrossOf2(first);
     const top = context.wallParts.get(first.id).y1;
     const count = Math.max(1, Math.ceil((run.to - run.from) / POST_SPACING));
     const posts = [];
@@ -17628,7 +18306,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       for (const run of runs) {
         const first = run.walls[0];
         const half = (first.thickness ?? 0.15) / 2;
-        const across = acrossOf(first);
+        const across = acrossOf2(first);
         const top = context.wallParts.get(first.id).y1;
         const aabb = first.axis === "u" ? [run.from - half, across - half, run.to + half, across + half] : [across - half, run.from - half, across + half, run.to + half];
         const material = context.isTimber ? construction.frame.timber : construction.frame.beams;
@@ -17667,7 +18345,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   function addPlatesAndPillars(context, floor) {
     const walls = context.walls.filter((wall) => wall.floor === floor);
     const { plates, pillars } = addPlates(context, walls, floor);
-    if (context.construction.system === "masonry") pillars.push(...addCornerPillars(context, walls, floor, plates));
+    if (context.construction.system === "masonry") {
+      const corners = addCornerPillars(context, walls, floor, plates);
+      pillars.push(...corners);
+      if (context.wallPillarSpacing) pillars.push(...addWallPillars(context, walls, floor, plates, corners, context.wallPillarSpacing));
+    }
     context.pillars.set(floor, pillars);
     context.plates.set(floor, plates);
     const innerBearing = walls.filter((wall) => wall.role === "wall" && !wall.exterior).map((wall) => context.wallParts.get(wall.id));
@@ -17942,21 +18624,21 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     builder.rest(flight, builder.find("basement_slab"), "resting");
     if (context.base0 && context.base0 !== GROUND) builder.rest(flight, context.base0, "nail");
   }
-  var TOLERANCE = 0.02;
+  var TOLERANCE2 = 0.02;
   var DOOR_HEIGHT = 2.1;
   var LINTEL_DEPTH = 0.2;
   var LINTEL_BEARING = 0.2;
   var crossOf = (wall) => wall.axis === "u" ? wall.v0 : wall.u0;
-  var alongRange = (wall) => wall.axis === "u" ? [Math.min(wall.u0, wall.u1), Math.max(wall.u0, wall.u1)] : [Math.min(wall.v0, wall.v1), Math.max(wall.v0, wall.v1)];
+  var alongRange2 = (wall) => wall.axis === "u" ? [Math.min(wall.u0, wall.u1), Math.max(wall.u0, wall.u1)] : [Math.min(wall.v0, wall.v1), Math.max(wall.v0, wall.v1)];
   function findOpenings(context) {
     const openings = [];
     for (const window of context.source.windows ?? []) {
       const from = window.at - window.width / 2;
       const to = window.at + window.width / 2;
       const wall = context.walls.find((w) => {
-        if (w.floor !== window.floor || w.axis !== window.axis || w.type !== "wall" || Math.abs(crossOf(w) - window.pos) > TOLERANCE) return false;
-        const [low, high] = alongRange(w);
-        return from >= low - TOLERANCE && to <= high + TOLERANCE;
+        if (w.floor !== window.floor || w.axis !== window.axis || w.type !== "wall" || Math.abs(crossOf(w) - window.pos) > TOLERANCE2) return false;
+        const [low, high] = alongRange2(w);
+        return from >= low - TOLERANCE2 && to <= high + TOLERANCE2;
       });
       if (!wall) continue;
       const base = context.level(window.floor);
@@ -17971,18 +18653,39 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const cross = door.axis === "u" ? door.v : door.u;
       const from = along - door.width / 2;
       const to = along + door.width / 2;
-      const beside = context.walls.filter((w) => w.floor === door.floor && w.axis === door.axis && w.type === "wall" && Math.abs(crossOf(w) - cross) <= TOLERANCE && (Math.abs(alongRange(w)[1] - from) <= 0.05 || Math.abs(alongRange(w)[0] - to) <= 0.05));
+      const beside = context.walls.filter((w) => w.floor === door.floor && w.axis === door.axis && w.type === "wall" && Math.abs(crossOf(w) - cross) <= TOLERANCE2 && (Math.abs(alongRange2(w)[1] - from) <= 0.05 || Math.abs(alongRange2(w)[0] - to) <= 0.05));
       if (!beside.length) continue;
       const half = (beside[0].thickness ?? 0.15) / 2;
       const lo = from - LINTEL_BEARING;
       const hi = to + LINTEL_BEARING;
       const box22 = door.axis === "u" ? [lo, cross - half, hi, cross + half] : [cross - half, lo, cross + half, hi];
       const y0 = context.level(door.floor) + DOOR_HEIGHT;
-      const lintel = builder.add({ id: `lintel_${door.id}`, role: "beam", material: system.timber ? construction.frame.timber : "concrete", aabb: box22, y0, y1: y0 + LINTEL_DEPTH }, { floor: door.floor, ...system.timber ? {} : { assembly: "reinforced_concrete" } });
+      const depth = Math.max(LINTEL_DEPTH, (door.width + LINTEL_BEARING) / 10);
+      const lintel = builder.add({ id: `lintel_${door.id}`, role: "beam", material: system.timber ? construction.frame.timber : "concrete", aabb: box22, y0, y1: y0 + depth }, { floor: door.floor, ...system.timber ? {} : { assembly: "reinforced_concrete" } });
       for (const wall of beside) builder.rest(lintel, context.wallParts.get(wall.id), system.joints.beam);
+      const jambs = (context.pillars.get(door.floor) ?? []).filter((pillar) => pillar.material === "concrete" && overlapsInPlan(pillar.aabb, box22) && pillar.y1 >= y0);
+      if (construction.system === "masonry" && hi - lo > WIDE_DOOR) jambs.push(...addJambPillars(context, { door, beside, from, to, cross }, jambs));
+      for (const pillar of jambs) builder.rest(lintel, pillar, "rebar");
       for (const plate of context.plates.get(door.floor) ?? []) if (overlapsInPlan(plate.aabb, box22)) builder.rest(plate, lintel, system.joints.beam);
     }
   }
+  var WIDE_DOOR = 3;
+  var HALF_PILLAR = WALL_PILLAR_SIDE / 2;
+  function addJambPillars(context, gap, standing) {
+    const { builder, construction } = context;
+    const top = Math.max(...gap.beside.map((w) => context.wallParts.get(w.id).y1));
+    const base = context.baseOf(gap.door.floor);
+    const out = [];
+    for (const [k, along] of [[0, gap.from - HALF_PILLAR], [1, gap.to + HALF_PILLAR]]) {
+      const [u, v] = gap.door.axis === "u" ? [along, gap.cross] : [gap.cross, along];
+      const box22 = [u - HALF_PILLAR, v - HALF_PILLAR, u + HALF_PILLAR, v + HALF_PILLAR];
+      if (standing.some((p) => overlapsInPlan(p.aabb, box22))) continue;
+      const pillar = builder.add({ id: `jamb_column_${gap.door.id}_${k}`, role: "column", material: construction.frame.pillars, aabb: box22, y0: context.level(gap.door.floor), y1: top }, { floor: gap.door.floor });
+      builder.rest(pillar, base === GROUND || !base ? GROUND : base, "rebar");
+      out.push(pillar);
+    }
+    return out;
+  }
   var overlapsInPlan = (a, b) => a[0] < b[2] && a[2] > b[0] && a[1] < b[3] && a[3] > b[1];
   var RISER = 0.18;
   var TREAD = 0.28;
@@ -18154,10 +18857,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const framed = system.studs !== void 0 && !isRailing;
     const part = builder.add(
       { id: wall.id, role: wall.role, material: wall.material, aabb: wall.box, y0, y1: Math.max(y1, y0 + 0.2) },
-      { floor, fill: context.isTimber && wall.role === "wall" ? system.wallFill : 1, ...framed ? { studs: system.studs } : {}, ...isRailing ? {} : { assembly: assemblyOf(context) } }
+      { floor, fill: context.isTimber && wall.role === "wall" ? system.wallFill : 1, ...framed ? { studs: system.studs } : {}, ...isRailing ? {} : { assembly: assemblyOf(context) }, ...wall.exterior && !isRailing ? { exterior: true } : {} }
     );
     context.wallParts.set(wall.id, part);
-    const base = isRailing ? railingBase(context, wall, floor) : context.baseOf(floor);
+    const base = isRailing ? railingBase(context, wall, floor) : context.groundBeams.get(wall.id) ?? context.baseOf(floor);
     const joint = isRailing ? "nail" : system.joints.wall;
     if (base === GROUND || floor === 0 && !base) builder.rest(part, GROUND, joint);
     else if (base) builder.rest(part, base, joint);
@@ -18173,6 +18876,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       addUpperFloor(context, floor);
     }
   }
+  var wallPillarSpacingOf = (options) => {
+    const pillars = options.wallPillars ?? true;
+    if (pillars === false) return 0;
+    return pillars === true ? WALL_PILLAR_SPACING : pillars.spacing ?? WALL_PILLAR_SPACING;
+  };
   function buildStructure(source, options = {}) {
     const refined = options.wallDetail !== "coarse";
     const built = options.construction ? { construction: options.construction, extras: options.extras ?? {} } : resolveConstruction(source);
@@ -18180,8 +18888,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const extras = options.extras ?? built.extras ?? {};
     if (construction.system === "canvas") return buildCanvasStructure(construction, extras);
     const tank = options.tank !== void 0 ? options.tank : source.waterTank ?? null;
-    const context = createContext(source, construction, extras, tank, { porchRoofOnPostsOnly: options.porchRoofOnPostsOnly ?? refined, rafterRoof: options.rafterRoof ?? refined });
+    const context = createContext(source, construction, extras, tank, { porchRoofOnPostsOnly: options.porchRoofOnPostsOnly ?? refined, rafterRoof: options.rafterRoof ?? refined, wallPillarSpacing: wallPillarSpacingOf(options), visorSections: options.visorSections === true });
     addFoundation(context);
+    if (options.groundBeams !== false) addGroundBeams(context);
     buildFloors(context);
     addBalconies(context);
     addPorchRoofs(context);
@@ -18930,6 +19639,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];
@@ -18943,6 +19654,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;
@@ -18953,23 +19665,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((sum, d) => sum + d.volume, 0);
     const pieces = all.map((d) => ({
       id: d.id,
@@ -18984,6 +19699,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];
@@ -19013,7 +19733,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);
     }
@@ -19021,7 +19742,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();
@@ -19083,21 +19815,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, rebar) => {
     if (!rebar || 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: rebar, spacing: MEMBER_CAGE.spacing, diameter: MEMBER_CAGE.diameter };
     return {
       ...spec,
-      reinforcement: { material: rebar, 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, rebar) => {
     if (detailed && part.assembly) return assemblySpec(part, capacity);
     const spec = boxSpec(part, capacity);
-    return detailed ? caged(spec, part, rebar) : spec;
+    const out = detailed ? caged(spec, part, rebar) : 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;
@@ -19113,7 +19859,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;
@@ -19178,6 +19926,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];
@@ -19336,7 +20085,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, fixed, length, c1, c2) => {
+      const bay = (side, k, along, centre2, fixed, length, c1, c2) => {
         const clear = length - g.columnSize;
         const win = clear * c.window;
         const pier = (clear - win) / 2;
@@ -19347,11 +20096,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 = at2(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 = at2(centre2);
         const gid = `glass_${f}_${side}_${k}`;
         parts.push({
           id: gid,
@@ -19995,7 +20744,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" } };
               }
@@ -20023,6 +20773,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const a = pos.array;
     const u = mesh2.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);
@@ -20106,10 +20857,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;
@@ -20120,7 +20872,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;
@@ -20134,8 +20886,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();
@@ -20224,6 +20989,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) {
@@ -20246,9 +21022,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, chips = 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 });
@@ -20344,52 +21126,55 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         return { center: local(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: local(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: local(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 {
@@ -20500,14 +21285,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 rotation = 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 })) });
+          return draw2(event.part, { chip: { center: event.center, size: event.size ?? [0, 0, 0], rotation } });
         },
         /** 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);
+            paint(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. */
@@ -20948,8 +21751,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   // src/build/build.ts
   function installBuildBuild(K, shared) {
     const { THREE, cfg, rectsOf: rectsOf2, invalidateShadow, colliderChanged, VERSION: VERSION2, CARS, EPS: EPS3, LIGHTS, MIRRORS, Y0, animateClotheslines, animateDoors, animateInteractive, applyLeaf, applyOutbuildings, applyPart, applyPiece, assembleInteractive, baseboardAndSidewalk, buildStairs, building, carModel, chooseMirror, closeScene, collideAt, createWater, cursor, doorText, doors, electricalStructure, elevator, floorsAndSlabs, gatesInteractive, houseItems, ivAssemble, ivBuild, ivDispose, ivParts, ivPublish, ivUpdate, lightOn, linkDoorLeaves, mailboxInteractive, newInteractiveState, newMirrorState, outbuildings, paths, perimeter, placeSwitches, roofs, roomAt, solar, targetOf, terrain, toggleDoor, toggleLight, walls, waterPipes, windows, props, TYPES, IVK, VEG, vegMaterials, markGroups, assembleStructure, createHouseDestruction, newState, enter, tagDamage } = K;
-    function build(r0, opts) {
-      opts = opts || {};
+    function build(r0, options) {
+      const opts = options || {};
       const r = applyOutbuildings(r0);
       const t0 = performance.now();
       const h = { ctx: { mv: props, types: TYPES }, inter: newInteractiveState(), state: opts.state || newState(), mirrors: newMirrorState(), quality: opts.quality === "game" || opts.quality === "high" ? opts.quality : cfg.quality === "game" ? "game" : "high", lodCurrent: 0, lodMin: 0 };
@@ -20970,7 +21773,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       shared.ctx.pieces = /* @__PURE__ */ new Map();
       shared.ctx.pieceObjects = /* @__PURE__ */ new Map();
       shared.ctx.structureIndex = {};
-      for (const e of r0.structure && r0.structure.parts || []) shared.ctx.structureIndex[e.id] = e;
+      for (const e of r0.structure?.parts || []) shared.ctx.structureIndex[e.id] = e;
       {
         const view = shared.ctx.panelView = panelViewOf(r0.structure, !!cfg.destruction);
         shared.ctx.panelsOf = /* @__PURE__ */ new Map();
@@ -20982,17 +21785,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           else shared.ctx.panelsOf.set(e.slab, [e]);
         }
       }
-      shared.ctx.panes = r0.roof && r0.roof.panes || [];
+      shared.ctx.panes = r0.roof?.panes || [];
       shared.ctx.noPiece = false;
       cursor.separate = opts.pieces === "meshes";
       cursor.pc = null;
+      shared.ctx.showPillars = opts.pillars !== "hidden";
       shared.ctx.apartment = r.template === "apartment_modern";
       shared.ctx.pa = Math.max(3, Math.min(20, pr.floors != null ? pr.floors : 5));
       shared.ctx.pf = Math.max(1, Math.min(shared.ctx.pa, pr.floor != null ? pr.floor : 3));
       shared.ctx.pu = Math.max(0, pr.unit != null ? pr.unit : 0);
       shared.ctx.showBuilding = shared.ctx.apartment && (pr.showIt == null ? true : !!pr.showIt);
       shared.ctx.limits = { x0: -2, z0: -2, x1: r.w + 2, z1: r.d + 2 };
-      shared.ctx.veg = VEG ? { G: VEG.G, S: VEG.S, mats: vegMaterials, groups: /* @__PURE__ */ new Map(), ok: /* @__PURE__ */ new Map(), opts: shared.quality === "game" ? { quality: "game" } : { lod: 0, triangleBudget: 6e4 } } : null;
+      shared.ctx.veg = VEG ? { G: VEG.G, S: VEG.S, mats: vegMaterials, groups: /* @__PURE__ */ new Map(), ok: /* @__PURE__ */ new Map(), opts: shared.quality === "game" ? { quality: "game" } : { quality: "high", lod: 0, triangleBudget: 6e4 } } : null;
       shared.ctx.vegInfo = null;
       terrain();
       if (r.lot) {
@@ -21042,7 +21846,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const g = gs[gd.name];
           if (!g) continue;
           delete gs[gd.name];
-          g.position.set(...gd.pos);
+          g.position.fromArray(gd.pos);
           parent.add(g);
           fo.gs.push(g);
         }
@@ -21057,7 +21861,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       root.add(house);
       shared.mirrors.house = house;
       if (shared.ctx.apartment) {
-        const u = r.building.units[Math.min(shared.ctx.pu, r.building.units.length - 1)];
+        const units = r.building.units, u = units[Math.min(shared.ctx.pu, units.length - 1)];
         house.position.set(u.u, shared.ctx.showBuilding ? 0 : -r.floors[0].y0, u.v);
         house.rotation.y = u.ry;
         shared.ctx.unitRy = u.ry;
@@ -21173,7 +21977,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const wallAt = (f, axis, L) => r.walls.find((w) => w.floor === f && w.axis === axis && Math.abs((axis === "u" ? w.v0 : w.u0) - L) < EPS3);
       for (const j of r.windows) {
         const alongU = j.axis === "u", y0 = Y0(j.floor), a = j.at - j.width / 2, b = j.at + j.width / 2, w = wallAt(j.floor, j.axis, j.pos), th = w ? w.thickness || 0.15 : 0.15, L = j.pos, id = "window:" + j.id;
-        parts[id] = { id, type: "window", group: null, virtual: true, floor: j.floor, aabb: alongU ? [a, y0 + j.y0, L - th / 2, b, y0 + j.y1, L + th / 2] : [L - th / 2, y0 + j.y0, a, L + th / 2, y0 + j.y1, b], damageable: tagDamage("glass"), opens: () => {
+        const jy0 = j.y0, jy1 = j.y1;
+        parts[id] = { id, type: "window", group: null, virtual: true, floor: j.floor, aabb: alongU ? [a, y0 + jy0, L - th / 2, b, y0 + jy1, L + th / 2] : [L - th / 2, y0 + jy0, a, L + th / 2, y0 + jy1, b], damageable: tagDamage("glass"), opens: () => {
         }, t: 0 };
       }
       for (const E of mirrorsCopy) {
@@ -21216,7 +22021,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const countDraw = () => {
         let n = 0, t = 0;
         root.traverseVisible((o) => {
-          if (o.isMesh) {
+          if (isMesh(o)) {
             n++;
             t += (o.geometry.index ? o.geometry.index.count : o.geometry.attributes.position.count) / 3;
           }
@@ -21230,8 +22035,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const budget = opts.drawCallBudget != null ? opts.drawCallBudget : cfg.drawCallBudget;
       const stats2 = { quality: h.quality, drawCalls: s0.n, drawCallsLOD1: s1.n, triangles: s0.t, trianglesLod1: s1.t, budget: budget || null, overBudget: !!budget && s0.n > budget, tBuild: performance.now() - t0 };
       shared.ctx.tBuild = stats2.tBuild;
-      const applyLod = (n) => {
-        n = Math.max(0, Math.min(2, n | 0));
+      const applyLod = (level) => {
+        const n = Math.max(0, Math.min(2, level | 0));
         if (n === h.lodCurrent) return;
         h.lodCurrent = n;
         for (const o of lodObjects) o.visible = n < 1;
@@ -21308,7 +22113,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         lights: (() => {
           const by = {};
           for (const l of shared.ctx.lights) {
-            const k = l.roomId != null ? l.roomId : l.room;
+            const k = String(l.roomId != null ? l.roomId : l.room);
             (by[k] || (by[k] = [])).push(l);
           }
           return { list: shared.ctx.lights, byRoom: by };
@@ -21348,9 +22153,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             applyLod(Math.max(n, h.lodMin));
           }
         },
-        show(o) {
+        show(options2) {
           enter(h);
-          o = o || {};
+          const o = options2 || {};
           const rr = shared.ctx.r, nA = rr.floors.length, a = o.floor == null ? -1 : o.floor, sel = a >= nA ? -1 : a, cut = !!o.cut;
           for (const [k, g] of Object.entries(gs)) {
             let v = true;
@@ -21370,7 +22175,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           enter(h);
           const a = targetOf(o, opt);
           if (!a) return false;
-          return actOn(a.target && a.target.pub ? a.target.pub : { id: a.target && a.target.id || a.text, type: a.target && a.target.kit ? a.target.type : "door", label: a.text, ref: a.target, _action: a.action }, a);
+          return actOn(a.target && a.target.pub ? a.target.pub : { id: a.target && a.target.id || a.text, type: a.target && a.target.kit ? a.target.type : "door", label: a.text, ref: a.target, _action: a.action, floor: 0, pos: [], radius: 0 }, a);
         },
         message() {
           return shared.inter.msg && performance.now() < shared.inter.msg.until ? shared.inter.msg.text : null;
@@ -21427,13 +22232,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           }
           return null;
         },
-        partAt(p, tol) {
-          tol = tol || 0.05;
+        partAt(p, tolerance) {
+          const tol = tolerance || 0.05;
           let m = null;
           for (const k in parts) {
-            const a = parts[k].aabb;
+            const part = parts[k], a = part.aabb;
             if (a && p.x >= a[0] - tol && p.x <= a[3] + tol && p.y >= a[1] - tol && p.y <= a[4] + tol && p.z >= a[2] - tol && p.z <= a[5] + tol) {
-              m = parts[k];
+              m = part;
               break;
             }
           }
@@ -21444,8 +22249,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           destruction.deactivate();
           if (h.IV) ivDispose(h);
           root.traverse((o) => {
-            if (o.isMesh && o.geometry && !o.geometry.userData.shared) o.geometry.dispose();
-            if (o.type === "Reflector" && o.dispose) o.dispose();
+            if (isMesh(o) && o.geometry && !o.geometry.userData.shared) o.geometry.dispose();
+            if (o.type === "Reflector" && "dispose" in o && typeof o.dispose === "function") o.dispose();
           });
           root.removeFromParent();
         },
@@ -21453,7 +22258,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       };
       return res;
     }
-    Object.assign(K, { build });
+    const defined = { build };
+    Object.assign(K, defined);
   }
 
   // src/build/api.ts
@@ -21475,11 +22281,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       lighting,
       effectLights,
       setNight(n) {
-        shared.mats.glass.emissive.set(n ? 9067040 : 0);
-        shared.mats.glass.opacity = n ? 0.4 : 0.24;
+        const glass = shared.mats.glass;
+        glass.emissive.set(n ? 9067040 : 0);
+        glass.opacity = n ? 0.4 : 0.24;
       },
       /** The chipped-plaster painting of every house of this renderer as a `DeferredQueue` for a frame budget (id `floorplan.breach-paint`); asking for it changes nothing. */
       deferredQueue: () => K.breachPaintQueue,
+      /* the destruction side is typed with the breach */
       cars: { model: carModel, group: carGroup, info: (k, seed) => {
         const m = carModel(k, seed);
         return m && { parts: m.parts.length, tris: m.tris, L: m.L, W: m.W, H: m.H };
@@ -22116,7 +22924,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const stopListening = () => {
       for (const off of listening.splice(0)) off?.();
     };
-    const collapsed = (list2) => list2.filter((e) => e.type === "collapse").flatMap((e) => e.parts.map((p) => p.id || p));
+    const collapsed = (list2) => list2.flatMap((e) => e.type === "collapse" ? e.parts.map((p) => p.id || p) : []);
     const whole = (room, oid, pid) => {
       const p = room.world.part(oid, pid);
       return !!p && p.status !== "broken" && !p.stripped;
@@ -22153,10 +22961,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const list2 = events(room);
           const columns = groundColumns(parts);
           const laj = slabs(parts);
-          const first = columns[0];
-          const mate = columns.slice(1).filter((p) => Math.abs(p.position[0] - first.position[0]) < 0.5).sort((a, b) => Math.abs(b.position[2] - first.position[2]) - Math.abs(a.position[2] - first.position[2]))[0] ?? columns[1];
-          blunt(room, oid, first.id, centre(first.id), 3e6);
-          blunt(room, oid, mate.id, centre(mate.id), 3e6);
+          const first = columns.find((p) => !/^wall_column_/.test(p.id)) ?? columns[0];
+          const mate = columns.filter((p) => p !== first && !/^wall_column_/.test(p.id)).filter((p) => Math.abs(p.position[0] - first.position[0]) < 0.5).sort((a, b) => Math.abs(b.position[2] - first.position[2]) - Math.abs(a.position[2] - first.position[2]))[0] ?? columns[1];
+          const along = columns.filter((p) => /^wall_column_/.test(p.id) && Math.abs(p.position[0] - first.position[0]) < 0.5);
+          for (const p of [first, mate, ...along]) blunt(room, oid, p.id, centre(p.id), 3e6);
           step(90);
           const fell = collapsed(list2);
           expect(laj.some((id) => fell.includes(id)), fill(T2.two_slab_fell, { n: fell.length }));
@@ -22476,9 +23284,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return best;
     };
     const eyeOf = (p) => {
+      const T2 = THREE;
       const camera = host?.camera;
       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());
+      const forward = new T2.Vector3(0, 0, -1).applyQuaternion(camera.quaternion).transformDirection(new T2.Matrix4().copy(p.house.group.matrixWorld).invert());
       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) => {
@@ -22494,8 +23303,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const standAt = (p, u, v, floor, lookU, lookV) => {
       if (!host?.bench) return;
       const y = p.house.y0(floor) + EYE;
-      const eye = p.house.group.localToWorld(new THREE.Vector3(u, y, v));
-      const target = p.house.group.localToWorld(new THREE.Vector3(lookU, y - 0.1, lookV));
+      const T2 = THREE;
+      const eye = p.house.group.localToWorld(new T2.Vector3(u, y, v));
+      const target = p.house.group.localToWorld(new T2.Vector3(lookU, y - 0.1, lookV));
       host.bench.look([eye.x, eye.y, eye.z], [target.x, target.y, target.z]);
       floorNow = floor;
     };
@@ -22545,16 +23355,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       host?.log(fill(text.steps.door, { text: String(target.text) }));
     };
     const doorReach = (p, fo) => {
+      const T2 = THREE;
       const g = fo.gs[0];
       const pivot = fo.handles[0].pivot;
       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);
+        const v = new T2.Vector3(pivot[0] * c + pivot[2] * s, pivot[1], -pivot[0] * s + pivot[2] * c).add(g.position);
         return g.parent ? g.parent.localToWorld(v) : v;
       };
       const camera = host?.camera;
-      const eye = new THREE.Vector3(camera.position.x, 0, camera.position.z);
+      const eye = new T2.Vector3(camera.position.x, 0, camera.position.z);
       const flat = (v) => Math.hypot(v.x - eye.x, v.z - eye.z);
       const closed = at2(0);
       const open = at2(fo.rot);
@@ -22562,9 +23373,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return {
         handle: () => {
           g.updateMatrixWorld(true);
-          return g.localToWorld(new THREE.Vector3(pivot[0], pivot[1], pivot[2])).toArray();
+          return g.localToWorld(new T2.Vector3(pivot[0], pivot[1], pivot[2])).toArray();
         },
-        hinge: () => g.getWorldPosition(new THREE.Vector3()).toArray(),
+        hinge: () => g.getWorldPosition(new T2.Vector3()).toArray(),
         seconds: fo.locked || fo.blockedFlag ? 0.6 : 0.55,
         pull: opening ? flat(open) <= flat(closed) : flat(closed) <= flat(open),
         locked: !!(fo.locked || fo.blockedFlag)
@@ -24329,6 +25140,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
 
   // src/wall.ts
+  var WARM_UP_SHOT = { type: "ballistic", point: [0, 1.2, 0.1], direction: [0, 0, -1], energy: 3500, caliber: 7.62 };
+  var WARM_UP_FRAMES = 5;
+  var isTexture = (value) => typeof value === "object" && value !== null && value.isTexture === true;
   var PLASTER = 15262420;
   var WALL_ID = "wall_0_0";
   function wallPlan(options) {
@@ -24359,9 +25173,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       waterTank: null,
       outbuildings: []
     };
-    plan.construction = masonryConstruction({ ...plan, facade: { ...facade, roof: "colonial" } });
-    plan.structure = buildStructure(plan, { wallDetail: "coarse", construction: plan.construction, roof: false });
-    return plan;
+    const construction = masonryConstruction({ ...plan, facade: { ...facade, roof: "colonial" } });
+    const structure = buildStructure({ ...plan, construction }, { wallDetail: "coarse", construction, roof: false });
+    return Object.assign(plan, { construction, structure });
   }
   function draw(THREE, plan, options) {
     return create3(THREE, { ...options, fleet: null }).build(plan, { quality: "game", terrain: false, noPerimeter: true, pieces: "meshes" });
@@ -24371,7 +25185,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     houses.set(house.group, house);
     for (const [id, items] of Object.entries(house.destruction.ranges())) {
       for (const item of items) {
-        const object2 = item.isObject3D ? item : item.mesh;
+        const object2 = "isObject3D" in item ? item : item.mesh;
         object2.userData.destructionPart = id;
       }
     }
@@ -24387,7 +25201,39 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       plan,
       spec,
       build: (T2) => label(draw(T2, plan, houseOptions)),
-      follow: (root, world, objectId) => houses.get(root)?.destruction?.follow?.(world, objectId, spec) ?? null
+      follow: (root, world, objectId) => houses.get(root)?.destruction?.follow?.(world, objectId, spec) ?? null,
+      warmUpProbes: (T2) => {
+        const house = draw(T2, plan, houseOptions);
+        const root = label(house);
+        const world = createDestruction({ seed: 1 });
+        const objectId = world.add(spec, { id: "warm_up_wall" });
+        const destruction = house.destruction;
+        const follower = destruction?.follow?.(world, objectId, spec) ?? null;
+        world.hitPart(objectId, WALL_ID, WARM_UP_SHOT);
+        for (let frame2 = 0; frame2 < WARM_UP_FRAMES; frame2++) {
+          world.update(1 / 60);
+          follower?.update?.();
+        }
+        for (let guard = 0; guard < WARM_UP_FRAMES && (destruction?.breach?.flush?.(Infinity) ?? 0) > 0; guard++) ;
+        root.traverse((node) => {
+          node.visible = true;
+          node.frustumCulled = false;
+        });
+        return {
+          group: root,
+          // the materials stay: the warmup keeps them as anchors, and disposing the last material of a program frees the program it was drawn for (so the
+          // follower is not disposed either: it would put the wall back and dispose the breach's materials; its world goes with the probe)
+          dispose: () => {
+            root.traverse((node) => {
+              node.geometry?.dispose();
+              for (const material of Array.isArray(node.material) ? node.material : node.material ? [node.material] : []) {
+                for (const uniform2 of Object.values(material.uniforms ?? {})) if (isTexture(uniform2.value)) uniform2.value.dispose();
+                material.map?.dispose();
+              }
+            });
+          }
+        };
+      }
     };
   }
   return __toCommonJS(index_exports);