@adatechnology/game-items-three 0.7.2 → 0.7.4

package/dist/index.global.js

@@ -89,7 +89,7 @@ var GameItemsThree = (() => {
     wearableMaterials: () => wearableMaterials
   });
 
-  // ../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));
@@ -1001,17 +1001,19 @@ var GameItemsThree = (() => {
     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) {
@@ -1969,6 +1971,9 @@ var GameItemsThree = (() => {
     }
     return releaseObject3D(list2, { keep });
   }
+  function isMesh(o) {
+    return !!o && o.isMesh === true;
+  }
 
   // src/kit.ts
   var WEAR_TAGS = ["metal", "wood", "cloth", "plastic", "paper", "food", "glass"];
@@ -2731,6 +2736,19 @@ var GameItemsThree = (() => {
         "drink",
         "sticky"
       ]
+    },
+    {
+      id: "mud",
+      color: 4008988,
+      opacity: 0.95,
+      stainColor: 3811866,
+      viscosity: 40,
+      density: 1600,
+      dryTime: 900,
+      gloss: 0.4,
+      tags: [
+        "dirty"
+      ]
     }
   ];
   var LIQUIDS = liquids_default;
@@ -13254,6 +13272,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 = (box4, 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 = box4.c[axis] - box4.s[axis] / 2;
+    for (const share of shares) {
+      const length = box4.s[axis] * share / total;
+      const c = [box4.c[0], box4.c[1], box4.c[2]];
+      const size = [box4.s[0], box4.s[1], box4.s[2]];
+      c[axis] = from + length / 2;
+      size[axis] = length;
+      out.push({ c, s: size });
+      from += length;
+    }
+    return out;
+  };
   var splinterBox = (inp, box4, limit = inp.maxFragments) => {
     const { rnd } = inp;
     const dims = box4.s;
@@ -13263,35 +13297,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(box4, c, [a, b], rnd);
+    const cells = [];
+    for (const cell of bsp(box4, 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 across2 = along === u ? v : u;
+    const layers = clamp(Math.round(dims[t] / PLY / 2), 2, 3);
+    const pitch = dims[t] / layers;
+    const th = Math.min(pitch, PLY_SHEET);
+    const per = Math.max(2, Math.floor(limit / layers));
+    const out = [];
+    for (let k = 0; k < layers; k++) {
+      const 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[across2] * (0.15 + 0.2 * rnd());
+          out.push({ center: cell.c, size: [cell.s[along], strand, th * 0.7], q: frame(along, across2, t), shape: "splinter", weight: cell.s[along] * strand * th });
+        } else {
+          out.push({ center: cell.c, size: [cell.s[u], cell.s[v], th], q: frame(u, v, t, (rnd() - 0.5) * 0.5), shape: "scrap", weight: cell.s[u] * cell.s[v] * th });
+        }
+      }
+    }
+    return out;
+  };
+  var granules = (inp, box4, count) => bsp(box4, 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;
   };
@@ -13324,8 +13404,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") {
@@ -13432,6 +13522,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 key2 = rowOf(cell.center[v] - cell.size[v] / 2);
+      const row = rows.get(key2);
+      if (row) row.push(i);
+      else rows.set(key2, [i]);
+    }
+    const held = /* @__PURE__ */ new Set();
+    const queue = [];
+    for (const i of rows.get(0) ?? []) {
+      held.add(i);
+      queue.push(i);
+    }
+    const overlap = (a, b) => Math.min(a.center[u] + a.size[u] / 2, b.center[u] + b.size[u] / 2) - Math.max(a.center[u] - a.size[u] / 2, b.center[u] - b.size[u] / 2);
+    const climb = () => {
+      while (queue.length > 0) {
+        const cell = cells[queue.pop()];
+        for (const j of rows.get(rowOf(cell.center[v] + cell.size[v] / 2)) ?? []) {
+          const other = cells[j];
+          if (held.has(j) || overlap(cell, other) <= Math.max(JOINT_GAP, MIN_BEARING_SHARE * Math.min(cell.size[u], other.size[u]))) continue;
+          held.add(j);
+          queue.push(j);
+        }
+      }
+    };
+    for (const row of rows.values()) row.sort((a, b) => cells[a].center[u] - cells[b].center[u]);
+    const touching = (a, b) => Math.abs(a.center[u] + a.size[u] / 2 - (b.center[u] - b.size[u] / 2)) <= 1e-3;
+    for (let wedged = true; wedged; ) {
+      climb();
+      wedged = false;
+      for (const row of rows.values()) {
+        for (let k = 1; k < row.length - 1; k++) {
+          const i = row[k];
+          if (held.has(i) || !held.has(row[k - 1]) || !held.has(row[k + 1])) continue;
+          if (!touching(cells[row[k - 1]], cells[i]) || !touching(cells[i], cells[row[k + 1]])) continue;
+          held.add(i);
+          queue.push(i);
+          wedged = true;
+        }
+      }
+    }
+    const loose = [];
+    for (const row of rows.values()) for (const i of row) if (!held.has(i)) loose.push(i);
+    return loose;
+  };
+  var clumpCells = (cells, thin, cap) => {
+    if (cells.length <= cap) return [...cells];
+    const [u, v] = planeAxes(thin);
+    let lo0 = Infinity, lo1 = Infinity, hi0 = -Infinity, hi1 = -Infinity;
+    for (const cell of cells) {
+      lo0 = Math.min(lo0, cell.center[u] - cell.size[u] / 2);
+      hi0 = Math.max(hi0, cell.center[u] + cell.size[u] / 2);
+      lo1 = Math.min(lo1, cell.center[v] - cell.size[v] / 2);
+      hi1 = Math.max(hi1, cell.center[v] + cell.size[v] / 2);
+    }
+    let side = Math.sqrt((hi0 - lo0) * (hi1 - lo1) / cap);
+    for (; ; ) {
+      const bins = /* @__PURE__ */ new Map();
+      for (const cell of cells) {
+        const key2 = `${Math.floor((cell.center[u] - lo0) / side)}:${Math.floor((cell.center[v] - lo1) / side)}`;
+        const bin = bins.get(key2) ?? { lo: [Infinity, Infinity, Infinity], hi: [-Infinity, -Infinity, -Infinity] };
+        for (let k = 0; k < 3; k++) {
+          bin.lo[k] = Math.min(bin.lo[k], cell.center[k] - cell.size[k] / 2);
+          bin.hi[k] = Math.max(bin.hi[k], cell.center[k] + cell.size[k] / 2);
+        }
+        bins.set(key2, bin);
+      }
+      if (bins.size <= cap) {
+        return [...bins.values()].map(({ lo, hi }) => ({ center: [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2], size: [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]] }));
+      }
+      side *= 1.25;
+    }
+  };
   var MAX_SPALLS = 64;
   var thinAxisOf = (dims) => dims[0] <= dims[1] && dims[0] <= dims[2] ? 0 : dims[1] <= dims[2] ? 1 : 2;
   var resolveLayer = (def, index, mat) => ({ index, def, mat, energy: mat.penetration * def.thickness * 1e3 });
