@adatechnology/game-floorplan-three 0.9.3 → 0.10.0

package/dist/index.global.js

@@ -4361,6 +4361,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   // src/house/walls.ts
   function installHouseWalls(K, shared) {
     const { EPS: EPS3, Y0, boxC, bx, cursor, effectiveHeight, pieceRecord, structurePiece, wallColor } = K;
+    const sh = (color2, factor) => K.sh(color2, factor);
     function wallBox2(alongU, L, a, b, ya, yb, th, cL, cH, mL, mH) {
       if (yb - ya < 1e-4 || b - a < 1e-4) return;
       if (alongU) {
@@ -4404,6 +4405,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     function walls() {
       const R = shared.ctx.r, cut = shared.ctx.cut, nA = R.floors.length, vMin = Math.min(...R.walls.map((w) => w.axis === "u" ? w.v0 : Math.min(w.v0, w.v1)));
       const corners = /* @__PURE__ */ new Map();
+      const looks = /* @__PURE__ */ new Map();
       for (const w of R.walls) {
         const f = w.floor;
         cursor.group = "f" + f;
@@ -4413,6 +4415,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const hh = cut ? Math.min(h, 1.2) : h, L = alongU ? w.v0 : w.u0, s0 = Math.min(alongU ? w.u0 : w.v0, alongU ? w.u1 : w.v1), s1 = Math.max(alongU ? w.u0 : w.v0, alongU ? w.u1 : w.v1);
         const front = alongU && Math.abs(L - vMin) < 0.05;
         const sideL = sideOf(w.sides[0], front), sideH = sideOf(w.sides[1], front);
+        if (w.id) {
+          const face = sideL.exterior ? sideL : sideH;
+          looks.set(w.id, { mat: face.mat, color: face.color, top: y0 + hh });
+        }
         shared.ctx.colliders.push({ type: "wall", piece: w.id, f, x0: alongU ? s0 : L - th / 2, z0: alongU ? L - th / 2 : s0, x1: alongU ? s1 : L + th / 2, z1: alongU ? L + th / 2 : s1 });
         if (w.type === "railing") {
           const c0 = shared.ctx.colors.metal != null ? shared.ctx.colors.metal : 9080466;
@@ -4459,8 +4465,27 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         cursor.group = "f" + e.f;
         bx(e.color.mat, e.pu - e.th / 2, e.y0, e.pv - e.th / 2, e.pu + e.th / 2, e.y0 + e.hh, e.pv + e.th / 2, e.color.color);
       }
+      if (shared.ctx.showPillars) wallPillars(looks);
+    }
+    const PILLAR_IN_WALL = /^(wall_column_|column_\d|jamb_column_)/;
+    const wallOf = (pillar, parts) => {
+      const u = (pillar.aabb[0] + pillar.aabb[2]) / 2, v = (pillar.aabb[1] + pillar.aabb[3]) / 2;
+      return parts.find((q) => (q.role === "wall" || q.role === "partition") && q.assembly !== void 0 && q.floor === pillar.floor && u >= q.aabb[0] - 1e-3 && u <= q.aabb[2] + 1e-3 && v >= q.aabb[1] - 1e-3 && v <= q.aabb[3] + 1e-3);
+    };
+    function wallPillars(looks) {
+      const parts = Object.values(shared.ctx.structureIndex);
+      for (const e of parts) {
+        if (e.role !== "column" || !PILLAR_IN_WALL.test(e.id)) continue;
+        const host = wallOf(e, parts);
+        const look = host && looks.get(host.id);
+        if (!host || !look) continue;
+        cursor.group = "f" + e.floor;
+        cursor.pc = structurePiece(host.id);
+        bx(look.mat, e.aabb[0], e.y0, e.aabb[1], e.aabb[2], Math.min(e.y1, look.top), e.aabb[3], sh(look.color != null ? look.color : 15262420, 0.93));
+      }
+      cursor.pc = null;
     }
-    Object.assign(K, { wallBox: wallBox2, sideOf, pieceOf, nearestWall, walls });
+    Object.assign(K, { wallBox: wallBox2, sideOf, pieceOf, nearestWall, walls, wallPillars });
   }
 
   // src/house/doors.ts
@@ -11433,6 +11458,22 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     return angle === 0 ? q : quat.mul(q, quat.fromAxisAngle([0, 0, 1], angle));
   };
   var clamp = (v, a, b) => Math.max(a, Math.min(b, v));
+  var splitAlong = (box3, count, axis, rnd) => {
+    const shares = Array.from({ length: count }, () => 0.25 + 1.5 * rnd());
+    const total = shares.reduce((sum, share) => sum + share, 0);
+    const out = [];
+    let from = box3.c[axis] - box3.s[axis] / 2;
+    for (const share of shares) {
+      const length = box3.s[axis] * share / total;
+      const c = [box3.c[0], box3.c[1], box3.c[2]];
+      const size = [box3.s[0], box3.s[1], box3.s[2]];
+      c[axis] = from + length / 2;
+      size[axis] = length;
+      out.push({ c, s: size });
+      from += length;
+    }
+    return out;
+  };
   var splinterBox = (inp, box3, limit = inp.maxFragments) => {
     const { rnd } = inp;
     const dims = box3.s;
@@ -11442,35 +11483,81 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const w = Math.max(fmin * 1.5, 0.01);
     const c = clamp(Math.round(dims[a] * dims[b] / (w * w)), 3, Math.max(3, Math.floor(limit / 2)));
     const maxLen = fmax * 4;
-    const cells = bsp(box3, c, [a, b], rnd);
+    const cells = [];
+    for (const cell of bsp(box3, c, [a, b], rnd)) {
+      const wide = cell.s[a] >= cell.s[b] ? a : b;
+      if (rnd() < 0.4 && cell.s[wide] > fmin * 0.5) for (const part of splitAlong(cell, 2, wide, rnd)) cells.push(part);
+      else cells.push(cell);
+    }
     const pieces = [];
     for (const cell of cells) {
-      const extra = rnd() < 0.4 ? 1 : 0;
+      const extra = Math.floor(rnd() * 3);
       const k = Math.max(1, Math.ceil(dims[g] / maxLen)) + extra;
-      for (const p of bsp(cell, k, [g], rnd)) pieces.push(p);
+      for (const p of splitAlong(cell, k, g, rnd)) pieces.push(p);
     }
     return pieces.slice(0, limit).map((p) => ({ center: p.c, size: [p.s[g], p.s[a], p.s[b]], q: frame(g, a, b), shape: "splinter", weight: p.s[0] * p.s[1] * p.s[2] }));
   };
+  var PLY = 3e-3;
+  var PLY_GAP = 0.6;
+  var PLY_SHEET = 0.012;
+  var plyBreak = (inp, root, limit) => {
+    const { rnd } = inp;
+    const dims = root.s;
+    const sorted = [0, 1, 2].sort((x, y) => dims[x] - dims[y]);
+    const t = sorted[0];
+    const [u, v] = [sorted[1], sorted[2]].sort((x, y) => x - y);
+    const along = dims[u] >= dims[v] ? u : v;
+    const across = along === u ? v : u;
+    const layers = clamp(Math.round(dims[t] / PLY / 2), 2, 3);
+    const pitch = dims[t] / layers;
+    const th = Math.min(pitch, PLY_SHEET);
+    const per = Math.max(2, Math.floor(limit / layers));
+    const out = [];
+    for (let k = 0; k < layers; k++) {
+      const layer = { c: [root.c[0], root.c[1], root.c[2]], s: [dims[0], dims[1], dims[2]] };
+      layer.c[t] = root.c[t] + (-dims[t] / 2 + (k + 0.5) * pitch) * (pitch > PLY_SHEET ? 1 : 1 + PLY_GAP);
+      layer.s[t] = th;
+      for (const cell of bsp(layer, per, [u, v], rnd)) {
+        if (out.length >= limit) return out;
+        if (rnd() < 0.35) {
+          const strand = cell.s[across] * (0.15 + 0.2 * rnd());
+          out.push({ center: cell.c, size: [cell.s[along], strand, th * 0.7], q: frame(along, across, t), shape: "splinter", weight: cell.s[along] * strand * th });
+        } else {
+          out.push({ center: cell.c, size: [cell.s[u], cell.s[v], th], q: frame(u, v, t, (rnd() - 0.5) * 0.5), shape: "scrap", weight: cell.s[u] * cell.s[v] * th });
+        }
+      }
+    }
+    return out;
+  };
+  var granules = (inp, box3, count) => bsp(box3, count, [0, 1, 2], inp.rnd).map((b) => ({ center: b.c, size: b.s, q: quat.identity(), shape: "chunk", weight: b.s[0] * b.s[1] * b.s[2] }));
+  var CRUMBS = 6;
   var severAt = (inp, root, at2, gap) => {
     const dims = root.s;
     const L = [0, 1, 2].sort((x, y) => dims[y] - dims[x])[0];
     const half = dims[L] / 2;
     const lo = clamp(at2 - gap / 2, -half, half), hi = clamp(at2 + gap / 2, -half, half);
     const out = [];
-    const stub = (from, to) => {
+    const fibrous = inp.form === "slivers" || inp.form === "plies";
+    const [a, b] = [0, 1, 2].filter((i) => i !== L);
+    const stub = (from, to, breakAtEnd) => {
       if (to - from < 0.02) return;
       const c = [root.c[0], root.c[1], root.c[2]], sz = [dims[0], dims[1], dims[2]];
       c[L] = (from + to) / 2;
       sz[L] = to - from;
-      out.push({ center: c, size: sz, q: quat.identity(), shape: "slab", weight: sz[0] * sz[1] * sz[2] });
+      const weight = sz[0] * sz[1] * sz[2];
+      if (fibrous) out.push({ center: c, size: [sz[L], sz[a], sz[b]], q: frame(L, a, b, breakAtEnd ? 0 : Math.PI), shape: "slab", weight });
+      else out.push({ center: c, size: sz, q: quat.identity(), shape: "slab", weight });
     };
-    stub(-half, lo);
-    stub(hi, half);
+    stub(-half, lo, true);
+    stub(hi, half, false);
     const band = { c: [root.c[0], root.c[1], root.c[2]], s: [dims[0], dims[1], dims[2]] };
     band.c[L] = (lo + hi) / 2;
     band.s[L] = Math.max(hi - lo, 0.01);
-    if (inp.style === "snap") {
-      for (const b of bsp(band, Math.max(3, Math.min(6, inp.maxFragments - out.length)), [0, 1, 2], inp.rnd)) out.push({ center: b.c, size: b.s, q: quat.identity(), shape: "chunk", weight: b.s[0] * b.s[1] * b.s[2] });
+    const room = inp.maxFragments - out.length;
+    if (inp.style === "snap" && inp.form === "plies") for (const p of plyBreak(inp, band, Math.max(3, room))) out.push(p);
+    else if (inp.style === "snap" && inp.form === "granules") for (const p of granules(inp, band, clamp(room, 3, 12))) out.push(p);
+    else if (inp.style === "snap") {
+      for (const b2 of bsp(band, Math.max(3, Math.min(6, room)), [0, 1, 2], inp.rnd)) out.push({ center: b2.c, size: b2.s, q: quat.identity(), shape: "chunk", weight: b2.s[0] * b2.s[1] * b2.s[2] });
     } else for (const p of splinterBox(inp, band, Math.max(3, inp.maxFragments - out.length))) out.push(p);
     return out;
   };
@@ -11503,8 +11590,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const [u, v] = [sorted[1], sorted[2]].sort((a, b) => a - b);
     if (style === "snap") {
       if (inp.cut) return severAt(inp, root, inp.cut.at, inp.cut.gap);
+      if (inp.form === "plies") return plyBreak(inp, root, maxFragments);
       const n2 = Math.min(maxFragments, 2 + Math.floor(rnd() * 3));
       for (const b of bsp(root, n2, [0, 1, 2], rnd)) out.push({ center: b.c, size: b.s, q: idq, shape: "slab", weight: b.s[0] * b.s[1] * b.s[2] });
+      if (inp.form !== "granules") return out;
+      const crumbs = Math.min(CRUMBS, maxFragments - out.length);
+      if (crumbs <= 0) return out;
+      const band = { c: [0, 0, 0], s: [0, 0, 0] };
+      for (let i = 0; i < 3; i++) {
+        band.s[i] = Math.min(dims[i], Math.max(fmin, dims[i] * 0.2));
+        band.c[i] = clamp(inp.hit[i], -dims[i] / 2 + band.s[i] / 2, dims[i] / 2 - band.s[i] / 2);
+      }
+      for (const p of granules(inp, band, crumbs)) out.push({ ...p, weight: p.weight * 0.5 });
       return out;
     }
     if (style === "crumble" || style === "none") {
@@ -11611,6 +11708,88 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     }
     return marks;
   };
+  var JOINT_GAP = 1e-4;
+  var MIN_BEARING_SHARE = 0.25;
+  var unsupportedCells = (cells, thin, dims, standing) => {
+    if (thin === 1) return [];
+    const [u, v] = planeAxes(thin);
+    const bottom = -dims[v] / 2;
+    const rowOf = (y) => Math.round((y - bottom) * 1e4);
+    const rows = /* @__PURE__ */ new Map();
+    for (let i = 0; i < cells.length; i++) {
+      if (!standing(i)) continue;
+      const cell = cells[i];
+      const key = rowOf(cell.center[v] - cell.size[v] / 2);
+      const row = rows.get(key);
+      if (row) row.push(i);
+      else rows.set(key, [i]);
+    }
+    const held = /* @__PURE__ */ new Set();
+    const queue = [];
+    for (const i of rows.get(0) ?? []) {
+      held.add(i);
+      queue.push(i);
+    }
+    const overlap = (a, b) => Math.min(a.center[u] + a.size[u] / 2, b.center[u] + b.size[u] / 2) - Math.max(a.center[u] - a.size[u] / 2, b.center[u] - b.size[u] / 2);
+    const climb = () => {
+      while (queue.length > 0) {
+        const cell = cells[queue.pop()];
+        for (const j of rows.get(rowOf(cell.center[v] + cell.size[v] / 2)) ?? []) {
+          const other = cells[j];
+          if (held.has(j) || overlap(cell, other) <= Math.max(JOINT_GAP, MIN_BEARING_SHARE * Math.min(cell.size[u], other.size[u]))) continue;
+          held.add(j);
+          queue.push(j);
+        }
+      }
+    };
+    for (const row of rows.values()) row.sort((a, b) => cells[a].center[u] - cells[b].center[u]);
+    const touching = (a, b) => Math.abs(a.center[u] + a.size[u] / 2 - (b.center[u] - b.size[u] / 2)) <= 1e-3;
+    for (let wedged = true; wedged; ) {
+      climb();
+      wedged = false;
+      for (const row of rows.values()) {
+        for (let k = 1; k < row.length - 1; k++) {
+          const i = row[k];
+          if (held.has(i) || !held.has(row[k - 1]) || !held.has(row[k + 1])) continue;
+          if (!touching(cells[row[k - 1]], cells[i]) || !touching(cells[i], cells[row[k + 1]])) continue;
+          held.add(i);
+          queue.push(i);
+          wedged = true;
+        }
+      }
+    }
+    const loose = [];
+    for (const row of rows.values()) for (const i of row) if (!held.has(i)) loose.push(i);
+    return loose;
+  };
+  var clumpCells = (cells, thin, cap) => {
+    if (cells.length <= cap) return [...cells];
+    const [u, v] = planeAxes(thin);
+    let lo0 = Infinity, lo1 = Infinity, hi0 = -Infinity, hi1 = -Infinity;
+    for (const cell of cells) {
+      lo0 = Math.min(lo0, cell.center[u] - cell.size[u] / 2);
+      hi0 = Math.max(hi0, cell.center[u] + cell.size[u] / 2);
+      lo1 = Math.min(lo1, cell.center[v] - cell.size[v] / 2);
+      hi1 = Math.max(hi1, cell.center[v] + cell.size[v] / 2);
+    }
+    let side = Math.sqrt((hi0 - lo0) * (hi1 - lo1) / cap);
+    for (; ; ) {
+      const bins = /* @__PURE__ */ new Map();
+      for (const cell of cells) {
+        const key = `${Math.floor((cell.center[u] - lo0) / side)}:${Math.floor((cell.center[v] - lo1) / side)}`;
+        const bin = bins.get(key) ?? { lo: [Infinity, Infinity, Infinity], hi: [-Infinity, -Infinity, -Infinity] };
+        for (let k = 0; k < 3; k++) {
+          bin.lo[k] = Math.min(bin.lo[k], cell.center[k] - cell.size[k] / 2);
+          bin.hi[k] = Math.max(bin.hi[k], cell.center[k] + cell.size[k] / 2);
+        }
+        bins.set(key, bin);
+      }
+      if (bins.size <= cap) {
+        return [...bins.values()].map(({ lo, hi }) => ({ center: [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2], size: [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]] }));
+      }
+      side *= 1.25;
+    }
+  };
   var MAX_SPALLS = 64;
   var thinAxisOf = (dims) => dims[0] <= dims[1] && dims[0] <= dims[2] ? 0 : dims[1] <= dims[2] ? 1 : 2;
   var resolveLayer = (def, index, mat) => ({ index, def, mat, energy: mat.penetration * def.thickness * 1e3 });
@@ -12590,6 +12769,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "wood_soft",
+      splitForm: "slivers",
       density: 500,
       hpPerKg: 90,
       penetration: 9,
@@ -12635,6 +12815,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "wood_hard",
+      splitForm: "slivers",
       density: 750,
       hpPerKg: 140,
       penetration: 14,
@@ -12679,6 +12860,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "plywood",
+      splitForm: "plies",
       density: 600,
       hpPerKg: 70,
       penetration: 7,
@@ -12726,6 +12908,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "mdf",
+      splitForm: "granules",
       density: 750,
       hpPerKg: 45,
       penetration: 6,
@@ -13237,6 +13420,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     },
     {
       id: "green_wood",
+      splitForm: "slivers",
       density: 650,
       hpPerKg: 5,
       penetration: 10,
@@ -13517,6 +13701,125 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         "brittle"
       ],
       compressive: 1e5
+    },
+    {
+      id: "mud",
+      density: 1700,
+      hpPerKg: 1,
+      penetration: 5,
+      ductility: 0.8,
+      fracture: "crumble",
+      fragmentSize: [
+        0.02,
+        0.08
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.5,
+        heatCapacity: 3.2
+      },
+      tags: [
+        "soil",
+        "wet"
+      ],
+      compressive: 5e3
+    },
+    {
+      id: "clay",
+      density: 1800,
+      hpPerKg: 5,
+      penetration: 7,
+      ductility: 0.05,
+      fracture: "crumble",
+      fragmentSize: [
+        0.02,
+        0.1
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.2
+      },
+      tags: [
+        "soil",
+        "brittle"
+      ],
+      compressive: 6e4
+    },
+    {
+      id: "snow",
+      density: 300,
+      hpPerKg: 1,
+      penetration: 3,
+      ductility: 0.6,
+      fracture: "crumble",
+      fragmentSize: [
+        0.01,
+        0.05
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2.1
+      },
+      tags: [
+        "soil",
+        "frozen"
+      ],
+      compressive: 1e3
+    },
+    {
+      id: "cobble",
+      density: 2650,
+      hpPerKg: 25,
+      penetration: 25,
+      penetrationClass: "concrete",
+      penetrationScale: 0.9,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.05,
+        0.15
+      ],
+      hitDebris: "chips",
+      breakDebris: "chips",
+      thermal: {
+        conductivity: 0.2,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 3e5
+    },
+    {
+      id: "paver",
+      density: 2300,
+      hpPerKg: 14,
+      penetration: 18,
+      penetrationClass: "concrete",
+      penetrationScale: 1,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.04,
+        0.12
+      ],
+      hitDebris: "chips",
+      breakDebris: "chips",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 35e4
     }
   ];
   var material_hints_default = {
@@ -13729,6 +14032,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   var BREACH_BLAST_FACTOR = 6;
   var BREACH_AREA = 0.25;
   var BREACH_BLAST_REACH = 0.12;
+  var MEMBER_CUT_REACH = 0.5;
+  var BLAST_REFERENCE_RESISTANCE = 200 * 1900 * 0.13;
+  var BLAST_EDGE_RAGGED = 0.3;
+  var BLAST_EDGE_LOOSE = 1.35;
+  var BLAST_EDGE_WEAR = 0.6;
   var RESIDUAL_CAPACITY = 0.15;
   var SEVER_BAND = 0.1;
   var SEVER_ASPECT = 3;
@@ -14981,7 +15289,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (j.st.open) continue;
         if (j.spec.kind === "rebar" && (isReinforced(o.parts[j.ia].spec) || isReinforced(o.parts[j.ib].spec))) continue;
         if (near && jointReach(o, j, near) > Math.max(radius, jointReachLimit(o, j))) continue;
-        j.st.hp -= span === void 0 ? amount : amount * Math.min(1, span / Math.max(jointLength(o, j), 1e-6));
+        j.st.hp -= span === void 0 ? amount : Math.min(amount, j.st.maxHp) * Math.min(1, span / Math.max(jointLength(o, j), 1e-6));
         if (j.st.hp <= 0) {
           j.st.hp = 0;
           j.st.open = true;
@@ -15109,6 +15417,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const worn = (_a = p.rt).chips ?? (_a.chips = {});
       const cut = (_b = p.rt).craters ?? (_b.craters = {});
       const out = [];
+      const wholeBefore = Object.values(worn).filter((w) => w === -1).length;
       const shot = kind === "ballistic";
       for (let i = 0; i < grid.length; i++) {
         const cell = grid[i];
@@ -15167,6 +15476,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         emit({ ...base(o, src), type: "chip", part: p.spec.id, center, size: [cell.size[0], cell.size[1], cell.size[2]], rotation: q, fragments });
         debris(o, p, p.mat.breakDebris, center, vec.scale(dir ?? [0, 1, 0], -1), 6, 2, src);
       }
+      if (Object.values(worn).filter((w) => w === -1).length > wholeBefore) dropUnsupported(o, p, src);
       if (p.spec.reinforcement) exposeRebar(o, p, src);
       for (const cell of out) addBreach(o, p, toWorld(c, q, cell.center), cell.size[u] * cell.size[v], energy, dir, src);
       if (p.structural && !isLost(p)) {
@@ -15270,10 +15580,122 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       setStage(o, p, 1, {}, src);
       setStage(o, p, 2, { opening: { center: worldCenter, radius }, fragments }, src);
       debris(o, p, p.mat.breakDebris, worldCenter, vec.scale(dir ?? [0, 1, 0], -1), 14, 3, src);
+      dropUnsupported(o, p, src);
       const reinforcement = p.spec.reinforcement;
       if (reinforcement) exposeRebar(o, p, src);
       if (p.structural) solveStructure(o);
     };
+    const blastReachOf = (p, energy) => {
+      const perKg = p.mat.hits?.blunt?.unitJoules ?? chipEnergy;
+      const resistance = Math.max(1, perKg * p.mat.density * p.thickness);
+      return BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3) * clamp2(Math.cbrt(BLAST_REFERENCE_RESISTANCE / resistance), 0.3, 2);
+    };
+    const blastUnits = (o, p, wp, energy, dist, src) => {
+      var _a, _b;
+      if (!p.staged || p.st.stripped || isLost(p) || chipEnergy <= 0) return false;
+      const reach = blastReachOf(p, energy);
+      if (dist >= reach) return false;
+      const radius = Math.sqrt(reach * reach - dist * dist);
+      const [u, v] = planeAxes(p.thin);
+      const lp = toLocal(p.pos, p.q, objLocal(o, wp));
+      const op = p.st.opening ? toLocal(p.pos, p.q, p.st.opening.center) : null;
+      const grid = gridOf(p);
+      const worn = (_a = p.rt).chips ?? (_a.chips = {});
+      const perKg = p.mat.hits?.blunt?.unitJoules ?? chipEnergy;
+      const lobes = [rnd() * 2 * Math.PI, rnd() * 2 * Math.PI];
+      const out = [];
+      for (let i = 0; i < grid.length; i++) {
+        const cell = grid[i];
+        if (worn[i] === -1) continue;
+        if (op && p.st.opening && Math.hypot(cell.center[u] - op[u], cell.center[v] - op[v]) <= p.st.opening.radius) continue;
+        const du = cell.center[u] - lp[u], dv = cell.center[v] - lp[v];
+        const angle = Math.atan2(dv, du);
+        const edge = radius * (1 + BLAST_EDGE_RAGGED * (0.5 * Math.sin(3 * angle + lobes[0]) + 0.3 * Math.sin(5 * angle + lobes[1]) + 0.4 * (rnd() - 0.5)));
+        const d = Math.hypot(du, dv);
+        if (d <= edge) {
+          worn[i] = -1;
+          out.push(i);
+        } else if (d <= edge * BLAST_EDGE_LOOSE) {
+          const mass = p.mat.density * cell.size[0] * cell.size[1] * cell.size[2];
+          worn[i] = Math.max(worn[i] ?? 0, perKg * mass * BLAST_EDGE_WEAR);
+        }
+      }
+      if (out.length === 0) return false;
+      const loose = unsupportedCells(grid, p.thin, p.dims, (i) => worn[i] !== -1 && !(op && p.st.opening && Math.hypot(grid[i].center[u] - op[u], grid[i].center[v] - op[v]) <= p.st.opening.radius));
+      for (const i of loose) worn[i] = -1;
+      const blown = out.map((i) => grid[i]), fallen = loose.map((i) => grid[i]);
+      const volume = (cells2) => cells2.reduce((sum, cell) => sum + cell.size[0] * cell.size[1] * cell.size[2], 0);
+      const blownMass = Math.min(p.st.mass, p.mat.density * volume(blown));
+      const fallenMass = Math.min(p.st.mass - blownMass, p.mat.density * volume(fallen));
+      const speed = clamp2(Math.sqrt(2 * energy * 0.02 / Math.max(blownMass, 0.05)), 1, 12);
+      const { c, q } = partXf(o, p);
+      const chipped = (_b = p.st).chipped ?? (_b.chipped = []);
+      const tag = `x${chipped.length}_`;
+      const fragments = [
+        ...cellFragments(o, p, clumpCells(blown, p.thin, maxFragments), wp, null, speed, blownMass, tag, true),
+        ...fallen.length > 0 ? cellFragments(o, p, clumpCells(fallen, p.thin, Math.max(2, Math.round(maxFragments / 4))), wp, null, 0.3, fallenMass, `${tag}f`, true) : []
+      ];
+      const cells = [...blown, ...fallen];
+      const holes = localHolesOf(p);
+      p.st.holes = p.st.holes.filter((_, k) => !cells.some((cell) => marksInBox(cell.center, cell.size, void 0, [holes[k]]).length > 0));
+      const lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+      for (const cell of cells) {
+        chipped.push({ center: [cell.center[0], cell.center[1], cell.center[2]], size: [cell.size[0], cell.size[1], cell.size[2]] });
+        for (let k = 0; k < 3; k++) {
+          lo[k] = Math.min(lo[k], cell.center[k] - cell.size[k] / 2);
+          hi[k] = Math.max(hi[k], cell.center[k] + cell.size[k] / 2);
+        }
+      }
+      p.st.mass = Math.max(0, p.st.mass - blownMass - fallenMass);
+      p.rt.removed = (p.rt.removed ?? 0) + blownMass + fallenMass;
+      markDamaged(p);
+      setStage(o, p, 1, {}, src);
+      const center = toWorld(c, q, [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2]);
+      const units = cells.map((cell) => ({ center: toWorld(c, q, cell.center), size: [cell.size[0], cell.size[1], cell.size[2]] }));
+      emit({ ...base(o, src), type: "chip", part: p.spec.id, center, size: [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]], rotation: q, fragments, units });
+      debris(o, p, p.mat.breakDebris, center, vec.normalize(vec.sub(center, wp), [0, 1, 0]), 14, 3, src);
+      if (p.spec.reinforcement) exposeRebar(o, p, src);
+      if (p.structural && !isLost(p)) {
+        solveStructure(o);
+        collapseCheck(o, src);
+      }
+      return true;
+    };
+    const dropUnsupported = (o, p, src) => {
+      var _a, _b;
+      if (!p.spec.units || p.spec.units.mortar === p.spec.material || p.st.stripped || isLost(p)) return 0;
+      const [u, v] = planeAxes(p.thin);
+      const grid = gridOf(p);
+      const worn = (_a = p.rt).chips ?? (_a.chips = {});
+      const op = p.st.opening ? toLocal(p.pos, p.q, p.st.opening.center) : null;
+      const opened = (cell) => !!op && !!p.st.opening && Math.hypot(cell.center[u] - op[u], cell.center[v] - op[v]) <= p.st.opening.radius;
+      const loose = unsupportedCells(grid, p.thin, p.dims, (i) => worn[i] !== -1 && !opened(grid[i]));
+      if (loose.length === 0) return 0;
+      for (const i of loose) worn[i] = -1;
+      const fallen = loose.map((i) => grid[i]);
+      const mass = Math.min(p.st.mass, p.mat.density * fallen.reduce((sum, cell) => sum + cell.size[0] * cell.size[1] * cell.size[2], 0));
+      const { c, q } = partXf(o, p);
+      const chipped = (_b = p.st).chipped ?? (_b.chipped = []);
+      const lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+      for (const cell of fallen) {
+        for (let k = 0; k < 3; k++) {
+          lo[k] = Math.min(lo[k], cell.center[k] - cell.size[k] / 2);
+          hi[k] = Math.max(hi[k], cell.center[k] + cell.size[k] / 2);
+        }
+      }
+      const center = toWorld(c, q, [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2]);
+      const fragments = cellFragments(o, p, clumpCells(fallen, p.thin, Math.max(2, Math.round(maxFragments / 4))), vec.add(center, [0, 1, 0]), null, 0.3, mass, `u${chipped.length}_`, true);
+      const holes = localHolesOf(p);
+      p.st.holes = p.st.holes.filter((_, k) => !fallen.some((cell) => marksInBox(cell.center, cell.size, void 0, [holes[k]]).length > 0));
+      for (const cell of fallen) chipped.push({ center: [cell.center[0], cell.center[1], cell.center[2]], size: [cell.size[0], cell.size[1], cell.size[2]] });
+      p.st.mass = Math.max(0, p.st.mass - mass);
+      p.rt.removed = (p.rt.removed ?? 0) + mass;
+      markDamaged(p);
+      const units = fallen.map((cell) => ({ center: toWorld(c, q, cell.center), size: [cell.size[0], cell.size[1], cell.size[2]] }));
+      emit({ ...base(o, src), type: "chip", part: p.spec.id, center, size: [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]], rotation: q, fragments, units });
+      debris(o, p, p.mat.breakDebris, center, [0, -1, 0], 6, 1, src);
+      return loose.length;
+    };
     const stripPart = (o, p, reinforcement, src) => {
       const bars = rebarBars(p.dims, p.thin, reinforcement.spacing);
       p.st.stripped = true;
@@ -15340,6 +15762,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const unitPlan = p.spec.units ? unitFragmentPlan(p, maxFragments * UNIT_FRAGMENT_FACTOR) : [];
       const axis = style === "splinter" || style === "snap" ? severAxis(p) : -1;
       const cutAt2 = axis < 0 ? void 0 : p.rt.cutAt ?? (origin ? hitLocal[axis] : void 0);
+      const planRnd = p.mat.splitForm ? splitStream(o.id, p.spec.id, hitLocal) : rnd;
       const plan = unitPlan.length > 0 ? unitPlan : planFragments({
         style,
         dims: p.dims,
@@ -15348,8 +15771,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         hit: hitLocal,
         fragmentSize: p.mat.fragmentSize ?? [0.04, 0.2],
         maxFragments,
-        rnd,
+        rnd: planRnd,
         sheet: p.mat.sheet,
+        ...p.mat.splitForm ? { form: p.mat.splitForm } : {},
         ...cutAt2 !== void 0 ? { cut: { at: cutAt2, gap: SEVER_BAND } } : {}
       });
       const holes = p.st.holes.length > 0 ? localHolesOf(p) : [];
@@ -15488,7 +15912,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const fragments = [];
       for (let i = 0; i < n; i++) {
         const back = !exit || i % 3 === 2;
-        const len = scale * (fibre ? 1.2 + 1.2 * rnd() : 3 + 4 * rnd()), w = scale * (0.8 + 0.8 * rnd()), t = scale * (fibre ? 0.7 + 0.6 * rnd() : 0.4 + 0.4 * rnd());
+        const plies = p.mat.splitForm === "plies";
+        const len = scale * (fibre ? 1.2 + 1.2 * rnd() : 3 + 4 * rnd()), w = scale * (0.8 + 0.8 * rnd()), t = scale * (fibre ? 0.7 + 0.6 * rnd() : plies ? 0.15 + 0.15 * rnd() : 0.4 + 0.4 * rnd());
         const size = [w, w, w];
         size[along] = len;
         size[(along + 1) % 3] = w;
@@ -15649,7 +16074,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           checkIgnite(o, p, src);
         }
       }