@@ -14411,6 +14583,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "wood_soft",
+      splitForm: "slivers",
       density: 500,
       hpPerKg: 90,
       penetration: 9,
@@ -14456,6 +14629,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "wood_hard",
+      splitForm: "slivers",
       density: 750,
       hpPerKg: 140,
       penetration: 14,
@@ -14500,6 +14674,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "plywood",
+      splitForm: "plies",
       density: 600,
       hpPerKg: 70,
       penetration: 7,
@@ -14547,6 +14722,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "mdf",
+      splitForm: "granules",
       density: 750,
       hpPerKg: 45,
       penetration: 6,
@@ -14713,6 +14889,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           floor: 60
         }
       },
+      ricochetDeg: 12,
       hitDebris: "chips",
       breakDebris: "dust",
       visual: { innerColor: 10197652 },
@@ -14744,6 +14921,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         0.04,
         0.12
       ],
+      ricochetDeg: 10,
       hitDebris: "chips",
       breakDebris: "dust",
       visual: { innerColor: 12085567 },
@@ -14801,6 +14979,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         0.06,
         0.3
       ],
+      ricochetDeg: 15,
       hitDebris: "chips",
       breakDebris: "dust",
       visual: { innerColor: 9407364 },
@@ -15058,6 +15237,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "green_wood",
+      splitForm: "slivers",
       density: 650,
       hpPerKg: 5,
       penetration: 10,
@@ -15228,6 +15408,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         0.03,
         0.15
       ],
+      ricochetDeg: 8,
       hitDebris: "chips",
       breakDebris: "dust",
       thermal: {
@@ -15327,6 +15508,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         0.02,
         0.08
       ],
+      ricochetDeg: 8,
       hitDebris: "chips",
       breakDebris: "dust",
       thermal: {
@@ -15338,6 +15520,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 = {
@@ -15550,6 +15853,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;
@@ -16802,7 +17110,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;
@@ -16930,6 +17238,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];
@@ -16988,6 +17297,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)) {
@@ -17091,10 +17401,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;
@@ -17161,6 +17583,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,
@@ -17169,8 +17592,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) : [];
@@ -17309,7 +17733,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;
@@ -17470,7 +17895,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 } : {} });
@@ -17480,7 +17905,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 };
@@ -17726,6 +18154,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(rng3.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]);
@@ -19021,7 +19454,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var DEFAULT_DENSITY = 500;
   var densityOf = (material) => DENSITY[material] ?? DEFAULT_DENSITY;
   var OPEN_ROOM_TYPES = ["balcony", "terrace", "porch"];
+  var WALL_PILLAR_SIDE = 0.2;
+  var HALF = WALL_PILLAR_SIDE / 2;
   var CLOSED_ONLY = [...OPEN_ROOM_TYPES, "void"];
+  var HALF_PILLAR = WALL_PILLAR_SIDE / 2;
   var entry = (itemId, min, max, group, pickable, weight) => ({ itemId, min, max, group, pickable, weight });
   var FRIDGE = [
     entry("water_bottle", 1, 3, "water", true, 3),
@@ -19756,6 +20192,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];
@@ -19769,6 +20207,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;
@@ -19779,23 +20218,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,
@@ -19810,6 +20252,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];
@@ -19839,7 +20286,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);
     }
@@ -19847,7 +20295,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();
@@ -19909,21 +20368,35 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   };
   var MEMBER_CAGE = { spacing: 0.1, diameter: 8e-3, unit: 0.1 };
   var CAGED_ROLES = /* @__PURE__ */ new Set(["beam", "column"]);
+  var CAGE_COVER = 0.03;
+  var CAGE_BUCKLING_SHARE = 0.5;
+  var DEFAULT_RESIDUAL = 0.15;
+  function cageResidualCapacity(size, reinforcement, capacity) {
+    const [a = 0, b = 0] = [...size].sort((x, y) => x - y);
+    const perSide = (w) => Math.max(2, Math.floor(Math.max(0, w - 2 * CAGE_COVER) / reinforcement.spacing) + 1);
+    const bars = 2 * perSide(a) + 2 * perSide(b) - 4;
+    const steel = MATERIALS2.find((m) => m.id === reinforcement.material)?.compressive ?? 0;
+    const carries2 = bars * Math.PI * (reinforcement.diameter / 2) ** 2 * steel * CAGE_BUCKLING_SHARE;
+    if (!capacity || capacity <= 0 || carries2 <= 0) return DEFAULT_RESIDUAL;
+    return Math.min(1, Math.max(DEFAULT_RESIDUAL, carries2 / capacity));
+  }
   var caged = (spec, part, rebar2) => {
     if (!rebar2 || part.material !== "concrete" || !CAGED_ROLES.has(part.role) || spec.reinforcement) return spec;
     const size = spec.shape.kind === "box" ? spec.shape.size : null;
     if (!size) return spec;
     const thin = Math.min(...size);
+    const reinforcement = { material: rebar2, spacing: MEMBER_CAGE.spacing, diameter: MEMBER_CAGE.diameter };
     return {
       ...spec,
-      reinforcement: { material: rebar2, spacing: MEMBER_CAGE.spacing, diameter: MEMBER_CAGE.diameter },
+      reinforcement: part.role === "column" ? { ...reinforcement, residualCapacity: cageResidualCapacity(size, reinforcement, spec.structure?.capacity) } : reinforcement,
       units: { size: [MEMBER_CAGE.unit, MEMBER_CAGE.unit, thin], bond: "stack", mortar: "concrete" }
     };
   };
   var partSpecOf = (part, capacity, detailed, rebar2) => {
     if (detailed && part.assembly) return assemblySpec(part, capacity);
     const spec = boxSpec(part, capacity);
-    return detailed ? caged(spec, part, rebar2) : spec;
+    const out = detailed ? caged(spec, part, rebar2) : spec;
+    return part.beamKind === "ground_beam" ? { ...out, anchored: true, structure: { role: "foundation" } } : out;
   };
   function toDestructibleSpec(structure, options = {}) {
     const { safety = 0.65, redundancy = 0.97, safetyOthers = 0.45 } = options;
@@ -19939,7 +20412,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;
@@ -20004,6 +20479,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];
@@ -20162,7 +20638,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         parts.push({ id, material: c.material, shape: box3(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;
@@ -20173,11 +20649,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,
@@ -20644,7 +21120,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   var towerLocales = { en: { labels: en_default.labels }, "pt-BR": { labels: pt_BR_default.labels } };
 
-  // ../game-floorplan-three/dist/chunk-QUVGWVEC.js
+  // ../game-floorplan-three/dist/chunk-Y3Y7NYOL.js
+  var __defProp2 = Object.defineProperty;
+  var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp2(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;
+  var __publicField = (obj, key2, value) => __defNormalProp(obj, typeof key2 !== "symbol" ? key2 + "" : key2, value);
   var en2 = {
     "prompt.open": "E: open {what}",
     "prompt.close": "E: close {what}",
@@ -20728,6 +21207,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);
@@ -20790,7 +21283,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") {
@@ -20885,7 +21379,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;
@@ -20983,14 +21477,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);
   }
   function installKernelNoise(K, _shared) {
     const _h2 = (x, z) => {
@@ -21006,15 +21499,18 @@ 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);
   }
   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;
@@ -21133,7 +21629,13 @@ 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);
+  }
+  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;
@@ -21146,7 +21648,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";
@@ -21161,7 +21663,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);
@@ -21258,7 +21760,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);
   }
   function installKernelCloseScene(K, shared2) {
     const { THREE, NO_SHADOW, ORDER, PARTS, applyPart, cursor } = K;
@@ -21267,15 +21770,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 = shared2.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 = shared2.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;
@@ -21283,7 +21789,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 = shared2.ctx.pieces.get(ids[0]);
+        const pc = pieces.get(ids[0]);
         if (pc.role) u.structuralRole = pc.role;
       }
     }
@@ -21334,7 +21840,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);
   }
   function installHouseHelpers(K, shared2) {
     shared2.ctx = {};
@@ -21370,8 +21877,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]))];
@@ -21382,10 +21895,12 @@ 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_TYPES22, NO_CEILING, OPEN_AREA, EPS: EPS3, Y0, colorOf, rectsOf: rectsOf2, roomAt, subRect, subRects, wallColor, floorColor, stairFootprint, effectiveHeight });
+    const defined = { OPEN_ROOM_TYPES: OPEN_ROOM_TYPES22, NO_CEILING, OPEN_AREA, EPS: EPS3, Y0, colorOf, rectsOf: rectsOf2, roomAt, subRect, subRects, wallColor, floorColor, stairFootprint, effectiveHeight };
+    Object.assign(K, defined);
   }
   function installHouseWalls(K, shared2) {
     const { EPS: EPS3, Y0, boxC, bx, cursor, effectiveHeight, pieceRecord, structurePiece, wallColor } = K;
+    const sh = (...a) => K.sh(...a);
     function wallBox(alongU, L, a, b, ya, yb, th, cL, cH, mL, mH) {
       if (yb - ya < 1e-4 || b - a < 1e-4) return;
       if (alongU) {
@@ -21429,8 +21944,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function walls() {
       const R = shared2.ctx.r, cut = shared2.ctx.cut, nA = R.floors.length, vMin = Math.min(...R.walls.map((w) => w.axis === "u" ? w.v0 : Math.min(w.v0, w.v1)));
       const corners = /* @__PURE__ */ new Map();
+      const looks = /* @__PURE__ */ new Map();
       for (const w of R.walls) {
-        const f = w.floor;
+        const f = w.floor, colliders = shared2.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";
@@ -21438,7 +21954,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);
-        shared2.ctx.colliders.push({ type: "wall", piece: w.id, f, x0: alongU ? s0 : L - th / 2, z0: alongU ? L - th / 2 : s0, x1: alongU ? s1 : L + th / 2, z1: alongU ? L + th / 2 : s1 });
+        if (w.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 = shared2.ctx.colors.metal != null ? shared2.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));
@@ -21484,8 +22004,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 (shared2.ctx.showPillars) wallPillars(looks);
     }
-    Object.assign(K, { wallBox, sideOf, pieceOf, nearestWall, walls });
+    const PILLAR_IN_WALL = /^(wall_column_|column_\d|jamb_column_)/;
+    const wallOf = (pillar, parts) => {
+      const u = (pillar.aabb[0] + pillar.aabb[2]) / 2, v = (pillar.aabb[1] + pillar.aabb[3]) / 2;
+      return parts.find((q) => (q.role === "wall" || q.role === "partition") && q.assembly !== void 0 && q.floor === pillar.floor && u >= q.aabb[0] - 1e-3 && u <= q.aabb[2] + 1e-3 && v >= q.aabb[1] - 1e-3 && v <= q.aabb[3] + 1e-3);
+    };
+    function wallPillars(looks) {
+      const parts = Object.values(shared2.ctx.structureIndex);
+      for (const e of parts) {
+        if (e.role !== "column" || !PILLAR_IN_WALL.test(e.id)) continue;
+        const host = wallOf(e, parts);
+        const look = host && looks.get(host.id);
+        if (!host || !look) continue;
+        cursor.group = "f" + e.floor;
+        cursor.pc = structurePiece(host.id);
+        bx(look.mat, e.aabb[0], e.y0, e.aabb[1], e.aabb[2], Math.min(e.y1, look.top), e.aabb[3], sh(look.color != null ? look.color : 15262420, 0.93));
+      }
+      cursor.pc = null;
+    }
+    const defined = { wallBox, sideOf, pieceOf, nearestWall, walls, wallPillars };
+    Object.assign(K, defined);
   }
   function installHouseDoors(K, shared2) {
     const seedKey = (id) => K.seedKey(id);
@@ -21502,7 +22042,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     shared2.doorState = /* @__PURE__ */ new Map();
     function doors() {
-      shared2.ctx.leaves = [];
+      const leaves = shared2.ctx.leaves = [], doorState = shared2.doorState, colliders = shared2.ctx.colliders;
       const R = shared2.ctx.r, cut = shared2.ctx.cut, C = shared2.ctx.colors, wood = C.wood != null ? C.wood : 8016948, frame2 = sh(wood, 0.55);
       for (const p of R.doors) {
         const f = p.floor;
@@ -21533,21 +22073,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 : shared2.doorState.has(p.id) ? shared2.doorState.get(p.id) : !!p.open;
-        shared2.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 };
-        shared2.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");
@@ -21562,7 +22102,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);
             {
@@ -21598,7 +22138,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]);
           }
         }