-      wearJoints(o, p, Ein * 0.5, void 0, 0, src);
+      wearJoints(o, p, Ein * 0.5, void 0, 0, src, false, 2 * BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3));
       const amount = Ein * DMG_PER_J * (mat.damageScale?.explosive ?? 1);
       if (blastFrontSpeed > 0 && dist > 0 && mat.tags?.includes("glass")) {
         frontQueue.push({ o, p, due: time + dist / blastFrontSpeed, amount, fragEnergy: Ein * 0.3, point, ...src !== void 0 ? { src } : {} });
@@ -15659,7 +16084,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const dealt = applyDamage(o, p, amount, "explosive", point, null, Ein * 0.3, 40, src);
       res.damage += dealt;
       if (p.bend && flexure.enabled) bendByBlast(o, p, point, energy, radius, reach, src);
-      if (dist <= BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3)) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
+      const breachReach = BREACH_BLAST_REACH * Math.cbrt(Math.max(0, energy) / 1e3);
+      if (p.spec.units && p.spec.units.mortar !== p.spec.material) blastUnits(o, p, wp, energy, dist, src);
+      else if (p.spec.reinforcement && p.spec.units && dist > MEMBER_CUT_REACH * breachReach) blastUnits(o, p, wp, energy, dist, src);
+      else if (dist <= breachReach) addBreach(o, p, wp, breachAreaOf(p, dealt, true), Ein, null, src);
       return reach;
     };
     const blastProbe = { partsTested: 0, partsNear: 0 };