-        shared2.ctx.leaves.push(fo);
+        leaves.push(fo);
         cursor.group = "f" + f;
         if (p.blocked) {
           part("window_boards", [0, 0, 0], () => {
@@ -21626,11 +22166,12 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
               }
             }
           }, { id: "boards:" + p.id }, "f" + f);
-          shared2.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);
   }
   function installHouseWindows(K, shared2) {
     const { EPS: EPS3, Y0, boxC, bx, cursor, pieceRecord, roomAt } = K;
@@ -21688,7 +22229,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);
   }
   function installHouseFloors(K, shared2) {
     const { rectsOf: rectsOf2, EPS: EPS3, OPEN_AREA, Y0, bx, cursor, floorColor, stairFootprint, structurePiece, subRects } = K;
@@ -21696,7 +22238,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       if (shared2.ctx._flights && shared2.ctx._flights.r === shared2.ctx.r) return shared2.ctx._flights.l;
       const R = shared2.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) });
       }
@@ -21715,7 +22257,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 && shared2.ctx.panelsOf && shared2.ctx.panelsOf.get(parent);
+      const ps = parent ? shared2.ctx.panelsOf && shared2.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)) {
@@ -21777,13 +22319,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 = shared2.ctx.r;
-      shared2.ctx.stairs = [];
+      const R = shared2.ctx.r, stairs = shared2.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 = shared2.ctx.colors.wood != null ? shared2.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) => {
@@ -21806,7 +22347,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           }
         }
         cursor.pc = null;
-        shared2.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() {
@@ -21823,7 +22364,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
     }
-    Object.assign(K, { buildStairs, elevator });
+    const defined = { buildStairs, elevator };
+    Object.assign(K, defined);
   }
   function installLightsFixtures(K, shared2) {
     const seedKey = (id) => K.seedKey(id);
@@ -21861,14 +22403,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         c: (mat, x, y, z, r, h, color2, seg2) => api.cylinder(M, mat, x, y0 + y, z, r, h, color2, 0, 0, seg2),
         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, seg2) {
+          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, seg2);
+            api.cylinder(M, mat, p[0], y0 + Math.min(p[1], q[1]), p[2], r, L, tc, 0, 0, seg2);
             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), seg2);
+          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), seg2);
         },
         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) {
@@ -22047,7 +22590,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: hashString2, rngString, SEED, STYLE, kit2, arcPoints, TEMP_WARM, TEMP_NEUTRAL, TEMP_COOL, colorTemperature, lightStyle, ceilingLamp, tableLamp, floorLamp, sconce, outdoorLamp, lightSwitch });
+    const defined = { hashString: hashString2, rngString, SEED, STYLE, kit2, arcPoints, TEMP_WARM, TEMP_NEUTRAL, TEMP_COOL, colorTemperature, lightStyle, ceilingLamp, tableLamp, floorLamp, sconce, outdoorLamp, lightSwitch };
+    Object.assign(K, defined);
   }
   function installLightsDecor(K, shared2) {
     const { EPS: EPS3, OPEN_AREA, SEED, Y0, cursor, rngString, roomAt, stairFootprint } = K;
@@ -22112,7 +22656,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         void sd;
       }
     }
-    Object.assign(K, { decorLights });
+    const defined = { decorLights };
+    Object.assign(K, defined);
   }
   function installLotTerrain(K, shared2) {
     const { rectsOf: rectsOf2, MIRRORS, PARTS, bx, cursor } = K;
@@ -22163,7 +22708,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);
   }
   function installLotPerimeter(K, shared2) {
     const { EPS: EPS3, boxC, bx, colorOf, cursor, freeSpans, pieceRecord } = K;
@@ -22181,7 +22727,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 };
         shared2.ctx.colliders.push(col);
@@ -22255,7 +22801,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
     }
-    Object.assign(K, { perimeter, paths });
+    const defined = { perimeter, paths };
+    Object.assign(K, defined);
   }
   function installLotGates(K, shared2) {
     const { bx, colorOf, cursor, cylBase } = K;
@@ -22269,7 +22816,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);
@@ -22341,7 +22888,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (!g.open || ped) shared2.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);
   }
   function installRoofRoofs(K, shared2) {
     const { rectsOf: rectsOf2, EPS: EPS3, OPEN_AREA, Y0, bx, cursor } = K;
@@ -22353,13 +22901,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function roofs() {
       const R = shared2.ctx.r, F = R.facade, C = shared2.ctx.colors, nA = R.floors.length, type = F.roof;
       cursor.group = "roof";
-      shared2.ctx.roofRects = [];
-      shared2.ctx.gutter = gutterConfig();
-      shared2.ctx.gutter.ncond = 0;
-      shared2.ctx.gutter.nbuz = 0;
-      shared2.ctx.gutter.bz = /* @__PURE__ */ new Set();
+      const roofRects = shared2.ctx.roofRects = [];
+      const G = shared2.ctx.gutter = gutterConfig();
+      G.ncond = 0;
+      G.nbuz = 0;
+      G.bz = /* @__PURE__ */ new Set();
       shared2.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;
@@ -22381,7 +22929,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)) shared2.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;
@@ -22404,16 +22952,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;
           }
-          shared2.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 (shared2.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 shared2.ctx.outbuildingList || []) {
         const [x0, z0, x1, z1] = e.aabb, yb = Y0(0) + (e.ceiling || 2.6) + 0.2;
-        shared2.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));
@@ -22424,11 +22972,13 @@ 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;
         shared2.ctx.noPiece = false;
-        if (shared2.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);
   }
+  var paletteMeta = (colors) => colors.meta;
   function installRoofGutters(K, shared2) {
     const { boxC, bx, cursor, roomAt } = K;
     const sh = (...a) => K.sh(...a);
@@ -22445,7 +22995,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const draw = rnd() < p, light = rnd() < 0.6;
       void draw;
       const on = true;
-      return { on, rnd, color: high ? 3816770 : light ? 15527921 : 10857392, bad: (shared2.ctx.colors.meta && shared2.ctx.colors.meta.state) === "abandoned" || R.state === "abandoned", fallback: false };
+      return { on, rnd, color: high ? 3816770 : light ? 15527921 : 10857392, bad: paletteMeta(shared2.ctx.colors)?.state === "abandoned" || R.state === "abandoned", fallback: false };
     }
     function gutter(type, f, X0, Z0, X1, Z1, yb, touchesU) {
       const G = shared2.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;
@@ -22487,7 +23037,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);
@@ -22521,7 +23071,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);
@@ -22532,7 +23082,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);
   }
   function installRoofSlabs(K, shared2) {
     const { boxC, bx, cursor, drain, roomAt, structurePiece } = K;
@@ -22564,15 +23115,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 (shared2.ctx.gutter && shared2.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 = shared2.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 || shared2.ctx.gutter.bz.has(kd)) continue;
-          shared2.ctx.gutter.bz.add(kd);
-          shared2.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 = shared2.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 (shared2.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;
@@ -22592,7 +23144,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
     }
-    Object.assign(K, { slabs });
+    const defined = { slabs };
+    Object.assign(K, defined);
   }
   function installRoofTiles(K, shared2) {
     const { UV_SCALE, _Y, _h2, _q, accFor, cursor, put, rgbOf, structurePiece } = K;
@@ -22723,7 +23276,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);
   }
   function installRoofRect(K, shared2) {
     const { R_STYLE, bx, cursor, pieceOfPane, polyFace, ridge, tileRelief } = K;
@@ -22767,7 +23321,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       const rm = alongX ? dz / 2 : dx / 2;
       {
-        const rr = shared2.ctx.roofRects[shared2.ctx.roofRects.length - 1];
+        const roofRects = shared2.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) {
@@ -22804,7 +23358,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
       }
     }
-    Object.assign(K, { roofRect });
+    const defined = { roofRect };
+    Object.assign(K, defined);
   }
   function installMirrors(K, shared2) {
     const { DOC, THREE, Reflector, MIRRORS, Y0, _Y, roomAt } = K;
@@ -22813,9 +23368,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function mirrorEnv() {
       if (shared2.mirrorEnv) return shared2.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;
       };
@@ -22874,7 +23431,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();
         }
@@ -22952,7 +23509,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);
   }
   function installCars(K, shared2) {
     const { THREE, FLEET, _Y } = K;
@@ -22963,13 +23521,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) {
@@ -22981,7 +23542,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     function carModel(k, seed) {
       const kc = k + "|" + shared2.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 {
@@ -22989,8 +23550,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;
@@ -23004,7 +23567,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;
@@ -23105,7 +23668,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return g;
     }
     function assembleCars(groups) {
-      if (shared2.quality === "game") return assembleMergedCars(groups);
+      if (shared2.quality === "game") {
+        assembleMergedCars(groups);
+        return;
+      }
       for (const C of CARS) {
         const g = carGroup(C.k, C.w, C.d, C.seed);
         if (!g) continue;
@@ -23156,7 +23722,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);
   }
   function installHouseBuilding(K, shared2) {
     const { bx, cursor } = K;
@@ -23210,12 +23777,13 @@ 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);
       shared2.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);
   }
   function installUtilitiesWater(K, shared2) {
     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;
@@ -23304,14 +23872,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     const _v3 = new THREE.Vector3();
     function waterPipes() {
-      const H = shared2.ctx.r.utilities.plumbing;
+      const H = shared2.ctx.r.utilities?.plumbing;
       if (!H || !H.visibleRuns) return;
       const nA = shared2.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 = shared2.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 ? shared2.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);
@@ -23333,16 +23901,17 @@ 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);
   }
   function installUtilitiesElectrical(K, shared2) {
     const { _Y, _q, _v3, bx, cursor, cylBase, pieceRecord, put } = K;
     const sh = (...a) => K.sh(...a);
     function electricalStructure() {
-      const E = shared2.ctx.r.utilities.electrical;
+      const R = shared2.ctx.r, E = R.utilities?.electrical;
       shared2.ctx.electricalInfo = null;
       if (!E) return;
-      const R = shared2.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 en22 = E.serviceEntrance, KV = shared2.ctx.iv ? shared2.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]);
@@ -23447,7 +24016,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);
   }
   function installHouseBaseboard(K, shared2) {
     const { Y0, bx, cursor, sideOf } = K;
@@ -23483,7 +24053,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);
   }
   function installUtilitiesSolar(K, shared2) {
     const { Y0, boxC, bx, cursor, cylBase } = K;
@@ -23496,6 +24067,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);
@@ -23504,7 +24076,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return y;
     }
     function solar() {
-      const R = shared2.ctx.r, S = R.utilities.solar;
+      const R = shared2.ctx.r, S = R.utilities?.solar;
       shared2.ctx.solarInfo = null;
       if (!S || !S.panels || !S.panels.length) return;
       cursor.group = "roof";
@@ -23547,13 +24119,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(...(shared2.ctx.roofRects || []).filter((t2) => t2.yb != null).map((t2) => t2.yb), Y0(fa) + 2.8);
+        const top = Math.max(...(shared2.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 };
       }
       shared2.ctx.solarInfo = info;
     }
-    Object.assign(K, { roofHeightAt, solar });
+    const defined = { roofHeightAt, solar };
+    Object.assign(K, defined);
   }
   function installHouseOutbuildings(K, shared2) {
     const { t, bx, cursor, floorColor } = K;
@@ -23566,7 +24139,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) {
@@ -23580,7 +24153,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 });
       }
@@ -23601,7 +24189,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);
   }
   function installFurnitureApi(K, _shared) {
     const { _e, _h2, _q, boxC, cursor, macroGround, polyFace, put } = K;
@@ -23664,7 +24253,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, seg2) => A.cylinder(M, mat, x, y0 + y, z, r, h, color2, rx || 0, rz || 0, seg2), 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);
   }
   function installFurnitureBuilders(K, _shared) {
     const { PE, _q, kit2, kk, paletteColor, put, rngOf, sh } = K;
@@ -23790,7 +24380,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));
@@ -24182,7 +24772,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);
   }
   function installFurnitureTypeTable(K, _shared) {
     const { FURNITURE, kk, paletteColor } = K;
@@ -24190,7 +24781,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 };
@@ -24329,7 +24921,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);
   }
   function installFurnitureTaps(K, shared2) {
     shared2.tapCount = 0;
@@ -24391,7 +24984,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);
   }
   function installFurnitureFixtures(K, _shared) {
     const seedKey = (id) => K.seedKey(id);
@@ -24500,7 +25094,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]);
         }