@@ -15905,6 +16333,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       }
       return h | 0;
     };
+    const splitStream = (objectId, partId, hit) => {
+      const codes = Array.from(`${objectId}|${partId}`, (char) => char.charCodeAt(0) / 1e3);
+      const stream = createRng(seedOf2(rng2.state() / 1e3, ...codes, hit[0], hit[1], hit[2]));
+      return () => stream.next();
+    };
     const throwFragment = (frag, objectId, from, g, centre, index, src, shields, results, reports, mult) => {
       const v = frag.velocity;
       const speed = Math.hypot(v[0], v[1], v[2]);
@@ -17321,12 +17754,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       builder,
       porchRoofOnPostsOnly: options.porchRoofOnPostsOnly,
       rafterRoof: options.rafterRoof,
+      wallPillarSpacing: options.wallPillarSpacing,
+      visorSections: options.visorSections,
       floorCount: floorCount2,
       isUnit,
       elevation,
       isTimber: system.timber,
       walls: [],
       wallParts: /* @__PURE__ */ new Map(),
+      groundBeams: /* @__PURE__ */ new Map(),
       carriers: /* @__PURE__ */ new Map(),
       plates: /* @__PURE__ */ new Map(),
       pillars: /* @__PURE__ */ new Map(),
@@ -17397,7 +17833,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         builder.rest(deck, base, system.joints.slab);
         continue;
       }