@@ -24613,7 +25207,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);
   }
   function installFurnitureYard(K, shared2) {
     const seedKey = (id) => K.seedKey(id);
@@ -24767,7 +25362,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);
@@ -24787,7 +25382,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: garment2 });
+    const defined = { CLOTHES_COLORS, strip, garment: garment2 };
+    Object.assign(K, defined);
   }
   function installFurnitureExtraTypes(K, _shared) {
     const seedKey = (id) => K.seedKey(id);
@@ -24845,7 +25441,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);
   }
   function installFurniturePlaceItems(K, shared2) {
     const { THREE, Y0, _col, boxC, colorOf, cursor, decorLights, makeApi, structurePiece } = K;
@@ -24865,8 +25462,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 = shared2.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: shared2.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: shared2.ctx.night, light: shared2.ctx.night, lit: shared2.ctx.night, open: !!m.doorOpen, overhead: m.overhead, assembly: m.assembly, hose: m.hose };
+        const com = m.room != null ? shared2.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: shared2.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: shared2.ctx.night, light: shared2.ctx.night, lit: shared2.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;
@@ -24943,7 +25540,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);
       shared2.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);
   }
   function installVegetationBridge(K, shared2) {
     const seedKey = (id) => K.seedKey(id);
@@ -24976,7 +25574,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const ids = VEG_MAP[m.type], can2 = VEG_PLANTER[m.type];
       if (!ids && !can2) 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);
@@ -25022,7 +25620,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;
@@ -25037,7 +25635,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       shared2.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);
   }
   function installInteractionState(K, shared2) {
     const { THREE, cfg, colliderChanged, invalidateShadow, invalidate, UV_SCALE, applyPart, texture } = K;
@@ -25103,12 +25702,14 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       shared2.inter.msg = { text, until: performance.now() + MESSAGE_MS };
       if (cfg.onMessage) cfg.onMessage(text);
     };
-    function definePiece(name, def) {
+    const I = () => shared2.inter;
+    function definePiece(name, definition) {
+      const def = definition;
       def.name = name;
       def.meshes = [];
       def.t = def.target = shared2.partState.has(name) ? shared2.partState.get(name) : def.t0 || 0;
-      shared2.inter.defs.set(name, def);
-      shared2.inter.pieces.push(def);
+      I().defs.set(name, def);
+      I().pieces.push(def);
       return def;
     }
     const localOf = (M, lx, lz) => {
@@ -25120,17 +25721,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       return true;
     }
     function assembleInteractive(gs) {
-      for (const [name, def] of shared2.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);
@@ -25142,13 +25744,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 (!shared2.inter.lights.has(def.roomId)) shared2.inter.lights.set(def.roomId, []);
-          shared2.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 shared2.inter.litRooms) applyLight(roomId);
-      shared2.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;
       });
     }
@@ -25156,6 +25759,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;
@@ -25188,8 +25792,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 (!shared2.inter.anim.size) return;
-      for (const p of shared2.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);
@@ -25197,7 +25802,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) shared2.inter.anim.delete(p);
+        if (p.t === p.target) inter.anim.delete(p);
       }
       invalidateShadow();
     }
@@ -25208,7 +25813,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         p.col.off = p.target > 0.5;
         colliderChanged(p.col);
       }
-      shared2.inter.anim.add(p);
+      I().anim.add(p);
     }
     const lightBase = (roomId) => roomId == null ? true : shared2.partState.has("light:" + roomId) ? !!shared2.partState.get("light:" + roomId) : !!shared2.ctx.night;
     const lightOn = (roomId) => {
@@ -25216,20 +25821,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 shared2.inter.lights.get(roomId) || []) for (const m of d.meshes) if (m.name.endsWith("/emissive")) m.material = on ? shared2.mats.emissive : shared2.mats.off;
-      const sw = shared2.inter.defs.get("ix:int:" + roomId);
+      const on = lightOn(roomId), inter = I(), mats = shared2.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) shared2.inter.anim.add(sw);
+        if (sw.t !== sw.target) inter.anim.add(sw);
       }
       invalidate();
     }
     function toggleLight(roomId) {
       const S = shared2.ctx.iv && shared2.ctx.iv.roomStates.get(roomId);
       if (S) {
-        ivRoomLight(shared2.ctx.iv, roomId, !S.ef);
-        const ef = ivRoomEffective(shared2.ctx.iv, S);
+        const IV = shared2.ctx.iv;
+        ivRoomLight(IV, roomId, !S.ef);
+        const ef = ivRoomEffective(IV, S);
         if (ef !== S.ef) {
           S.ef = ef;
           applyLight(roomId);
@@ -25241,9 +25847,11 @@ 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);
   }
   function installInteractionCollision(K, shared2) {
+    const inter = () => shared2.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;
@@ -25253,7 +25861,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         w = Math.min(w, 0.5);
         d = Math.min(d, 0.5);
       }
-      shared2.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;
@@ -25261,7 +25869,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 shared2.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;
@@ -25281,13 +25889,15 @@ 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);
   }
   function installInteractionItems(K, shared2) {
     const { t, LIGHTS, cursor, definePiece, localOf, registerCollision, togglePiece } = K;
     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 = () => shared2.inter;
     function objectName(type, drawer) {
       return drawer ? "drawer" : /^wardrobe/.test(type) ? "wardrobe" : /fridge|refrig|freezer/.test(type) ? "fridge" : /pantry/.test(type) ? "pantry" : "cabinet";
     }
@@ -25316,8 +25926,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 (!shared2.inter.defs.has(name)) definePiece(name, { kind: "light", pivot: [0, 0, 0], ry: 0, parent, roomId: m.room });
-      shared2.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;
@@ -25345,12 +25955,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);
-      shared2.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;
           shared2.partState.set(p.name, al);
-          shared2.inter.anim.add(p);
+          I().anim.add(p);
         }
       } });
     }
@@ -25371,7 +25982,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;
@@ -25403,8 +26014,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) => {
@@ -25420,8 +26032,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);
-        shared2.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 = shared2.inter.items[shared2.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);
@@ -25435,12 +26047,15 @@ 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: buildItem2, lightItem, curtainItem, furnitureItem });
+    const defined = { DOOR_ITEM, DRAWER_ITEM, LIGHT_TYPES, objectName, recordApi, buildItem: buildItem2, lightItem, curtainItem, furnitureItem };
+    Object.assign(K, defined);
   }
   function installInteractionFittings(K, shared2) {
     const { t, EPS: EPS3, OPEN_AREA, Y0, applyPiece, bx, cursor, definePiece, gates, lightOn, roomAt, slideDirection, toggleLight, togglePiece } = K;
+    const I = () => shared2.inter;
+    const house = () => shared2.ctx.r;
     function gatesInteractive() {
-      const lt = shared2.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) => {
@@ -25460,9 +26075,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 = shared2.ctx.colliders.length;
+      const colliders = shared2.ctx.colliders, n0 = colliders.length;
       try {
         gs.forEach((g) => {
           g.open = false;
@@ -25474,7 +26089,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           g.open = opening[i];
         });
       }
-      const cols = shared2.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;
@@ -25483,25 +26098,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") });
-        shared2.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 shared2.ctx.r.items) {
+      for (const m of house().items) {
         if (m.type !== "mailbox") continue;
         const g = shared2.ctx.parts && shared2.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;
-        shared2.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 = shared2.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) || !shared2.inter.litRooms.has(c.id) || used.has(c.id) || shared2.ctx.iv && shared2.ctx.iv.switchRooms.has(c.id)) continue;
+        if (c.type === "void" || OPEN_AREA(c) || !I().litRooms.has(c.id) || used.has(c.id) || shared2.ctx.iv && shared2.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)) {
@@ -25511,11 +26126,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
     }
     function putSwitch(c, p) {
-      const R = shared2.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;
@@ -25538,17 +26153,20 @@ 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];
-        shared2.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);
   }
   function installInteractionDoors(K, shared2) {
     const { t, colliderChanged, invalidateShadow, applyPiece, hudMessage } = K;
+    const leaves = () => shared2.ctx.leaves;
     function linkDoorLeaves() {
-      for (const fo of shared2.ctx.leaves) fo.handles = (fo.handleNames || []).map((n) => shared2.inter.defs.get(n)).filter(Boolean);
+      const I = shared2.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 || []) {
@@ -25558,11 +26176,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;
         shared2.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;
@@ -25576,8 +26195,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       fo.open = !fo.open;
       shared2.doorState.set(fo.id, fo.open);
-      fo.col.off = fo.open;
-      colliderChanged(fo.col);
+      col.off = fo.open;
+      colliderChanged(col);
       fo.anim = true;
       shared2.ctx.animateDoorsOn = true;
       if (fo.handles && fo.handles.length) {
@@ -25588,7 +26207,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function animateDoors(dt) {
       if (!shared2.ctx.animateDoorsOn) return;
       let active = false;
-      for (const fo of shared2.ctx.leaves) {
+      for (const fo of leaves()) {
         if (!fo.phase) continue;
         active = true;
         if (fo.phase === "handle") {
@@ -25608,7 +26227,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) {
@@ -25622,9 +26241,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       invalidateShadow();
     }
     function wallBlocks(ex, ez, ax, az, floor) {
-      const n = shared2.ctx.wallColliders != null ? shared2.ctx.wallColliders : 0;
+      const n = shared2.ctx.wallColliders != null ? shared2.ctx.wallColliders : 0, colliders = shared2.ctx.colliders;
       for (let i = 0; i < n; i++) {
-        const c = shared2.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;
@@ -25654,7 +26273,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);
   }
   function installInteractionTarget(K, shared2) {
     const { doorText, toggleDoor, visibleChain, wallBlocks } = K;
@@ -25662,6 +26282,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function targetOf(o, opt) {
       if (!o) return null;
       opt = opt || {};
+      const I = shared2.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) => {
@@ -25675,16 +26296,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 = shared2.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 = shared2.ctx.iv ? ivTarget(shared2.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 shared2.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);
@@ -25692,7 +26313,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);
   }
   function installInteractablesBridge(K, shared2) {
     const { t, THREE, invalidate, invalidateShadow, cfg, DOC, LIGHT_TYPES, _Y, _q, _v3, accFor, applyLight, cursor, hashString: hashString2, hudMessage, lightBase, pieceRecord, put, rgbOf, sh, wallBlocks } = K;
@@ -25747,7 +26369,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function ivBuild(h, water) {
       const ik = K.IVK, r = shared2.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();
@@ -25766,9 +26389,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: shared2.mats.plain, metal: shared2.mats.metal, wood: shared2.mats.wood, glass: shared2.mats.glass, fabric: shared2.mats.fabric, plant: shared2.mats.plant, water: shared2.mats.water, emissive: shared2.mats.emissive, atlas_picture: shared2.mats.picture, atlas_floor: shared2.mats.floor };
+      const mats = shared2.mats;
+      IV.mats = { plain: mats.plain, metal: shared2.mats.metal, wood: shared2.mats.wood, glass: shared2.mats.glass, fabric: shared2.mats.fabric, plant: shared2.mats.plant, water: shared2.mats.water, emissive: shared2.mats.emissive, atlas_picture: shared2.mats.picture, atlas_floor: shared2.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);
@@ -25785,7 +26409,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;
@@ -25832,14 +26456,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;
@@ -25848,7 +26473,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";
           }
@@ -25856,13 +26481,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);
         }
@@ -25872,7 +26497,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();
@@ -25883,7 +26508,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;
@@ -25911,7 +26536,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]) {
@@ -25946,9 +26571,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;
@@ -25984,16 +26610,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);
         }
@@ -26002,7 +26629,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 };
     }
@@ -26044,18 +26671,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]],
@@ -26090,7 +26718,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]]);
           }
         }
       }
@@ -26119,12 +26748,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, shared2.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, shared2.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;
@@ -26258,7 +26888,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);
   }
   function installAnimationClotheslines(K, shared2) {
     const { invalidate, CLOTHES_UNIFORMS } = K;
@@ -26281,7 +26912,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);
   }
   function installBuildInstance(K, shared2) {
     const { PROPS, THREE, DOC, cfg, HP, createInteractiveMaterials, createMaterials, typeTable } = K;
@@ -26304,7 +26936,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       shared2.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);
   }
   function installInteractablesKit(K, shared2) {
     const { t, THREE, DOC, cfg, Reflector } = K;
@@ -26330,15 +26963,18 @@ 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);
   }