-      const pillar = builder.add({ id: `balcony_column_${room.id}`, role: "column", material: construction.frame.pillars, aabb: [box22[0] - 0.08, box22[1] - 0.08, box22[0] + 0.08, box22[1] + 0.08], y0: 0, y1: context.level(floor) - system.slabThickness }, { floor: 0 });
+      const half = context.visorSections ? 0.08 : 0.1;
+      const pillar = builder.add({ id: `balcony_column_${room.id}`, role: "column", material: construction.frame.pillars, aabb: [box22[0] - half, box22[1] - half, box22[0] + half, box22[1] + half], y0: 0, y1: context.level(floor) - system.slabThickness }, { floor: 0 });
       builder.rest(pillar, GROUND, "rebar");
       builder.rest(deck, pillar, "rebar");
     }
@@ -17462,8 +17899,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const top = context.level(floor) - thickness * 0.15;
     const out = [];
     for (let k = 0; k < count; k++) {
-      const centre = (alongU ? box22[0] : box22[1]) + 0.05 + k * (span - 0.1) / (count - 1);
-      const aabb = alongU ? [centre - 0.025, box22[1], centre + 0.025, box22[3]] : [box22[0], centre - 0.025, box22[2], centre + 0.025];
+      const centre2 = (alongU ? box22[0] : box22[1]) + 0.05 + k * (span - 0.1) / (count - 1);
+      const aabb = alongU ? [centre2 - 0.025, box22[1], centre2 + 0.025, box22[3]] : [box22[0], centre2 - 0.025, box22[2], centre2 + 0.025];
       const joist = context.builder.add({ id: `joist_${floor}${suffix}_${k}`, role: "beam", material, aabb, y0: context.level(floor) - thickness, y1: top }, { floor, fill: 1, spacing: JOIST_PITCH });
       out.push(joist);
       const below = carriers.filter((carrier) => carrier.y0 <= top + 0.05);
@@ -17551,8 +17988,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const at2 = alongU ? box22[1] + line * (box22[3] - box22[1]) / (rows - 1) : box22[0] + line * (box22[2] - box22[0]) / (columns - 1);
       const aabb = alongU ? [box22[0], at2 - 0.07, box22[2], at2 + 0.07] : [at2 - 0.07, box22[1], at2 + 0.07, box22[3]];
       const beam = builder.add({ id: `base_beam_${line}`, role: "beam", material: construction.frame.timber, aabb, y0: height, y1: elevation - context.system.slabThickness }, { floor: 0 });
-      const centre = (q) => alongU ? (q.aabb[1] + q.aabb[3]) / 2 : (q.aabb[0] + q.aabb[2]) / 2;
-      for (const pier of piers.filter((q) => Math.abs(centre(q) - at2) < 0.05)) builder.rest(beam, pier, "bolt");
+      const centre2 = (q) => alongU ? (q.aabb[1] + q.aabb[3]) / 2 : (q.aabb[0] + q.aabb[2]) / 2;
+      for (const pier of piers.filter((q) => Math.abs(centre2(q) - at2) < 0.05)) builder.rest(beam, pier, "bolt");
       beams.push(beam);
     }
     return beams;
@@ -17572,17 +18009,110 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     else if (type === "crawl_space" || type === "piles" || type === "basement") addRaisedFloor(context);
     else if (context.isTimber && type !== "ground") context.base0 = raft(context, Math.max(0.12, context.elevation), "concrete");
   }
+  var GROUND_BEAM_DEPTH = 0.3;
+  function addGroundBeams(context) {
+    const { builder, construction } = context;
+    if (construction.system !== "masonry" || context.isUnit || construction.foundation.type !== "strip_footing") return;
+    const top = context.level(0);
+    for (const wall of context.walls) {
+      if (wall.floor !== 0 || wall.type !== "wall") continue;
+      const beam = builder.add({ id: `ground_beam_${context.groundBeams.size}`, role: "beam", material: construction.frame.beams, aabb: wall.box, y0: top - GROUND_BEAM_DEPTH, y1: top }, { floor: 0, beamKind: "ground_beam" });
+      builder.rest(beam, GROUND, "rebar");
+      context.groundBeams.set(wall.id, beam);
+    }
+  }
+  var WALL_PILLAR_SPACING = 4;
+  var WALL_PILLAR_SIDE = 0.2;
+  var MERGE_DISTANCE = 0.45;
+  var HALF = WALL_PILLAR_SIDE / 2;
+  var TOLERANCE = 0.03;
+  var alongRange = (wall) => wall.axis === "u" ? [Math.min(wall.u0, wall.u1), Math.max(wall.u0, wall.u1)] : [Math.min(wall.v0, wall.v1), Math.max(wall.v0, wall.v1)];
+  var acrossOf = (wall) => wall.axis === "u" ? wall.v0 : wall.u0;
+  function stretchesOf(context, wall) {
+    const [low, high] = alongRange(wall);
+    const windows = (context.source.windows ?? []).filter((w) => w.floor === wall.floor && w.axis === wall.axis && Math.abs(w.pos - acrossOf(wall)) <= TOLERANCE && w.at + w.width / 2 > low && w.at - w.width / 2 < high).map((w) => [w.at - w.width / 2, w.at + w.width / 2]).sort((a, b) => a[0] - b[0]);
+    const out = [];
+    let cursor = low;
+    for (const [from, to] of windows) {
+      if (from - cursor > TOLERANCE) out.push({ wall, from: cursor, to: from });
+      cursor = Math.max(cursor, to);
+    }
+    if (high - cursor > TOLERANCE) out.push({ wall, from: cursor, to: high });
+    return out;
+  }
+  function junctionsOf(context, wall) {
+    const [low, high] = alongRange(wall);
+    const line = acrossOf(wall);
+    const out = [];
+    for (const other of context.walls) {
+      if (other === wall || other.floor !== wall.floor || other.axis === wall.axis || other.type !== "wall") continue;
+      const at2 = acrossOf(other);
+      const [a, b] = alongRange(other);
+      const meets = Math.abs(a - line) <= (wall.thickness ?? 0.15) / 2 + TOLERANCE || Math.abs(b - line) <= (wall.thickness ?? 0.15) / 2 + TOLERANCE;
+      if (meets && at2 > low + HALF && at2 < high - HALF) out.push(at2);
+    }
+    return out;
+  }
+  function pillarStations(from, to, junctions, spacing) {
+    const length = to - from;
+    if (length < WALL_PILLAR_SIDE - 1e-6) return [];
+    if (length < 2 * WALL_PILLAR_SIDE) return [(from + to) / 2];
+    if (length < WALL_PILLAR_SIDE + MERGE_DISTANCE) return [from + HALF, to - HALF];
+    const fixed = [from + HALF, ...junctions.filter((at2) => at2 > from + HALF + MERGE_DISTANCE && at2 < to - HALF - MERGE_DISTANCE), to - HALF].sort((a, b) => a - b);
+    const out = [];
+    fixed.forEach((at2, k) => {
+      out.push(at2);
+      const next = fixed[k + 1];
+      if (next === void 0) return;
+      const spans = Math.ceil((next - at2) / spacing - 1e-6);
+      for (let s = 1; s < spans; s++) out.push(at2 + (next - at2) * s / spans);
+    });
+    return out;
+  }
+  function addWallPillars(context, walls, floor, plates, taken, spacing) {
+    const { builder } = context;
+    const pillars = [];
+    const placed = taken.map((p) => [(p.aabb[0] + p.aabb[2]) / 2, (p.aabb[1] + p.aabb[3]) / 2]);
+    const base = context.baseOf(floor);
+    for (const wall of walls) {
+      if (!wall.exterior || wall.type !== "wall") continue;
+      const top = context.wallParts.get(wall.id).y1;
+      const across = acrossOf(wall);
+      const junctions = junctionsOf(context, wall);
+      for (const stretch of stretchesOf(context, wall)) {
+        const standing = (end) => placed.map(([pu, pv]) => wall.axis === "u" ? [pu, pv] : [pv, pu]).find(([a, c]) => Math.abs(c - across) <= TOLERANCE && Math.abs(a - end) < MERGE_DISTANCE + HALF)?.[0];
+        const first = standing(stretch.from);
+        const last = standing(stretch.to);
+        const from = first === void 0 ? stretch.from : Math.min(stretch.from, first - HALF);
+        const to = last === void 0 ? stretch.to : Math.max(stretch.to, last + HALF);
+        for (const along of pillarStations(from, to, junctions, spacing)) {
+          const [u, v] = wall.axis === "u" ? [along, across] : [across, along];
+          const end = Math.abs(along - stretch.from) < Math.abs(along - stretch.to) ? stretch.from : stretch.to;
+          const endPoint = wall.axis === "u" ? [end, across] : [across, end];
+          const isEnd = Math.abs(along - end) <= HALF + TOLERANCE;
+          if (placed.some(([pu, pv]) => Math.hypot(pu - u, pv - v) < MERGE_DISTANCE && (!isEnd || Math.hypot(pu - endPoint[0], pv - endPoint[1]) < MERGE_DISTANCE))) continue;
+          placed.push([u, v]);
+          const box22 = [u - HALF, v - HALF, u + HALF, v + HALF];
+          const pillar = builder.add({ id: `wall_column_${floor}_${pillars.length}`, role: "column", material: context.construction.frame.pillars, aabb: box22, y0: context.level(floor), y1: top }, { floor });
+          builder.rest(pillar, base === GROUND || !base ? GROUND : base, "rebar");
+          for (const plate of plates.filter((p) => touches(p.aabb, box22, 0.01))) builder.rest(plate, pillar, "rebar");
+          pillars.push(pillar);
+        }
+      }
+    }
+    return pillars;
+  }
   var MAX_GAP_WITHIN_RUN = 3.2;
   var POST_SPACING = 2.4;
   var POST_SIDE = 0.05;
   var alongOf = (wall, pick2) => wall.axis === "u" ? pick2(wall.u0, wall.u1) : pick2(wall.v0, wall.v1);