+  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, shared2) {
     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;
@@ -26366,12 +27002,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(shared2.mats)) roomLightMask(shared2.mats[k]);
+      const mats = shared2.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 [key2, width] of [["uRB0", 4], ["uRB1", 4], ["uRB2", 4], ["uRBY", 2], ["uREx", 4]]) {
@@ -26422,9 +27059,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(houses, focus, op) {
-        op = op || {};
-        houses = (Array.isArray(houses) ? houses : [houses]).filter(Boolean);
+      A.update = function(houseOrList, focus, options2) {
+        const op = options2 || {}, houses = (Array.isArray(houseOrList) ? houseOrList : [houseOrList]).filter((h) => !!h);
         _f.set(focus.x, focus.y, focus.z);
         const rooms = [], exterior = [];
         for (const house of houses) {
@@ -26436,7 +27072,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()) {
@@ -26471,9 +27107,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;
@@ -26574,8 +27211,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);
@@ -26653,7 +27290,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(houses) {
-          const indoors = cfg.effectLightsIndoors !== false, list2 = (Array.isArray(houses) ? houses : [houses]).filter(Boolean), cache2 = /* @__PURE__ */ new Map();
+          const indoors = cfg.effectLightsIndoors !== false, list2 = (Array.isArray(houses) ? houses : [houses]).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];
@@ -26681,7 +27318,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);
   }
   var NONE = { panels: [], replaced: [], supports: [] };
   var MEMO = /* @__PURE__ */ new WeakMap();
@@ -26857,7 +27495,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" } };
               }
@@ -26883,6 +27522,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);
@@ -26966,10 +27606,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;
@@ -26980,7 +27621,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;
@@ -26994,8 +27635,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();
@@ -27084,6 +27738,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) {
@@ -27106,9 +27771,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 });
@@ -27204,52 +27875,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 draw(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 {
@@ -27360,14 +28034,32 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
          */
         chip(event) {
           if (event.torn) return false;
-          return draw(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 draw(event.part, { chips: event.units.map((unit) => ({ center: unit.center, size: unit.size, rotation })) });
+          return draw(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. */
@@ -27804,8 +28496,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   function installBuildBuild(K, shared2) {
     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 };
@@ -27826,7 +28518,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       shared2.ctx.pieces = /* @__PURE__ */ new Map();
       shared2.ctx.pieceObjects = /* @__PURE__ */ new Map();
       shared2.ctx.structureIndex = {};
-      for (const e of r0.structure && r0.structure.parts || []) shared2.ctx.structureIndex[e.id] = e;
+      for (const e of r0.structure?.parts || []) shared2.ctx.structureIndex[e.id] = e;
       {
         const view = shared2.ctx.panelView = panelViewOf(r0.structure, !!cfg.destruction);
         shared2.ctx.panelsOf = /* @__PURE__ */ new Map();
@@ -27838,17 +28530,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           else shared2.ctx.panelsOf.set(e.slab, [e]);
         }
       }
-      shared2.ctx.panes = r0.roof && r0.roof.panes || [];
+      shared2.ctx.panes = r0.roof?.panes || [];
       shared2.ctx.noPiece = false;
       cursor.separate = opts.pieces === "meshes";
       cursor.pc = null;
+      shared2.ctx.showPillars = opts.pillars !== "hidden";
       shared2.ctx.apartment = r.template === "apartment_modern";
       shared2.ctx.pa = Math.max(3, Math.min(20, pr.floors != null ? pr.floors : 5));
       shared2.ctx.pf = Math.max(1, Math.min(shared2.ctx.pa, pr.floor != null ? pr.floor : 3));
       shared2.ctx.pu = Math.max(0, pr.unit != null ? pr.unit : 0);
       shared2.ctx.showBuilding = shared2.ctx.apartment && (pr.showIt == null ? true : !!pr.showIt);
       shared2.ctx.limits = { x0: -2, z0: -2, x1: r.w + 2, z1: r.d + 2 };
-      shared2.ctx.veg = VEG ? { G: VEG.G, S: VEG.S, mats: vegMaterials, groups: /* @__PURE__ */ new Map(), ok: /* @__PURE__ */ new Map(), opts: shared2.quality === "game" ? { quality: "game" } : { lod: 0, triangleBudget: 6e4 } } : null;
+      shared2.ctx.veg = VEG ? { G: VEG.G, S: VEG.S, mats: vegMaterials, groups: /* @__PURE__ */ new Map(), ok: /* @__PURE__ */ new Map(), opts: shared2.quality === "game" ? { quality: "game" } : { quality: "high", lod: 0, triangleBudget: 6e4 } } : null;
       shared2.ctx.vegInfo = null;
       terrain();
       if (r.lot) {
@@ -27898,7 +28591,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);
         }
@@ -27913,7 +28606,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       root.add(house);
       shared2.mirrors.house = house;
       if (shared2.ctx.apartment) {
-        const u = r.building.units[Math.min(shared2.ctx.pu, r.building.units.length - 1)];
+        const units = r.building.units, u = units[Math.min(shared2.ctx.pu, units.length - 1)];
         house.position.set(u.u, shared2.ctx.showBuilding ? 0 : -r.floors[0].y0, u.v);
         house.rotation.y = u.ry;
         shared2.ctx.unitRy = u.ry;
@@ -28029,7 +28722,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) {
@@ -28072,7 +28766,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;
           }
@@ -28086,8 +28780,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 };
       shared2.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;
@@ -28164,7 +28858,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         lights: (() => {
           const by = {};
           for (const l of shared2.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: shared2.ctx.lights, byRoom: by };
@@ -28204,9 +28898,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 = shared2.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;
@@ -28226,7 +28920,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 shared2.inter.msg && performance.now() < shared2.inter.msg.until ? shared2.inter.msg.text : null;
@@ -28283,13 +28977,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;
             }
           }
@@ -28300,8 +28994,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();
         },
@@ -28309,7 +29003,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       };
       return res;
     }
-    Object.assign(K, { build });
+    const defined = { build };
+    Object.assign(K, defined);
   }
   function buildApi(K, shared2) {
     const { cfg, VERSION: VERSION2, ATLAS, TEX, applyPart, carGroup, carModel, props, TYPES, roomLightMask, lighting, effectLights, newState, build } = K;
@@ -28329,11 +29024,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       lighting,
       effectLights,
       setNight(n) {
-        shared2.mats.glass.emissive.set(n ? 9067040 : 0);
-        shared2.mats.glass.opacity = n ? 0.4 : 0.24;
+        const glass = shared2.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 };
@@ -28435,10 +29132,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
 
   // ../game-floorplan-residential/dist/index.js
-  var __defProp2 = Object.defineProperty;
+  var __defProp3 = Object.defineProperty;
   var __export2 = (target, all) => {
     for (var name in all)
-      __defProp2(target, name, { get: all[name], enumerable: true });
+      __defProp3(target, name, { get: all[name], enumerable: true });
   };
   var residentialItems = [
     { type: "sofa_3seat", category: "sofa", w: 2.1, d: 0.9, h: 0.85, color: { role: "fabric_main" } },