-  var acrossOf = (wall) => wall.axis === "u" ? wall.v0 : wall.u0;
+  var acrossOf2 = (wall) => wall.axis === "u" ? wall.v0 : wall.u0;
   function runsOf(context, walls, floor) {
     const lines = /* @__PURE__ */ new Map();
     for (const wall of walls) {
       if (!wall.exterior || wall.type !== "wall") continue;
       const top = round2(context.wallParts.get(wall.id).y1);
-      const key = `${floor}|${wall.axis}|${acrossOf(wall).toFixed(2)}|${top.toFixed(2)}`;
+      const key = `${floor}|${wall.axis}|${acrossOf2(wall).toFixed(2)}|${top.toFixed(2)}`;
       lines.set(key, [...lines.get(key) ?? [], wall]);
     }
     return [...lines.values()].map((line) => {
@@ -17602,7 +18132,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   function addShackPosts(context, run, plate, floor, index) {
     const first = run.walls[0];
-    const across = acrossOf(first);
+    const across = acrossOf2(first);
     const top = context.wallParts.get(first.id).y1;
     const count = Math.max(1, Math.ceil((run.to - run.from) / POST_SPACING));
     const posts = [];
@@ -17628,7 +18158,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       for (const run of runs) {
         const first = run.walls[0];
         const half = (first.thickness ?? 0.15) / 2;
-        const across = acrossOf(first);
+        const across = acrossOf2(first);
         const top = context.wallParts.get(first.id).y1;
         const aabb = first.axis === "u" ? [run.from - half, across - half, run.to + half, across + half] : [across - half, run.from - half, across + half, run.to + half];
         const material = context.isTimber ? construction.frame.timber : construction.frame.beams;
@@ -17667,7 +18197,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   function addPlatesAndPillars(context, floor) {
     const walls = context.walls.filter((wall) => wall.floor === floor);
     const { plates, pillars } = addPlates(context, walls, floor);
-    if (context.construction.system === "masonry") pillars.push(...addCornerPillars(context, walls, floor, plates));
+    if (context.construction.system === "masonry") {
+      const corners = addCornerPillars(context, walls, floor, plates);
+      pillars.push(...corners);
+      if (context.wallPillarSpacing) pillars.push(...addWallPillars(context, walls, floor, plates, corners, context.wallPillarSpacing));
+    }
     context.pillars.set(floor, pillars);
     context.plates.set(floor, plates);
     const innerBearing = walls.filter((wall) => wall.role === "wall" && !wall.exterior).map((wall) => context.wallParts.get(wall.id));
@@ -17942,21 +18476,21 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     builder.rest(flight, builder.find("basement_slab"), "resting");
     if (context.base0 && context.base0 !== GROUND) builder.rest(flight, context.base0, "nail");
   }
-  var TOLERANCE = 0.02;
+  var TOLERANCE2 = 0.02;
   var DOOR_HEIGHT = 2.1;
   var LINTEL_DEPTH = 0.2;
   var LINTEL_BEARING = 0.2;
   var crossOf = (wall) => wall.axis === "u" ? wall.v0 : wall.u0;
-  var alongRange = (wall) => wall.axis === "u" ? [Math.min(wall.u0, wall.u1), Math.max(wall.u0, wall.u1)] : [Math.min(wall.v0, wall.v1), Math.max(wall.v0, wall.v1)];
+  var alongRange2 = (wall) => wall.axis === "u" ? [Math.min(wall.u0, wall.u1), Math.max(wall.u0, wall.u1)] : [Math.min(wall.v0, wall.v1), Math.max(wall.v0, wall.v1)];
   function findOpenings(context) {
     const openings = [];
     for (const window of context.source.windows ?? []) {
       const from = window.at - window.width / 2;
       const to = window.at + window.width / 2;
       const wall = context.walls.find((w) => {
-        if (w.floor !== window.floor || w.axis !== window.axis || w.type !== "wall" || Math.abs(crossOf(w) - window.pos) > TOLERANCE) return false;
-        const [low, high] = alongRange(w);
-        return from >= low - TOLERANCE && to <= high + TOLERANCE;
+        if (w.floor !== window.floor || w.axis !== window.axis || w.type !== "wall" || Math.abs(crossOf(w) - window.pos) > TOLERANCE2) return false;
+        const [low, high] = alongRange2(w);
+        return from >= low - TOLERANCE2 && to <= high + TOLERANCE2;
       });
       if (!wall) continue;
       const base = context.level(window.floor);
@@ -17971,18 +18505,39 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       const cross = door.axis === "u" ? door.v : door.u;
       const from = along - door.width / 2;
       const to = along + door.width / 2;
-      const beside = context.walls.filter((w) => w.floor === door.floor && w.axis === door.axis && w.type === "wall" && Math.abs(crossOf(w) - cross) <= TOLERANCE && (Math.abs(alongRange(w)[1] - from) <= 0.05 || Math.abs(alongRange(w)[0] - to) <= 0.05));
+      const beside = context.walls.filter((w) => w.floor === door.floor && w.axis === door.axis && w.type === "wall" && Math.abs(crossOf(w) - cross) <= TOLERANCE2 && (Math.abs(alongRange2(w)[1] - from) <= 0.05 || Math.abs(alongRange2(w)[0] - to) <= 0.05));
       if (!beside.length) continue;
       const half = (beside[0].thickness ?? 0.15) / 2;
       const lo = from - LINTEL_BEARING;
       const hi = to + LINTEL_BEARING;
       const box22 = door.axis === "u" ? [lo, cross - half, hi, cross + half] : [cross - half, lo, cross + half, hi];
       const y0 = context.level(door.floor) + DOOR_HEIGHT;
-      const lintel = builder.add({ id: `lintel_${door.id}`, role: "beam", material: system.timber ? construction.frame.timber : "concrete", aabb: box22, y0, y1: y0 + LINTEL_DEPTH }, { floor: door.floor, ...system.timber ? {} : { assembly: "reinforced_concrete" } });
+      const depth = Math.max(LINTEL_DEPTH, (door.width + LINTEL_BEARING) / 10);
+      const lintel = builder.add({ id: `lintel_${door.id}`, role: "beam", material: system.timber ? construction.frame.timber : "concrete", aabb: box22, y0, y1: y0 + depth }, { floor: door.floor, ...system.timber ? {} : { assembly: "reinforced_concrete" } });
       for (const wall of beside) builder.rest(lintel, context.wallParts.get(wall.id), system.joints.beam);
+      const jambs = (context.pillars.get(door.floor) ?? []).filter((pillar) => pillar.material === "concrete" && overlapsInPlan(pillar.aabb, box22) && pillar.y1 >= y0);
+      if (construction.system === "masonry" && hi - lo > WIDE_DOOR) jambs.push(...addJambPillars(context, { door, beside, from, to, cross }, jambs));
+      for (const pillar of jambs) builder.rest(lintel, pillar, "rebar");
       for (const plate of context.plates.get(door.floor) ?? []) if (overlapsInPlan(plate.aabb, box22)) builder.rest(plate, lintel, system.joints.beam);
     }
   }
+  var WIDE_DOOR = 3;
+  var HALF_PILLAR = WALL_PILLAR_SIDE / 2;
+  function addJambPillars(context, gap, standing) {
+    const { builder, construction } = context;
+    const top = Math.max(...gap.beside.map((w) => context.wallParts.get(w.id).y1));
+    const base = context.baseOf(gap.door.floor);
+    const out = [];
+    for (const [k, along] of [[0, gap.from - HALF_PILLAR], [1, gap.to + HALF_PILLAR]]) {
+      const [u, v] = gap.door.axis === "u" ? [along, gap.cross] : [gap.cross, along];
+      const box22 = [u - HALF_PILLAR, v - HALF_PILLAR, u + HALF_PILLAR, v + HALF_PILLAR];
+      if (standing.some((p) => overlapsInPlan(p.aabb, box22))) continue;
+      const pillar = builder.add({ id: `jamb_column_${gap.door.id}_${k}`, role: "column", material: construction.frame.pillars, aabb: box22, y0: context.level(gap.door.floor), y1: top }, { floor: gap.door.floor });
+      builder.rest(pillar, base === GROUND || !base ? GROUND : base, "rebar");
+      out.push(pillar);
+    }
+    return out;
+  }
   var overlapsInPlan = (a, b) => a[0] < b[2] && a[2] > b[0] && a[1] < b[3] && a[3] > b[1];
   var RISER = 0.18;
   var TREAD = 0.28;
@@ -18154,10 +18709,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const framed = system.studs !== void 0 && !isRailing;
     const part = builder.add(
       { id: wall.id, role: wall.role, material: wall.material, aabb: wall.box, y0, y1: Math.max(y1, y0 + 0.2) },
-      { floor, fill: context.isTimber && wall.role === "wall" ? system.wallFill : 1, ...framed ? { studs: system.studs } : {}, ...isRailing ? {} : { assembly: assemblyOf(context) } }
+      { floor, fill: context.isTimber && wall.role === "wall" ? system.wallFill : 1, ...framed ? { studs: system.studs } : {}, ...isRailing ? {} : { assembly: assemblyOf(context) }, ...wall.exterior && !isRailing ? { exterior: true } : {} }
     );
     context.wallParts.set(wall.id, part);
-    const base = isRailing ? railingBase(context, wall, floor) : context.baseOf(floor);
+    const base = isRailing ? railingBase(context, wall, floor) : context.groundBeams.get(wall.id) ?? context.baseOf(floor);
     const joint = isRailing ? "nail" : system.joints.wall;
     if (base === GROUND || floor === 0 && !base) builder.rest(part, GROUND, joint);
     else if (base) builder.rest(part, base, joint);
@@ -18173,6 +18728,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       addUpperFloor(context, floor);
     }
   }
+  var wallPillarSpacingOf = (options) => {
+    const pillars = options.wallPillars ?? true;
+    if (pillars === false) return 0;
+    return pillars === true ? WALL_PILLAR_SPACING : pillars.spacing ?? WALL_PILLAR_SPACING;
+  };
   function buildStructure(source, options = {}) {
     const refined = options.wallDetail !== "coarse";
     const built = options.construction ? { construction: options.construction, extras: options.extras ?? {} } : resolveConstruction(source);
@@ -18180,8 +18740,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const extras = options.extras ?? built.extras ?? {};
     if (construction.system === "canvas") return buildCanvasStructure(construction, extras);
     const tank = options.tank !== void 0 ? options.tank : source.waterTank ?? null;
-    const context = createContext(source, construction, extras, tank, { porchRoofOnPostsOnly: options.porchRoofOnPostsOnly ?? refined, rafterRoof: options.rafterRoof ?? refined });
+    const context = createContext(source, construction, extras, tank, { porchRoofOnPostsOnly: options.porchRoofOnPostsOnly ?? refined, rafterRoof: options.rafterRoof ?? refined, wallPillarSpacing: wallPillarSpacingOf(options), visorSections: options.visorSections === true });
     addFoundation(context);
+    if (options.groundBeams !== false) addGroundBeams(context);
     buildFloors(context);
     addBalconies(context);
     addPorchRoofs(context);
@@ -18930,6 +19491,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   var LINTEL_DEPTH2 = 0.2;
   var LINTEL_BEARING2 = 0.2;
+  var SILL_BEAM_DEPTH = 0.1;
+  var LINTEL_SPAN_RATIO = 10;
   var MIN_PIECE = 0.05;
   var frameOf = (wall) => {
     const alongU = wall.aabb[2] - wall.aabb[0] >= wall.aabb[3] - wall.aabb[1];
@@ -18943,6 +19506,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const drafts = [];
     const piers = [];
     const lintels = [];
+    const sillBeams = [];
     const spandrels = [];
     const height = wall.y1 - wall.y0;
     let cursor = frame2.from;
@@ -18953,23 +19517,26 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     };
     own.forEach((opening2, k) => {
       addPier(Math.max(cursor, opening2.from));
-      const lintelTop = Math.min(wall.y1, opening2.y1 + Math.max(LINTEL_DEPTH2, style.lintelDepth?.(opening2.to - opening2.from) ?? 0));
+      const span = opening2.to - opening2.from;
+      const lintelTop = Math.min(wall.y1, opening2.y1 + Math.max(LINTEL_DEPTH2, style.lintelDepth?.(span) ?? 0, (span + LINTEL_BEARING2) / LINTEL_SPAN_RATIO));
       const lintelFrom = Math.max(frame2.from, opening2.from - LINTEL_BEARING2);
       const lintelTo = Math.min(frame2.to, opening2.to + LINTEL_BEARING2);
       const lintelHeight = lintelTop - opening2.y1;
-      if (opening2.y0 - wall.y0 > MIN_PIECE) drafts.push({ id: `${wall.id}_sill_${k}`, role: "partition", material: wall.material, from: opening2.from, to: opening2.to, y0: wall.y0, y1: opening2.y0, volume: (opening2.to - opening2.from) * (opening2.y0 - wall.y0) });
+      const sillTop = style.sillBeam && opening2.y0 - wall.y0 > SILL_BEAM_DEPTH + MIN_PIECE ? opening2.y0 - SILL_BEAM_DEPTH : opening2.y0;
+      if (sillTop - wall.y0 > MIN_PIECE) drafts.push({ id: `${wall.id}_sill_${k}`, role: "partition", material: wall.material, from: opening2.from, to: opening2.to, y0: wall.y0, y1: sillTop, volume: (opening2.to - opening2.from) * (sillTop - wall.y0) });
+      if (sillTop < opening2.y0) sillBeams.push({ id: `${wall.id}_sillbeam_${k}`, role: "beam", material: style.lintelMaterial, from: lintelFrom, to: lintelTo, y0: sillTop, y1: opening2.y0, volume: (lintelTo - lintelFrom) * SILL_BEAM_DEPTH });
       lintels.push({ id: `${wall.id}_lintel_${k}`, role: "beam", material: style.lintelMaterial, from: lintelFrom, to: lintelTo, y0: opening2.y1, y1: lintelTop, volume: (lintelTo - lintelFrom) * lintelHeight });
       spandrels.push(wall.y1 - lintelTop > MIN_PIECE ? { id: `${wall.id}_spandrel_${k}`, role: roleOf2, material: wall.material, from: opening2.from, to: opening2.to, y0: lintelTop, y1: wall.y1, volume: (opening2.to - opening2.from) * (wall.y1 - lintelTop) } : void 0);
       cursor = opening2.to;
     });
     addPier(frame2.to);
     for (const pier of piers) {
-      for (const lintel of lintels) {
+      for (const lintel of [...lintels, ...sillBeams]) {
         const overlap = Math.max(0, Math.min(pier.to, lintel.to) - Math.max(pier.from, lintel.from));
         pier.volume -= overlap * (lintel.y1 - lintel.y0);
       }
     }
-    const all = [...piers, ...drafts, ...lintels, ...spandrels.filter((d) => d !== void 0)];
+    const all = [...piers, ...drafts, ...sillBeams, ...lintels, ...spandrels.filter((d) => d !== void 0)];
     const total = all.reduce((sum, d) => sum + d.volume, 0);
     const pieces = all.map((d) => ({
       id: d.id,
@@ -18984,6 +19551,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       ...d.role === "beam" ? style.lintelAssembly ? { assembly: style.lintelAssembly } : {} : wall.assembly ? { assembly: wall.assembly } : {}
     }));
     const internal = [];
+    for (const beam of sillBeams) {
+      const sill = drafts.find((d) => d.id === beam.id.replace("_sillbeam_", "_sill_"));
+      if (sill) internal.push({ part: beam.id, on: sill.id, joint: style.lintelJoint });
+      for (const pier of piers) if (Math.min(pier.to, beam.to) - Math.max(pier.from, beam.from) > 0) internal.push({ part: beam.id, on: pier.id, joint: style.lintelJoint });
+    }
     lintels.forEach((lintel, k) => {
       for (const pier of piers) if (Math.min(pier.to, lintel.to) - Math.max(pier.from, lintel.from) > 0) internal.push({ part: lintel.id, on: pier.id, joint: style.lintelJoint });
       const spandrel = spandrels[k];
@@ -19013,7 +19585,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         ...system.timber ? {} : { lintelAssembly: "reinforced_concrete" },
         lintelJoint: system.joints.beam,
         wallJoint: system.joints.wall,
-        ...lintelDepth && !system.timber ? { lintelDepth } : {}
+        ...lintelDepth && !system.timber ? { lintelDepth } : {},
+        ...construction.system === "masonry" ? { sillBeam: true } : {}
       });
       if (split.pieces.length > 1) splits.set(part.id, split);
     }
@@ -19021,7 +19594,18 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   function applyPanels(input, structure, detail, lintelDepth) {
     if (detail === "coarse") return input;
-    return applySplits(input, panelSplits(input, structure, lintelDepth));
+    return onJambPillars(applySplits(input, panelSplits(input, structure, lintelDepth)));
+  }
+  var OPENING_BEAM = /_(lintel|sillbeam)_\d+$/;
+  var overlaps2 = (a, b) => a[0] < b[2] && a[2] > b[0] && a[1] < b[3] && a[3] > b[1];
+  function onJambPillars(split) {
+    const pillars = split.parts.filter((part) => part.role === "column" && part.material === "concrete");
+    const extra = [];
+    for (const beam of split.parts) {
+      if (beam.role !== "beam" || !OPENING_BEAM.test(beam.id)) continue;
+      for (const pillar of pillars) if (pillar.floor === beam.floor && overlaps2(pillar.aabb, beam.aabb) && pillar.y0 <= beam.y0 && pillar.y1 >= beam.y1 - 0.01) extra.push({ part: beam.id, on: pillar.id, joint: "rebar" });
+    }
+    return extra.length ? { parts: split.parts, supports: [...split.supports, ...extra] } : split;
   }
   function applyUnits(input, structure) {
     const splits = /* @__PURE__ */ new Map();
@@ -19083,21 +19667,35 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   };
   var MEMBER_CAGE = { spacing: 0.1, diameter: 8e-3, unit: 0.1 };
   var CAGED_ROLES = /* @__PURE__ */ new Set(["beam", "column"]);
+  var CAGE_COVER = 0.03;
+  var CAGE_BUCKLING_SHARE = 0.5;
+  var DEFAULT_RESIDUAL = 0.15;
+  function cageResidualCapacity(size, reinforcement, capacity) {
+    const [a = 0, b = 0] = [...size].sort((x, y) => x - y);
+    const perSide = (w) => Math.max(2, Math.floor(Math.max(0, w - 2 * CAGE_COVER) / reinforcement.spacing) + 1);
+    const bars = 2 * perSide(a) + 2 * perSide(b) - 4;
+    const steel = MATERIALS2.find((m) => m.id === reinforcement.material)?.compressive ?? 0;
+    const carries2 = bars * Math.PI * (reinforcement.diameter / 2) ** 2 * steel * CAGE_BUCKLING_SHARE;
+    if (!capacity || capacity <= 0 || carries2 <= 0) return DEFAULT_RESIDUAL;
+    return Math.min(1, Math.max(DEFAULT_RESIDUAL, carries2 / capacity));
+  }
   var caged = (spec, part, rebar) => {
     if (!rebar || part.material !== "concrete" || !CAGED_ROLES.has(part.role) || spec.reinforcement) return spec;
     const size = spec.shape.kind === "box" ? spec.shape.size : null;
     if (!size) return spec;
     const thin = Math.min(...size);
+    const reinforcement = { material: rebar, spacing: MEMBER_CAGE.spacing, diameter: MEMBER_CAGE.diameter };
     return {
       ...spec,
-      reinforcement: { material: rebar, spacing: MEMBER_CAGE.spacing, diameter: MEMBER_CAGE.diameter },
+      reinforcement: part.role === "column" ? { ...reinforcement, residualCapacity: cageResidualCapacity(size, reinforcement, spec.structure?.capacity) } : reinforcement,
       units: { size: [MEMBER_CAGE.unit, MEMBER_CAGE.unit, thin], bond: "stack", mortar: "concrete" }
     };
   };
   var partSpecOf = (part, capacity, detailed, rebar) => {
     if (detailed && part.assembly) return assemblySpec(part, capacity);
     const spec = boxSpec(part, capacity);
-    return detailed ? caged(spec, part, rebar) : spec;
+    const out = detailed ? caged(spec, part, rebar) : spec;
+    return part.beamKind === "ground_beam" ? { ...out, anchored: true, structure: { role: "foundation" } } : out;
   };
   function toDestructibleSpec(structure, options = {}) {
     const { safety = 0.65, redundancy = 0.97, safetyOthers = 0.45 } = options;
@@ -19113,7 +19711,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const walled = applyPanels(slabbed, structure, detail, slabOptions && structure.construction.frame.rebar ? (span) => beamDepthFor(span, slabOptions) : void 0);
     const panels = slabOptions && detail !== "coarse" ? deepenBondBeams(walled, structure, slabOptions) : walled;
     const sizing = { safety, redundancy, safetyOthers };
-    const sized = { ...panels, capacities: options.sized === false ? /* @__PURE__ */ new Map() : sizeCapacities(panels.parts, panels.supports, sizing) };
+    const foundation = new Set(panels.parts.filter((part) => part.beamKind === "ground_beam").map((part) => part.id));
+    const onFoundation = foundation.size ? panels.supports.filter((s) => !foundation.has(s.part)).map((s) => foundation.has(s.on) ? { ...s, on: GROUND } : s) : panels.supports;
+    const sized = { ...panels, capacities: options.sized === false ? /* @__PURE__ */ new Map() : sizeCapacities(panels.parts.filter((part) => !foundation.has(part.id)), onFoundation, sizing) };
     const { parts, supports, capacities } = detail === "units" ? applyUnits(sized, structure) : sized;
     const specs = parts.map((part) => partSpecOf(part, capacities.get(part.id), detail !== "coarse", structure.construction.frame.rebar));
     const margin = options.terrainMargin ?? TERRAIN_MARGIN;
@@ -19178,6 +19778,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     out.parts = out.parts.map((p, i) => i === ground ? raft2 : p);
     return out;
   }
+  var LOW_WINDOW = SILL_BEAM_DEPTH + 0.05;
   var slabId = (g, f) => f === g.floors - 1 && g.roof ? "roof" : `slab_${f}`;
   var storeyBase = (g, f) => f * (g.height + g.slab);
   var slabHalf = (g) => [(g.spanX + g.columnSize + 0.2) / 2, (g.spanZ + g.columnSize + 0.2) / 2];
@@ -19336,7 +19937,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         parts.push({ id, material: c.material, shape: box2(size), position, structure: { role: "partition" }, tags: ["infill"] });
         for (const o of on) rests(joints, id, o, "mortar");
       };
-      const bay = (side, k, along, centre, fixed, length, c1, c2) => {
+      const bay = (side, k, along, centre2, fixed, length, c1, c2) => {
         const clear = length - g.columnSize;
         const win = clear * c.window;
         const pier = (clear - win) / 2;
@@ -19347,11 +19948,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           wall(`infill_${f}_${side}_${k}_${name}`, size(u, h), [p[0], y, p[2]], on);
         };
         const id = (name) => `infill_${f}_${side}_${k}_${name}`;
-        put("sill", clear, sill, yb + sill / 2, centre, [c1, c2]);
-        put("pl", pier, head - sill, yb + sill + (head - sill) / 2, centre - clear / 2 + pier / 2, [c1, id("sill")]);
-        put("pr", pier, head - sill, yb + sill + (head - sill) / 2, centre + clear / 2 - pier / 2, [c2, id("sill")]);
-        put("head", clear, room - head, yb + head + (room - head) / 2, centre, [c1, c2]);
-        const gp = at2(centre);
+        put("sill", clear, sill, yb + sill / 2, centre2, [c1, c2]);
+        put("pl", pier, head - sill, yb + sill + (head - sill) / 2, centre2 - clear / 2 + pier / 2, [c1, id("sill")]);
+        put("pr", pier, head - sill, yb + sill + (head - sill) / 2, centre2 + clear / 2 - pier / 2, [c2, id("sill")]);
+        put("head", clear, room - head, yb + head + (room - head) / 2, centre2, [c1, c2]);
+        const gp = at2(centre2);
         const gid = `glass_${f}_${side}_${k}`;
         parts.push({
           id: gid,
@@ -19995,7 +20596,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
             if (!pc || pc.unit) return sp;
             if (pc.role !== "wall" && pc.role !== "partition") {
               const def = getAssembly(pc.assembly || (pc.material === "concrete" && ["slab", "beam", "column", "stair"].includes(pc.role) ? "reinforced_concrete" : ""));
-              const out = def && def.reinforcement && !sp.reinforcement ? { ...sp, reinforcement: { ...def.reinforcement } } : sp;
+              const cage = def && def.reinforcement ? pc.role === "column" && sp.shape.kind === "box" ? { ...def.reinforcement, residualCapacity: cageResidualCapacity(sp.shape.size, def.reinforcement, sp.structure?.capacity) } : { ...def.reinforcement } : null;
+              const out = cage && !sp.reinforcement ? { ...sp, reinforcement: cage } : sp;
               if (out.reinforcement && !out.units && pc.material === "concrete" && (pc.role === "beam" || pc.role === "column") && sp.shape.kind === "box") {
                 return { ...out, units: { size: [MEMBER_CAGE.unit, MEMBER_CAGE.unit, Math.min(...sp.shape.size)], bond: "stack", mortar: "concrete" } };
               }
@@ -20023,6 +20625,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     const a = pos.array;
     const u = mesh2.userData;
     if (!u._p0) u._p0 = a.slice();
+    if (!u.plainPositions) Object.defineProperty(u, "plainPositions", { value: u._p0, enumerable: false, configurable: true, writable: true });
     const list2 = u.collapsedRanges ?? (u.collapsedRanges = []);
     if (!list2.some((r) => r[0] === v0 && r[1] === v1)) list2.push([v0, v1]);
     const saved = a.slice(v0 * 3, v1 * 3);
@@ -20106,10 +20709,11 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const v = house.worldToLocal(tmp.p.set(p[0], p[1], p[2]));
         return [v.x, v.y, v.z];
       };
-      function cells(part, units) {
+      function cells(part, units, mask) {
         const [u0, v0, u1, v1] = part.aabb;
-        const alongU = u1 - u0 >= v1 - v0;
+        const alongU = mask.alongU;
         const len = alongU ? u1 - u0 : v1 - v0;
+        const offset = (alongU ? u0 : v0) - mask.start;
         const [ul, uh] = units.size;
         const rows = Math.max(1, Math.round((part.y1 - part.y0) / uh));
         const rowH = (part.y1 - part.y0) / rows;
@@ -20120,7 +20724,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const shift = units.bond === "running" && r & 1 ? w / 2 : 0;
           for (let i = 0; i < per + (shift ? 1 : 0); i++) {
             const a = Math.max(0, i * w - shift), b = Math.min(len, i * w - shift + w);
-            if (b - a > 1e-3) out.push({ a, b, y0: part.y0 + r * rowH, y1: part.y0 + (r + 1) * rowH, r, i });
+            if (b - a > 1e-3) out.push({ a: offset + a, b: offset + b, y0: part.y0 + r * rowH, y1: part.y0 + (r + 1) * rowH, r, i });
           }
         }
         return out;
@@ -20134,8 +20738,21 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         for (const q of structure.parts) {
           if (q.id !== partId && same(q.aabb, part.aabb) && Math.abs(q.y1 - part.y0) < 0.01 && structure.meshesOf(q.id).some((it) => it.mesh)) return q.id;
         }
+        return part.role === "column" ? wallAround(part) : null;
+      }
+      function wallAround(part) {
+        const cu = (part.aabb[0] + part.aabb[2]) / 2, cv = (part.aabb[1] + part.aabb[3]) / 2;
+        for (const q of structure.parts) {
+          if (q.id === part.id || q.role !== "wall" && q.role !== "partition" || !structure.meshesOf(q.id).some((it) => it.mesh)) continue;
+          const inside2 = cu >= q.aabb[0] - 1e-3 && cu <= q.aabb[2] + 1e-3 && cv >= q.aabb[1] - 1e-3 && cv <= q.aabb[3] + 1e-3;
+          if (inside2 && Math.min(q.y1, part.y1) - Math.max(q.y0, part.y0) > 0.5) return q.id;
+        }
         return null;
       }
+      const pillarSpans = (view) => structure.parts.filter((q) => q.role === "column" && wallAround(q) === view.host).map((q) => {
+        const a = (view.mask.alongU ? q.aabb[0] : q.aabb[1]) - view.mask.start, b = (view.mask.alongU ? q.aabb[2] : q.aabb[3]) - view.mask.start;
+        return { a, b, y0: q.y0, y1: q.y1 };
+      });
       const riders = (hostId) => structure.parts.filter((q) => q.id !== hostId && specOf(q.id)?.units && hostOf(q.id) === hostId && !structure.meshesOf(q.id).some((it) => it.mesh)).map((q) => q.id);
       function shell(it, mask) {
         const g0 = it.mesh.geometry, g = new THREE.BufferGeometry();
@@ -20224,6 +20841,17 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         texture.needsUpdate = true;
         return { data, texture, w, h, alongU, start: alongU ? u0 : v0, len, y0, height: y1 - y0, rect: new THREE.Vector4(alongU ? u0 : v0, y0, len, y1 - y0) };
       }
+      function besidePillars(c, pillars) {
+        let { a, b } = c;
+        for (const k of pillars) {
+          if (c.y1 <= k.y0 || c.y0 >= k.y1 || b <= k.a || a >= k.b) continue;
+          const centre = (a + b) / 2;
+          if (centre > k.a && centre < k.b) return [];
+          if (centre <= k.a) b = Math.min(b, k.a);
+          else a = Math.max(a, k.b);
+        }
+        return b - a > 1e-3 ? [{ ...c, a, b }] : [];
+      }
       const boxDistance = (s, y, a, b, c, d) => Math.hypot(Math.max(a - s, 0, s - b), Math.max(c - y, 0, y - d));
       const ellipseDistance = (s, y, cs, cy, rs, ry) => (Math.hypot((s - cs) / Math.max(rs, 1e-4), (y - cy) / Math.max(ry, 1e-4)) - 1) * Math.min(rs, ry);
       function covered(c, boxes) {
@@ -20246,9 +20874,15 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const discs = [];
         const flakes = [];
         const shown = [];
+        const pillars = pillarSpans(view);
         for (const id of view.parts) {
           const part = structure.byId.get(id), units2 = specOf(id).units, chips = view.chips.get(id), opening = view.openings.get(id), spalls = view.spalls.get(id);
-          const all = cells(part, units2);
+          const own = cells(part, units2, mask);
+          const all = id === view.host ? own.flatMap((c) => besidePillars(c, pillars)) : own;
+          if (view.fallen.has(id)) {
+            holes.push(...all);
+            continue;
+          }
           const thick = mask.alongU ? part.aabb[3] - part.aabb[1] : part.aabb[2] - part.aabb[0];
           const mid = mask.alongU ? (part.aabb[1] + part.aabb[3]) / 2 : (part.aabb[0] + part.aabb[2]) / 2;
           if (opening) discs.push({ s: along(opening.center), y: opening.center[1], r: opening.radius });
@@ -20344,52 +20978,55 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         }
         return { center: local(chip.center), along: a, up: u };
       }
+      function newView(hostId) {
+        const items = structure.meshesOf(hostId).filter((it) => it.mesh);
+        if (!items.length) return null;
+        const parts = [hostId, ...riders(hostId)].filter((id) => structure.byId.get(id) && specOf(id)?.units);
+        const mask = maskOf(hostId, parts), core = maskOf(hostId, parts);
+        return {
+          host: hostId,
+          parts,
+          items,
+          mask,
+          core,
+          unitMaterial: unitsMaterial(core),
+          shells: [],
+          saved: null,
+          units: null,
+          gone: 0,
+          pits: 0,
+          bounds: drawnBounds(items),
+          chips: new Map(parts.map((id) => [id, []])),
+          spalls: new Map(parts.map((id) => [id, []])),
+          openings: /* @__PURE__ */ new Map(),
+          flakes: 0,
+          fallen: /* @__PURE__ */ new Set()
+        };
+      }
+      function cut(view) {
+        if (view.saved) return;
+        view.shells = view.items.map((it) => shell(it, view.mask));
+        for (const m of view.shells) m.userData.behind = () => view.units;
+        view.saved = view.items.map((it) => ({ it, v0: it.v0, data: collapseRange(it.mesh, it.v0, it.v1) }));
+      }
       function draw2(partId, change) {
         if (lod !== 0) return false;
         const hostId = hostOf(partId);
         if (!hostId || !specOf(partId)?.units) return false;
-        let view = views.get(hostId);
-        if (!view) {
-          const items = structure.meshesOf(hostId).filter((it) => it.mesh);
-          if (!items.length) return false;
-          const parts = [hostId, ...riders(hostId)].filter((id) => structure.byId.get(id) && specOf(id)?.units);
-          if (!parts.includes(partId)) return false;
-          const mask = maskOf(hostId, parts), core = maskOf(hostId, parts);
-          view = {
-            host: hostId,
-            parts,
-            items,
-            mask,
-            core,
-            unitMaterial: unitsMaterial(core),
-            shells: [],
-            saved: null,
-            units: null,
-            gone: 0,
-            pits: 0,
-            bounds: drawnBounds(items),
-            chips: new Map(parts.map((id) => [id, []])),
-            spalls: new Map(parts.map((id) => [id, []])),
-            openings: /* @__PURE__ */ new Map(),
-            flakes: 0
-          };
-        }
-        if (!view.chips.has(partId)) return false;
+        const view = views.get(hostId) ?? newView(hostId);
+        if (!view || !view.chips.has(partId)) return false;
         if (change.opening) {
           if (view.openings.has(partId)) return false;
           view.openings.set(partId, { center: local(change.opening.center), radius: change.opening.radius });
         }
         if (change.chip) view.chips.get(partId).push(chipBox(change.chip, view.mask.alongU));
+        for (const chip of change.chips ?? []) view.chips.get(partId).push(chipBox(chip, view.mask.alongU));
         if (change.spall) {
           const list2 = view.spalls.get(partId);
           list2.push({ center: local(change.spall.center), radius: change.spall.radius });
           if (list2.length > MAX_FLAKES) list2.shift();
         }
-        if (!view.saved) {
-          view.shells = view.items.map((it) => shell(it, view.mask));
-          for (const m of view.shells) m.userData.behind = () => view.units;
-          view.saved = view.items.map((it) => ({ it, v0: it.v0, data: collapseRange(it.mesh, it.v0, it.v1) }));
-        }
+        cut(view);
         views.set(hostId, view);
         if (opts.deferPaint && change.spall) dirty.add(view);
         else {
@@ -20500,14 +21137,32 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
          */
         chip(event) {
           if (event.torn) return false;
-          return draw2(event.part, { chip: { center: event.center, size: event.size ?? [0, 0, 0], rotation: event.rotation ?? [0, 0, 0, 1] } });
+          const rotation = event.rotation ?? [0, 0, 0, 1];
+          if (event.units?.length) return draw2(event.part, { chips: event.units.map((unit) => ({ center: unit.center, size: unit.size, rotation })) });
+          return draw2(event.part, { chip: { center: event.center, size: event.size ?? [0, 0, 0], rotation } });
         },
         /** The part broke or fell: its damage goes (the plain range stays collapsed, the renderer hides the part). */
         drop(partId) {
-          const v = views.get(partId);
-          if (!v) return;
+          let host = views.get(partId) ?? [...views.values()].find((view) => view.parts.includes(partId));
+          if (!host && lod === 0 && riders(partId).length > 0) {
+            host = newView(partId);
+            if (host) {
+              cut(host);
+              views.set(partId, host);
+            }
+          }
+          if (!host) return;
+          host.fallen.add(partId);
+          if (host.parts.some((id) => !host.fallen.has(id))) {
+            dirty.delete(host);
+            paint(host);
+            invalidate();
+            invalidateShadow();
+            return;
+          }
+          const v = host;
           dispose(v);
-          views.delete(partId);
+          views.delete(v.host);
           if (v.saved) dropped.push(v);
         },
         /** LOD 0 draws the cut wall; LOD 1 and 2 give the wall its box back. */
@@ -20986,6 +21641,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       shared.ctx.noPiece = false;
       cursor.separate = opts.pieces === "meshes";
       cursor.pc = null;
+      shared.ctx.showPillars = opts.pillars !== "hidden";
       shared.ctx.apartment = r.template === "apartment_modern";
       shared.ctx.pa = Math.max(3, Math.min(20, pr.floors != null ? pr.floors : 5));
       shared.ctx.pf = Math.max(1, Math.min(shared.ctx.pa, pr.floor != null ? pr.floor : 3));
@@ -22153,10 +22809,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           const list2 = events(room);
           const columns = groundColumns(parts);
           const laj = slabs(parts);
-          const first = columns[0];
-          const mate = columns.slice(1).filter((p) => Math.abs(p.position[0] - first.position[0]) < 0.5).sort((a, b) => Math.abs(b.position[2] - first.position[2]) - Math.abs(a.position[2] - first.position[2]))[0] ?? columns[1];
-          blunt(room, oid, first.id, centre(first.id), 3e6);
-          blunt(room, oid, mate.id, centre(mate.id), 3e6);
+          const first = columns.find((p) => !/^wall_column_/.test(p.id)) ?? columns[0];
+          const mate = columns.filter((p) => p !== first && !/^wall_column_/.test(p.id)).filter((p) => Math.abs(p.position[0] - first.position[0]) < 0.5).sort((a, b) => Math.abs(b.position[2] - first.position[2]) - Math.abs(a.position[2] - first.position[2]))[0] ?? columns[1];
+          const along = columns.filter((p) => /^wall_column_/.test(p.id) && Math.abs(p.position[0] - first.position[0]) < 0.5);
+          for (const p of [first, mate, ...along]) blunt(room, oid, p.id, centre(p.id), 3e6);
           step(90);
           const fell = collapsed(list2);
           expect(laj.some((id) => fell.includes(id)), fill(T2.two_slab_fell, { n: fell.length }));
@@ -24329,6 +24985,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
 
   // src/wall.ts
+  var WARM_UP_SHOT = { type: "ballistic", point: [0, 1.2, 0.1], direction: [0, 0, -1], energy: 3500, caliber: 7.62 };
+  var WARM_UP_FRAMES = 5;
+  var isTexture = (value) => typeof value === "object" && value !== null && value.isTexture === true;
   var PLASTER = 15262420;
   var WALL_ID = "wall_0_0";
   function wallPlan(options) {
@@ -24387,7 +25046,39 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       plan,
       spec,
       build: (T2) => label(draw(T2, plan, houseOptions)),
-      follow: (root, world, objectId) => houses.get(root)?.destruction?.follow?.(world, objectId, spec) ?? null
+      follow: (root, world, objectId) => houses.get(root)?.destruction?.follow?.(world, objectId, spec) ?? null,
+      warmUpProbes: (T2) => {
+        const house = draw(T2, plan, houseOptions);
+        const root = label(house);
+        const world = createDestruction({ seed: 1 });
+        const objectId = world.add(spec, { id: "warm_up_wall" });
+        const destruction = house.destruction;
+        const follower = destruction?.follow?.(world, objectId, spec) ?? null;
+        world.hitPart(objectId, WALL_ID, WARM_UP_SHOT);
+        for (let frame2 = 0; frame2 < WARM_UP_FRAMES; frame2++) {
+          world.update(1 / 60);
+          follower?.update?.();
+        }
+        for (let guard = 0; guard < WARM_UP_FRAMES && (destruction?.breach?.flush?.(Infinity) ?? 0) > 0; guard++) ;
+        root.traverse((node) => {
+          node.visible = true;
+          node.frustumCulled = false;
+        });
+        return {
+          group: root,
+          // the materials stay: the warmup keeps them as anchors, and disposing the last material of a program frees the program it was drawn for (so the
+          // follower is not disposed either: it would put the wall back and dispose the breach's materials; its world goes with the probe)
+          dispose: () => {
+            root.traverse((node) => {
+              node.geometry?.dispose();
+              for (const material of Array.isArray(node.material) ? node.material : node.material ? [node.material] : []) {
+                for (const uniform2 of Object.values(material.uniforms ?? {})) if (isTexture(uniform2.value)) uniform2.value.dispose();
+                material.map?.dispose();
+              }
+            });
+          }
+        };
+      }
     };
   }
   return __toCommonJS(index_exports);