@adatechnology/game-floorplan-structure 2.0.1 → 2.1.0

package/dist/index.global.js

@@ -23,6 +23,7 @@ var GameFloorplanStructure = (() => {
   // src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    BEAM_DEPTH_RATIO: () => BEAM_DEPTH_RATIO,
     CONSTRUCTIONS: () => CONSTRUCTIONS,
     CONSTRUCTION_SYSTEMS: () => CONSTRUCTION_SYSTEMS,
     CORE_DEFAULTS: () => CORE_DEFAULTS,
@@ -31,8 +32,14 @@ var GameFloorplanStructure = (() => {
     DENSITY: () => DENSITY,
     FLAT_ROOF_DEFAULTS: () => FLAT_ROOF_DEFAULTS,
     GROUND: () => GROUND,
+    GROUND_BEAM_DEPTH: () => GROUND_BEAM_DEPTH,
+    MAX_LINTEL_ON_MASONRY: () => MAX_LINTEL_ON_MASONRY,
+    MAX_PILLAR_SPACING: () => MAX_PILLAR_SPACING,
     MECHANICAL_DEFAULTS: () => MECHANICAL_DEFAULTS,
     MEMBER_CAGE: () => MEMBER_CAGE,
+    MIN_BEAM_WIDTH: () => MIN_BEAM_WIDTH,
+    MIN_PILLAR_AREA: () => MIN_PILLAR_AREA,
+    MIN_PILLAR_SIDE: () => MIN_PILLAR_SIDE,
     PILE_AREA: () => PILE_AREA,
     PILE_DEFAULTS: () => PILE_DEFAULTS,
     PLATE_DEFAULTS: () => PLATE_DEFAULTS,
@@ -40,10 +47,15 @@ var GameFloorplanStructure = (() => {
     RAFT_THICKNESS: () => RAFT_THICKNESS,
     REBAR_RATIOS: () => REBAR_RATIOS,
     ROOF_COVERINGS: () => ROOF_COVERINGS,
+    SILL_BEAM_DEPTH: () => SILL_BEAM_DEPTH,
     SKYSCRAPER_DEFAULTS: () => SKYSCRAPER_DEFAULTS,
     SKYSCRAPER_MAX_STOREYS: () => SKYSCRAPER_MAX_STOREYS,
     SLAB_PANEL_DEFAULTS: () => SLAB_PANEL_DEFAULTS,
+    STRUCTURAL_VIOLATION: () => STRUCTURAL_VIOLATION,
+    TANK_PILLAR_SIDE: () => TANK_PILLAR_SIDE,
     TOWER_DEFAULTS: () => TOWER_DEFAULTS,
+    WALL_PILLAR_SIDE: () => WALL_PILLAR_SIDE,
+    WALL_PILLAR_SPACING: () => WALL_PILLAR_SPACING,
     addCore: () => addCore,
     addCurtainWall: () => addCurtainWall,
     addFlatRoof: () => addFlatRoof2,
@@ -57,16 +69,19 @@ var GameFloorplanStructure = (() => {
     buildStructure: () => buildStructure,
     buildTower: () => buildTower,
     buildWallSpecimen: () => buildWallSpecimen,
+    cageResidualCapacity: () => cageResidualCapacity,
     campConstruction: () => campConstruction,
     chaletConstruction: () => chaletConstruction,
     constructionOfSystem: () => constructionOfSystem,
     coreSize: () => coreSize,
+    countViolations: () => countViolations,
     damperMass: () => damperMass,
     exteriorWindows: () => exteriorWindows,
     logCabinConstruction: () => logCabinConstruction,
     masonryConstruction: () => masonryConstruction,
     mechanicalStoreys: () => mechanicalStoreys,
     pilesFor: () => pilesFor,
+    pillarStations: () => pillarStations,
     planToSpace: () => planToSpace,
     planWaterTank: () => planWaterTank,
     register: () => register,
@@ -87,6 +102,8 @@ var GameFloorplanStructure = (() => {
     towerLocales: () => towerLocales,
     towerPlate: () => towerPlate,
     towerWater: () => towerWater,
+    validateSpec: () => validateSpec,
+    validateStructure: () => validateStructure,
     version: () => version,
     windExposureOf: () => windExposureOf,
     woodFrameConstruction: () => woodFrameConstruction
@@ -424,12 +441,15 @@ var GameFloorplanStructure = (() => {
       builder,
       porchRoofOnPostsOnly: options.porchRoofOnPostsOnly,
       rafterRoof: options.rafterRoof,
+      wallPillarSpacing: options.wallPillarSpacing,
+      visorSections: options.visorSections,
       floorCount,
       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(),
@@ -502,7 +522,8 @@ var GameFloorplanStructure = (() => {
         builder.rest(deck, base, system.joints.slab);
         continue;
       }
-      const pillar = builder.add({ id: `balcony_column_${room.id}`, role: "column", material: construction.frame.pillars, aabb: [box2[0] - 0.08, box2[1] - 0.08, box2[0] + 0.08, box2[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: [box2[0] - half, box2[1] - half, box2[0] + half, box2[1] + half], y0: 0, y1: context.level(floor) - system.slabThickness }, { floor: 0 });
       builder.rest(pillar, GROUND, "rebar");
       builder.rest(deck, pillar, "rebar");
     }
@@ -573,8 +594,8 @@ var GameFloorplanStructure = (() => {
     const top = context.level(floor) - thickness * 0.15;
     const out = [];
     for (let k = 0; k < count; k++) {
-      const centre = (alongU ? box2[0] : box2[1]) + 0.05 + k * (span - 0.1) / (count - 1);
-      const aabb = alongU ? [centre - 0.025, box2[1], centre + 0.025, box2[3]] : [box2[0], centre - 0.025, box2[2], centre + 0.025];
+      const centre2 = (alongU ? box2[0] : box2[1]) + 0.05 + k * (span - 0.1) / (count - 1);
+      const aabb = alongU ? [centre2 - 0.025, box2[1], centre2 + 0.025, box2[3]] : [box2[0], centre2 - 0.025, box2[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);
@@ -664,8 +685,8 @@ var GameFloorplanStructure = (() => {
       const at2 = alongU ? box2[1] + line * (box2[3] - box2[1]) / (rows - 1) : box2[0] + line * (box2[2] - box2[0]) / (columns - 1);
       const aabb = alongU ? [box2[0], at2 - 0.07, box2[2], at2 + 0.07] : [at2 - 0.07, box2[1], at2 + 0.07, box2[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;
@@ -686,18 +707,115 @@ var GameFloorplanStructure = (() => {
     else if (context.isTimber && type !== "ground") context.base0 = raft(context, Math.max(0.12, context.elevation), "concrete");
   }
 
+  // src/structure/ground-beams.ts
+  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);
+    }
+  }
+
+  // src/structure/wall-pillars.ts
+  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 box2 = [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: box2, 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, box2, 0.01))) builder.rest(plate, pillar, "rebar");
+          pillars.push(pillar);
+        }
+      }
+    }
+    return pillars;
+  }
+
   // src/structure/plates.ts
   var MAX_GAP_WITHIN_RUN = 3.2;
   var POST_SPACING = 2.4;
   var POST_SIDE = 0.05;
   var alongOf = (wall, pick) => wall.axis === "u" ? pick(wall.u0, wall.u1) : pick(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) => {
@@ -717,7 +835,7 @@ var GameFloorplanStructure = (() => {
   }
   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 = [];
@@ -743,7 +861,7 @@ var GameFloorplanStructure = (() => {
       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;
@@ -782,7 +900,11 @@ var GameFloorplanStructure = (() => {
   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));
@@ -1067,21 +1189,21 @@ var GameFloorplanStructure = (() => {
   }
 
   // src/structure/openings.ts
-  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);
@@ -1096,18 +1218,39 @@ var GameFloorplanStructure = (() => {
       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 box2 = 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: box2, 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: box2, 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, box2) && 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, box2)) 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 box2 = [u - HALF_PILLAR, v - HALF_PILLAR, u + HALF_PILLAR, v + HALF_PILLAR];
+      if (standing.some((p) => overlapsInPlan(p.aabb, box2))) continue;
+      const pillar = builder.add({ id: `jamb_column_${gap.door.id}_${k}`, role: "column", material: construction.frame.pillars, aabb: box2, 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];
 
   // src/structure/steps.ts
@@ -1287,10 +1430,10 @@ var GameFloorplanStructure = (() => {
     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);
@@ -1308,6 +1451,11 @@ var GameFloorplanStructure = (() => {
       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);
@@ -1315,8 +1463,9 @@ var GameFloorplanStructure = (() => {
     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);
@@ -1765,13 +1914,13 @@ var GameFloorplanStructure = (() => {
     const segments = groundExteriorWalls(plan).sort((a, b) => (b.sides.includes("outside") ? 1 : 0) - (a.sides.includes("outside") ? 1 : 0) || (a.axis === "u" && a.v0 === 0 ? -1 : 1));
     const wall = segments.find((w) => w.axis === "u" && w.v0 === 0) || segments[0];
     if (!wall) return null;
-    const centre = wall.axis === "u" ? (wall.u0 + wall.u1) / 2 : (wall.v0 + wall.v1) / 2;
+    const centre2 = wall.axis === "u" ? (wall.u0 + wall.u1) / 2 : (wall.v0 + wall.v1) / 2;
     const vector = outwardOf(wall);
     const offset = HALF_WALL + 0.1;
     return {
       id: "gas.meter",
-      u: round22(wall.axis === "u" ? centre : wall.u0 + vector[0] * offset),
-      v: round22(wall.axis === "u" ? wall.v0 + vector[1] * offset : centre),
+      u: round22(wall.axis === "u" ? centre2 : wall.u0 + vector[0] * offset),
+      v: round22(wall.axis === "u" ? wall.v0 + vector[1] * offset : centre2),
       y: 1.2,
       side: sideNameOf(vector),
       w: 0.3,
@@ -1962,9 +2111,9 @@ var GameFloorplanStructure = (() => {
     const wall = groundExteriorWalls(plan).filter((q) => q.sides.includes("outside")).sort((a, b) => (a.axis === "v" ? 0 : 1) - (b.axis === "v" ? 0 : 1))[0];
     if (!wall) return null;
     const vector = outwardOf(wall);
-    const centre = wall.axis === "u" ? (wall.u0 + wall.u1) / 2 : (wall.v0 + wall.v1) / 2;
+    const centre2 = wall.axis === "u" ? (wall.u0 + wall.u1) / 2 : (wall.v0 + wall.v1) / 2;
     const offset = HALF_WALL + 0.08;
-    return { id: "inverter", u: round22(wall.axis === "u" ? centre : wall.u0 + vector[0] * offset), v: round22(wall.axis === "u" ? wall.v0 + vector[1] * offset : centre), y: 1.5, side: sideNameOf(vector), w: 0.4, d: 0.15, h: 0.5, outdoor: true, link: "panel" };
+    return { id: "inverter", u: round22(wall.axis === "u" ? centre2 : wall.u0 + vector[0] * offset), v: round22(wall.axis === "u" ? wall.v0 + vector[1] * offset : centre2), y: 1.5, side: sideNameOf(vector), w: 0.4, d: 0.15, h: 0.5, outdoor: true, link: "panel" };
   }
   function planSolar(context) {
     const { plan, rng, energy } = context;
@@ -2172,6 +2321,8 @@ var GameFloorplanStructure = (() => {
 
   // src/water-tank.ts
   var TANK_SIDE = 1.1;
+  var TANK_PILLAR_SIDE = 0.2;
+  var VISOR_TANK_PILLAR_SIDE = 0.12;
   var NOT_UNDER_TANK = ["void", "elevator", "stairs", "balcony", "porch"];
   var WET_ROOMS = ["bathroom", "kitchen", "laundry"];
   var ATTIC_CHANCE = 0.12;
@@ -2181,26 +2332,27 @@ var GameFloorplanStructure = (() => {
     return capacities[source.style ?? ""] ?? capacities[source.template ?? ""] ?? 2e3;
   }
   function bestSpot(source, floor, reference) {
-    const centre = reference ? [reference.u, reference.v] : [source.w / 2, source.d / 2];
+    const centre2 = reference ? [reference.u, reference.v] : [source.w / 2, source.d / 2];
     let best;
     for (const room of source.rooms.filter((r) => r.floor === floor && !NOT_UNDER_TANK.includes(r.type))) {
       for (const part of room.parts) {
         const rect = [part[0] + 0.4, part[1] + 0.4, part[2] - 0.4, part[3] - 0.4];
         if (rect[2] - rect[0] < TANK_SIDE || rect[3] - rect[1] < TANK_SIDE) continue;
         const base = WET_ROOMS.includes(room.type) ? 0 : room.type === "terrace" ? 500 : 100;
-        const weight = base + Math.hypot((rect[0] + rect[2]) / 2 - centre[0], (rect[1] + rect[3]) / 2 - centre[1]);
+        const weight = base + Math.hypot((rect[0] + rect[2]) / 2 - centre2[0], (rect[1] + rect[3]) / 2 - centre2[1]);
         if (!best || weight < best.weight) best = { roomType: room.type, roomId: room.id, rect, weight };
       }
     }
     return best;
   }
-  function raisedPlatform(source, u, v, baseY) {
+  function raisedPlatform(source, spot, side) {
+    const { u, v, baseY } = spot;
     const margin = 0.12;
     const edge = Math.max(0, Math.min(u, source.w - u, v, source.d - v));
     const rise = round2(clamp2(edge * 0.35 + 0.7, 1.1, 2.4));
     const thickness = 0.12;
-    const reach = TANK_SIDE / 2 + margin - 0.06;
-    const pillars = [[-1, -1], [1, -1], [-1, 1], [1, 1]].map(([a, b]) => ({ u: round2(u + a * reach), v: round2(v + b * reach), side: 0.12 }));
+    const reach = TANK_SIDE / 2 + margin - side / 2;
+    const pillars = [[-1, -1], [1, -1], [-1, 1], [1, 1]].map(([a, b]) => ({ u: round2(u + a * reach), v: round2(v + b * reach), side }));
     const half = TANK_SIDE / 2 + margin;
     return { aabb: [u - half, v - half, u + half, v + half].map(round2), baseY, height: rise, thickness, topY: round2(baseY + rise + thickness), pillars, ladder: true };
   }
@@ -2237,7 +2389,7 @@ var GameFloorplanStructure = (() => {
       aabb: [u - TANK_SIDE / 2, v - TANK_SIDE / 2, u + TANK_SIDE / 2, v + TANK_SIDE / 2].map(round2)
     };
     if (where === "raised_slab") {
-      tank.platform = raisedPlatform(source, u, v, slabY);
+      tank.platform = raisedPlatform(source, { u, v, baseY: slabY }, options.pillarSide ?? TANK_PILLAR_SIDE);
       tank.y = tank.platform.topY;
     }
     return tank;
@@ -2342,7 +2494,7 @@ var GameFloorplanStructure = (() => {
   }
   function structureExtension(context) {
     const cache = cacheOf(context.result);
-    const options = { construction: cache.build.construction, extras: cache.build.extras ?? {}, tank: tankOf(context), wallDetail: context.options.wallDetail ?? "panels" };
+    const options = { construction: cache.build.construction, extras: cache.build.extras ?? {}, tank: tankOf(context), wallDetail: context.options.wallDetail ?? "panels", ...context.options.wallPillars !== void 0 ? { wallPillars: context.options.wallPillars } : {}, ...context.options.groundBeams !== void 0 ? { groundBeams: context.options.groundBeams === true } : {}, ...context.options.visorSections === true ? { visorSections: true } : {} };
     const { roof, ...structure } = buildStructure(context.result, options);
     cache.roof = roof;
     for (const part of structure.parts) {
@@ -2366,7 +2518,7 @@ var GameFloorplanStructure = (() => {
     engine.registerResultExtension(
       "waterTank",
       (context) => {
-        const tank = { capacities: options.tankCapacities, custom: context.plan.tpl.tank, location: context.plan.tpl.tankLocation };
+        const tank = { capacities: options.tankCapacities, custom: context.plan.tpl.tank, location: context.plan.tpl.tankLocation, ...context.options.visorSections === true ? { pillarSide: VISOR_TANK_PILLAR_SIDE } : {} };
         return planWaterTank(context.result, context.rng, tank);
       },
       { after: ["construction"], seedKey: "caixa" }
@@ -2388,6 +2540,7 @@ var GameFloorplanStructure = (() => {
   }
 
   // ../game-contracts/dist/index.js
+  var DEFAULT_BLAST_IMPULSE = { bodyArea: 0.7, lift: 0.15, minSpeed: 0.3, tntPerJoule: 0.24 / 2e5 };
   var DEFAULT_COST_ALLOCATION_BYTES = 1024 * 1024;
   var DEFAULT_IGNITION_RULES = {
     fillCurve: [
@@ -2810,6 +2963,22 @@ var GameFloorplanStructure = (() => {
     return angle === 0 ? q : quat.mul(q, quat.fromAxisAngle([0, 0, 1], angle));
   };
   var clamp3 = (v, a, b) => Math.max(a, Math.min(b, v));
+  var splitAlong = (box2, 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 = box2.c[axis] - box2.s[axis] / 2;
+    for (const share of shares) {
+      const length = box2.s[axis] * share / total;
+      const c = [box2.c[0], box2.c[1], box2.c[2]];
+      const size = [box2.s[0], box2.s[1], box2.s[2]];
+      c[axis] = from + length / 2;
+      size[axis] = length;
+      out.push({ c, s: size });
+      from += length;
+    }
+    return out;
+  };
   var splinterBox = (inp, box2, limit = inp.maxFragments) => {
     const { rnd } = inp;
     const dims = box2.s;
@@ -2819,35 +2988,81 @@ var GameFloorplanStructure = (() => {
     const w = Math.max(fmin * 1.5, 0.01);
     const c = clamp3(Math.round(dims[a] * dims[b] / (w * w)), 3, Math.max(3, Math.floor(limit / 2)));
     const maxLen = fmax * 4;
-    const cells = bsp(box2, c, [a, b], rnd);
+    const cells = [];
+    for (const cell of bsp(box2, 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 = clamp3(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, box2, count) => bsp(box2, 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 = clamp3(at2 - gap / 2, -half, half), hi = clamp3(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, clamp3(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;
   };
@@ -2880,8 +3095,18 @@ var GameFloorplanStructure = (() => {
     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] = clamp3(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") {
@@ -2988,6 +3213,88 @@ var GameFloorplanStructure = (() => {
     }
     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 });
@@ -3659,7 +3966,7 @@ var GameFloorplanStructure = (() => {
         eau[j] += e * area * g[i].u * w;
       }
     }
-    const centre = ea.map((v, j) => v > 0 ? eau[j] / v : 0);
+    const centre2 = ea.map((v, j) => v > 0 ? eau[j] / v : 0);
     const ei = new Array(n).fill(0);
     const ga = new Array(n).fill(0);
     for (const i of vertical) {
@@ -3668,7 +3975,7 @@ var GameFloorplanStructure = (() => {
       for (let j = 0; j < n; j++) {
         const w = share(p, j) / bands[j];
         if (w <= 0) continue;
-        ei[j] += e * (g[i].du ** 3 * g[i].dv / 12 + g[i].du * g[i].dv * (g[i].u - centre[j]) ** 2) * w;
+        ei[j] += e * (g[i].du ** 3 * g[i].dv / 12 + g[i].du * g[i].dv * (g[i].u - centre2[j]) ** 2) * w;
       }
     }
     for (let i = 0; i < parts.length; i++) {
@@ -3715,7 +4022,7 @@ var GameFloorplanStructure = (() => {
       for (let j = 0; j < n; j++) {
         const w = share(p, j);
         if (w <= 0) continue;
-        sum += w * p.elasticPa * c.stiffnessFactor * kappa[j] * g[i].du * g[i].dv * (g[i].u - centre[j]);
+        sum += w * p.elasticPa * c.stiffnessFactor * kappa[j] * g[i].du * g[i].dv * (g[i].u - centre2[j]);
         tot += w;
       }
       axial[i] = tot > 0 ? sum / tot : 0;
@@ -3967,6 +4274,7 @@ var GameFloorplanStructure = (() => {
     },
     {
       id: "wood_soft",
+      splitForm: "slivers",
       density: 500,
       hpPerKg: 90,
       penetration: 9,
@@ -4012,6 +4320,7 @@ var GameFloorplanStructure = (() => {
     },
     {
       id: "wood_hard",
+      splitForm: "slivers",
       density: 750,
       hpPerKg: 140,
       penetration: 14,
@@ -4056,6 +4365,7 @@ var GameFloorplanStructure = (() => {
     },
     {
       id: "plywood",
+      splitForm: "plies",
       density: 600,
       hpPerKg: 70,
       penetration: 7,
@@ -4103,6 +4413,7 @@ var GameFloorplanStructure = (() => {
     },
     {
       id: "mdf",
+      splitForm: "granules",
       density: 750,
       hpPerKg: 45,
       penetration: 6,
@@ -4614,6 +4925,7 @@ var GameFloorplanStructure = (() => {
     },
     {
       id: "green_wood",
+      splitForm: "slivers",
       density: 650,
       hpPerKg: 5,
       penetration: 10,
@@ -4894,6 +5206,125 @@ var GameFloorplanStructure = (() => {
         "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 = {
@@ -5106,6 +5537,11 @@ var GameFloorplanStructure = (() => {
   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;
@@ -6358,7 +6794,7 @@ var GameFloorplanStructure = (() => {
         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;
@@ -6486,6 +6922,7 @@ var GameFloorplanStructure = (() => {
       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];
@@ -6544,6 +6981,7 @@ var GameFloorplanStructure = (() => {
         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)) {
@@ -6647,10 +7085,122 @@ var GameFloorplanStructure = (() => {
       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) * clamp22(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 = clamp22(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;
@@ -6717,6 +7267,7 @@ var GameFloorplanStructure = (() => {
       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,
@@ -6725,8 +7276,9 @@ var GameFloorplanStructure = (() => {
         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) : [];
@@ -6771,7 +7323,7 @@ var GameFloorplanStructure = (() => {
         return;
       }
       if (ex) {
-        emit({ ...base(o, src), type: "explode", part: p.spec.id, point: c, energy: ex.energy, radius: ex.radius, ...ex.lethalRadius !== void 0 ? { lethalRadius: ex.lethalRadius } : {}, ...ex.effect !== void 0 ? { effect: ex.effect } : {} });
+        emit({ ...base(o, src), type: "explode", part: p.spec.id, point: c, energy: ex.energy, radius: ex.radius, ...ex.lethalRadius !== void 0 ? { lethalRadius: ex.lethalRadius } : {}, ...ex.tnt !== void 0 ? { tnt: ex.tnt } : {}, ...ex.effect !== void 0 ? { effect: ex.effect } : {} });
         blasts.push({ point: c, energy: ex.energy, radius: ex.radius, ...ex.lethalRadius !== void 0 ? { lethalRadius: ex.lethalRadius } : {}, source: src });
       }
       partLost(o, p, src);
@@ -6838,11 +7390,11 @@ var GameFloorplanStructure = (() => {
         o.active = true;
       }
     };
-    const lightLeaksNear = (centre, radius) => {
+    const lightLeaksNear = (centre2, radius) => {
       for (const o of objects.values()) {
         for (const q of o.parts) {
           if (isLost(q) || q.rt.lit || q.rt.jet || !leaksFlammable(q)) continue;
-          if (vec.distance(partXf(o, q).c, centre) - q.bound > radius) continue;
+          if (vec.distance(partXf(o, q).c, centre2) - q.bound > radius) continue;
           q.rt.lit = true;
           o.active = true;
         }
@@ -6865,7 +7417,8 @@ var GameFloorplanStructure = (() => {
       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;
@@ -7026,7 +7579,7 @@ var GameFloorplanStructure = (() => {
           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 } : {} });
@@ -7036,7 +7589,10 @@ var GameFloorplanStructure = (() => {
       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 };
@@ -7282,12 +7838,17 @@ var GameFloorplanStructure = (() => {
       }
       return h | 0;
     };
-    const throwFragment = (frag, objectId, from, g, centre, index, src, shields, results, reports, mult) => {
+    const splitStream = (objectId, partId, hit) => {
+      const codes = Array.from(`${objectId}|${partId}`, (char) => char.charCodeAt(0) / 1e3);
+      const stream = createRng(seedOf(rng.state() / 1e3, ...codes, hit[0], hit[1], hit[2]));
+      return () => stream.next();
+    };
+    const throwFragment = (frag, objectId, from, g, centre2, index, src, shields, results, reports, mult) => {
       const v = frag.velocity;
       const speed = Math.hypot(v[0], v[1], v[2]);
       const energy = g.energyFactor * 0.5 * frag.mass * speed * speed;
       if (speed < 0.5 || energy < 1) return;
-      const r = createRng(seedOf(options.seed ?? 1, centre[0], centre[1], centre[2], index, frag.center[0], frag.center[1], frag.center[2]));
+      const r = createRng(seedOf(options.seed ?? 1, centre2[0], centre2[1], centre2[2], index, frag.center[0], frag.center[1], frag.center[2]));
       let dir = vec.scale(v, 1 / speed);
       const behind = from ? shields.get(from) : void 0;
       if (behind) {
@@ -9161,6 +9722,8 @@ var GameFloorplanStructure = (() => {
   // src/wall-detail/panels.ts
   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];
@@ -9174,6 +9737,7 @@ var GameFloorplanStructure = (() => {
     const drafts = [];
     const piers = [];
     const lintels = [];
+    const sillBeams = [];
     const spandrels = [];
     const height = wall.y1 - wall.y0;
     let cursor = frame2.from;
@@ -9184,23 +9748,26 @@ var GameFloorplanStructure = (() => {
     };
     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,
@@ -9215,6 +9782,11 @@ var GameFloorplanStructure = (() => {
       ...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];
@@ -9246,7 +9818,8 @@ var GameFloorplanStructure = (() => {
         ...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);
     }
@@ -9254,7 +9827,18 @@ var GameFloorplanStructure = (() => {
   }
   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();
@@ -9318,21 +9902,35 @@ var GameFloorplanStructure = (() => {
   };
   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 = MATERIALS.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;
@@ -9348,7 +9946,9 @@ var GameFloorplanStructure = (() => {
     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;
@@ -9414,6 +10014,359 @@ var GameFloorplanStructure = (() => {
     return out;
   }
 
+  // src/validate/codes.ts
+  var STRUCTURAL_VIOLATION = {
+    /** A pillar with no load path to the ground, or that starts above what it rests on. */
+    PILLAR_NOT_GROUNDED: "PILLAR_NOT_GROUNDED",
+    /** A pillar of a masonry wall that stops short of the bond beam, or that the bond beam does not rest on. */
+    PILLAR_DOES_NOT_REACH_BOND_BEAM: "PILLAR_DOES_NOT_REACH_BOND_BEAM",
+    /** A masonry wall that runs more than `MAX_PILLAR_SPACING` between two of its pillars. */
+    WALL_SPAN_WITHOUT_PILLAR: "WALL_SPAN_WITHOUT_PILLAR",
+    /** A free end of a masonry wall (a door jamb, the end of a garden wall) with no pillar. */
+    WALL_END_WITHOUT_PILLAR: "WALL_END_WITHOUT_PILLAR",
+    /** Two masonry walls meet at a corner with no pillar there. */
+    CORNER_WITHOUT_PILLAR: "CORNER_WITHOUT_PILLAR",
+    /** Another wall meets a masonry wall inside its length (a T) with no pillar there. */
+    WALL_JUNCTION_WITHOUT_PILLAR: "WALL_JUNCTION_WITHOUT_PILLAR",
+    /** A window or door in a masonry wall with no lintel (verga) over it. */
+    OPENING_WITHOUT_LINTEL: "OPENING_WITHOUT_LINTEL",
+    /** A window in a masonry wall with no sill beam (contraverga) under it. */
+    OPENING_WITHOUT_SILL: "OPENING_WITHOUT_SILL",
+    /** An exterior masonry wall with no bond beam (cinta de amarração) on top. */
+    MISSING_BOND_BEAM: "MISSING_BOND_BEAM",
+    /** A ground-floor masonry wall standing on the soil with no ground beam (viga baldrame) or foundation under it. */
+    MISSING_GROUND_BEAM: "MISSING_GROUND_BEAM",
+    /** A part with no load path down to the ground. */
+    FLOATING_PART: "FLOATING_PART",
+    /** A concrete beam longer than a lintel that rests on masonry alone (no pillar, beam or slab carries it). */
+    BEAM_ON_WEAK_MASONRY: "BEAM_ON_WEAK_MASONRY",
+    /** A concrete pillar or beam below the NBR 6118 minimum section, or a beam between point supports shallower than a tenth of its span. */
+    CONCRETE_BELOW_MIN_SECTION: "CONCRETE_BELOW_MIN_SECTION",
+    /** A concrete pillar or beam with no steel (the construction has no rebar). */
+    UNREINFORCED_CONCRETE: "UNREINFORCED_CONCRETE",
+    /** A brick or block wall laid in stack bond: the vertical joints line up and the wall splits along them. */
+    UNBONDED_MASONRY: "UNBONDED_MASONRY",
+    /** A plastered brick wall without plaster on both faces. */
+    MISSING_PLASTER: "MISSING_PLASTER"
+  };
+  var MAX_PILLAR_SPACING = 4;
+  var MIN_PILLAR_SIDE = 0.19;
+  var MIN_PILLAR_AREA = 0.036;
+  var MIN_BEAM_WIDTH = 0.12;
+  var BEAM_DEPTH_RATIO = 10;
+  var MAX_LINTEL_ON_MASONRY = 3;
+
+  // src/validate/load-path.ts
+  var CONTACT = 0.05;
+  var EPSILON = 5e-3;
+  function groundedParts(parts, supports) {
+    const ids = new Set(parts.map((part) => part.id));
+    const grounded = /* @__PURE__ */ new Set([GROUND]);
+    const bearing = supports.filter((s) => s.bears !== false && ids.has(s.part));
+    let grew = true;
+    while (grew) {
+      grew = false;
+      for (const support of bearing) {
+        if (grounded.has(support.part) || !grounded.has(support.on)) continue;
+        grounded.add(support.part);
+        grew = true;
+      }
+    }
+    return grounded;
+  }
+  function loadPathViolations(structure) {
+    const { parts, supports } = structure;
+    const grounded = groundedParts(parts, supports);
+    const byId = new Map(parts.map((part) => [part.id, part]));
+    const out = [];
+    for (const part of parts) {
+      if (part.role === "none") continue;
+      const pillar = part.role === "column";
+      if (!grounded.has(part.id)) {
+        out.push({ code: pillar ? STRUCTURAL_VIOLATION.PILLAR_NOT_GROUNDED : STRUCTURAL_VIOLATION.FLOATING_PART, part: part.id, message: `${part.id} has no load path to the ground` });
+        continue;
+      }
+      if (!pillar) continue;
+      const bases = supports.filter((s) => s.part === part.id && s.bears !== false);
+      const standsOnBase = bases.some((s) => {
+        if (s.on === GROUND) return part.y0 <= CONTACT;
+        const base = byId.get(s.on);
+        return base !== void 0 && part.y0 >= base.y0 - EPSILON && part.y0 <= base.y1 + CONTACT;
+      });
+      if (!standsOnBase) out.push({ code: STRUCTURAL_VIOLATION.PILLAR_NOT_GROUNDED, part: part.id, message: `${part.id} starts at ${part.y0} m, above what it rests on` });
+    }
+    return out;
+  }
+  var alongOf2 = (part) => {
+    const alongU = part.aabb[2] - part.aabb[0] >= part.aabb[3] - part.aabb[1];
+    return alongU ? { alongU, from: part.aabb[0], to: part.aabb[2], width: part.aabb[3] - part.aabb[1] } : { alongU, from: part.aabb[1], to: part.aabb[3], width: part.aabb[2] - part.aabb[0] };
+  };
+  function bearingsOf(beam, supports, byId) {
+    const frame2 = alongOf2(beam);
+    return supports.filter((s) => s.part === beam.id && s.bears !== false && s.on !== GROUND).map((s) => byId.get(s.on)).filter((on) => on !== void 0).map((on) => {
+      const [low, high] = frame2.alongU ? [on.aabb[0], on.aabb[2]] : [on.aabb[1], on.aabb[3]];
+      return { on, from: Math.max(frame2.from, low), to: Math.min(frame2.to, high) };
+    }).filter((bearing) => bearing.to - bearing.from > -EPSILON);
+  }
+  var isWallLike = (part) => part.role === "wall" || part.role === "partition";
+  var PEDESTAL_RATIO = 3;
+  var isPedestal = (part) => part.role === "column" && part.y1 - part.y0 <= PEDESTAL_RATIO * Math.min(part.aabb[2] - part.aabb[0], part.aabb[3] - part.aabb[1]);
+  function concreteViolations(structure, isMasonry) {
+    const { parts, supports } = structure;
+    const byId = new Map(parts.map((part) => [part.id, part]));
+    const out = [];
+    for (const part of parts) {
+      if (part.material !== "concrete" || part.role !== "column" && part.role !== "beam") continue;
+      if (!structure.construction.frame.rebar && !isPedestal(part)) out.push({ code: STRUCTURAL_VIOLATION.UNREINFORCED_CONCRETE, part: part.id, message: `${part.id} is concrete without steel` });
+      if (part.role === "column") {
+        const sides = [part.aabb[2] - part.aabb[0], part.aabb[3] - part.aabb[1]];
+        if (Math.min(...sides) < MIN_PILLAR_SIDE - EPSILON || sides[0] * sides[1] < MIN_PILLAR_AREA - EPSILON)
+          out.push({ code: STRUCTURAL_VIOLATION.CONCRETE_BELOW_MIN_SECTION, part: part.id, message: `${part.id} is ${sides.map((s) => s.toFixed(2)).join(" x ")} m: NBR 6118 asks at least ${MIN_PILLAR_SIDE} m a side and ${MIN_PILLAR_AREA} m\xB2` });
+        continue;
+      }
+      const castOn = supports.filter((s) => s.on === part.id && s.bears !== false).map((s) => byId.get(s.part)).filter((top) => top !== void 0 && top.role === "beam" && top.material === "concrete" && Math.abs(top.y0 - part.y1) < 0.01).reduce((most, top) => Math.max(most, top.y1 - top.y0), 0);
+      out.push(...beamViolations(part, bearingsOf(part, supports, byId), { isMasonry, castOn }));
+    }
+    return out;
+  }
+  function effectiveSpan(bearings, depth) {
+    const sorted = [...bearings].sort((a, b) => a.from - b.from);
+    let most = 0;
+    for (let k = 1; k < sorted.length; k++) {
+      const previous = sorted.slice(0, k).reduce((a, b) => b.to > a.to ? b : a);
+      const next = sorted[k];
+      const clear = next.from - previous.to;
+      if (clear <= 0) continue;
+      most = Math.max(most, clear + Math.min((previous.to - previous.from) / 2, 0.3 * depth) + Math.min((next.to - next.from) / 2, 0.3 * depth));
+    }
+    return most;
+  }
+  function beamViolations(beam, bearings, context) {
+    const out = [];
+    const frame2 = alongOf2(beam);
+    const length = frame2.to - frame2.from;
+    const depth = beam.y1 - beam.y0 + context.castOn;
+    if (frame2.width < MIN_BEAM_WIDTH - EPSILON) out.push({ code: STRUCTURAL_VIOLATION.CONCRETE_BELOW_MIN_SECTION, part: beam.id, message: `${beam.id} is ${frame2.width.toFixed(2)} m wide: NBR 6118 asks at least ${MIN_BEAM_WIDTH} m` });
+    if (!bearings.length) return out;
+    const continuous = bearings.some((b) => isWallLike(b.on) && b.to - b.from >= length / 2);
+    const span = continuous ? 0 : effectiveSpan(bearings, depth);
+    if (depth < span / BEAM_DEPTH_RATIO - EPSILON) out.push({ code: STRUCTURAL_VIOLATION.CONCRETE_BELOW_MIN_SECTION, part: beam.id, message: `${beam.id} is ${depth.toFixed(2)} m deep over a ${span.toFixed(2)} m span: it needs at least L/${BEAM_DEPTH_RATIO} = ${(span / BEAM_DEPTH_RATIO).toFixed(2)} m` });
+    if (length > MAX_LINTEL_ON_MASONRY && bearings.every((b) => context.isMasonry(b.on)))
+      out.push({ code: STRUCTURAL_VIOLATION.BEAM_ON_WEAK_MASONRY, part: beam.id, message: `${beam.id} spans ${length.toFixed(2)} m on masonry alone: no pillar carries it` });
+    return out;
+  }
+
+  // src/validate/masonry.ts
+  var TOLERANCE3 = 0.05;
+  var AT_POINT = 0.45;
+  var EXPOSED_FINISHES = ["exposed_brick", "exposed_block"];
+  var lineOf2 = (part) => {
+    const alongU = part.aabb[2] - part.aabb[0] >= part.aabb[3] - part.aabb[1];
+    const half = (alongU ? part.aabb[3] - part.aabb[1] : part.aabb[2] - part.aabb[0]) / 2;
+    const [from, to] = alongU ? [part.aabb[0], part.aabb[2]] : [part.aabb[1], part.aabb[3]];
+    return { part, alongU, line: alongU ? part.aabb[1] + half : part.aabb[0] + half, from: from + half, to: to - half, half };
+  };
+  function isMasonryWall(part) {
+    if (!part.id.startsWith("wall_") || !part.assembly || part.role !== "wall" && part.role !== "partition") return false;
+    const units = getAssembly(part.assembly)?.units;
+    return units !== void 0 && units.mortar !== "concrete";
+  }
+  var pointOf2 = (wall, along) => wall.alongU ? [along, wall.line] : [wall.line, along];
+  var alongOfPoint = (wall, point) => wall.alongU ? point[0] : point[1];
+  var acrossOfPoint = (wall, point) => wall.alongU ? point[1] : point[0];
+  var centre = (part) => [(part.aabb[0] + part.aabb[2]) / 2, (part.aabb[1] + part.aabb[3]) / 2];
+  var onLine = (wall, point, slack = 0) => Math.abs(acrossOfPoint(wall, point) - wall.line) <= wall.half + TOLERANCE3 && alongOfPoint(wall, point) >= wall.from - wall.half - slack && alongOfPoint(wall, point) <= wall.to + wall.half + slack;
+  function endKind(wall, along, others) {
+    const point = pointOf2(wall, along);
+    const meeting = others.filter((other) => onLine(other, point));
+    const across = meeting.filter((other) => other.alongU !== wall.alongU);
+    const continued = meeting.length > across.length;
+    if (!across.length) return continued ? "continued" : "free";
+    const atEnd = (other) => Math.min(Math.abs(alongOfPoint(other, point) - other.from), Math.abs(alongOfPoint(other, point) - other.to)) <= other.half + wall.half + TOLERANCE3;
+    return !continued && across.every(atEnd) ? "corner" : "junction";
+  }
+  var masonryBetween = (from, to, windows) => windows.reduce((left, [a, b]) => left - Math.max(0, Math.min(to, b) - Math.max(from, a)), to - from);
+  function pointViolations(context, others) {
+    const { wall, stations } = context;
+    const out = [];
+    const covered = (along) => stations.some((at2) => Math.abs(at2 - along) <= AT_POINT);
+    for (const along of [wall.from, wall.to]) {
+      const kind = endKind(wall, along, others);
+      if (kind === "continued" || covered(along)) continue;
+      const code = kind === "corner" ? STRUCTURAL_VIOLATION.CORNER_WITHOUT_PILLAR : kind === "junction" ? STRUCTURAL_VIOLATION.WALL_JUNCTION_WITHOUT_PILLAR : STRUCTURAL_VIOLATION.WALL_END_WITHOUT_PILLAR;
+      out.push({ code, part: wall.part.id, message: `${wall.part.id} has no pillar at its ${kind} end (${along.toFixed(2)} m along)` });
+    }
+    for (const other of others) {
+      if (other.alongU === wall.alongU) continue;
+      for (const end of [other.from, other.to]) {
+        const point = pointOf2(other, end);
+        const at2 = alongOfPoint(wall, point);
+        if (!onLine(wall, point) || at2 <= wall.from + AT_POINT || at2 >= wall.to - AT_POINT || covered(at2)) continue;
+        out.push({ code: STRUCTURAL_VIOLATION.WALL_JUNCTION_WITHOUT_PILLAR, part: wall.part.id, message: `${other.part.id} meets ${wall.part.id} at ${at2.toFixed(2)} m along with no pillar there` });
+      }
+    }
+    const line = [...stations].sort((a, b) => a - b);
+    for (let k = 1; k < line.length; k++) {
+      const gap = masonryBetween(line[k - 1], line[k], context.windows);
+      if (gap > MAX_PILLAR_SPACING + TOLERANCE3) out.push({ code: STRUCTURAL_VIOLATION.WALL_SPAN_WITHOUT_PILLAR, part: wall.part.id, message: `${wall.part.id} runs ${gap.toFixed(2)} m between pillars (at most ${MAX_PILLAR_SPACING} m)` });
+    }
+    if (!line.length && wall.to - wall.from > MAX_PILLAR_SPACING) out.push({ code: STRUCTURAL_VIOLATION.WALL_SPAN_WITHOUT_PILLAR, part: wall.part.id, message: `${wall.part.id} runs ${(wall.to - wall.from).toFixed(2)} m with no pillar` });
+    return out;
+  }
+  function bondBeamViolations(context, structure) {
+    const { wall, pillars } = context;
+    const resting = new Set(structure.supports.filter((s) => s.on === wall.part.id).map((s) => s.part));
+    const beams = structure.parts.filter((p) => p.beamKind === "bond_beam" && resting.has(p.id));
+    if (!beams.length) return [{ code: STRUCTURAL_VIOLATION.MISSING_BOND_BEAM, part: wall.part.id, message: `${wall.part.id} has no bond beam on top` }];
+    const out = [];
+    for (const pillar of pillars) {
+      const [u, v] = centre(pillar);
+      const over = beams.filter((b) => u >= b.aabb[0] - TOLERANCE3 && u <= b.aabb[2] + TOLERANCE3 && v >= b.aabb[1] - TOLERANCE3 && v <= b.aabb[3] + TOLERANCE3);
+      const carries2 = over.some((b) => pillar.y1 >= b.y0 - TOLERANCE3 && structure.supports.some((s) => s.part === b.id && s.on === pillar.id && s.bears !== false));
+      if (!carries2) out.push({ code: STRUCTURAL_VIOLATION.PILLAR_DOES_NOT_REACH_BOND_BEAM, part: pillar.id, message: `${pillar.id} stops at ${pillar.y1} m and does not carry the bond beam of ${wall.part.id}` });
+    }
+    return out;
+  }
+  function assemblyViolations(part, finish) {
+    const def = getAssembly(part.assembly ?? "");
+    if (!def) return [];
+    const out = [];
+    if (def.units && def.units.bond !== "running") out.push({ code: STRUCTURAL_VIOLATION.UNBONDED_MASONRY, part: part.id, message: `${part.id} is laid in ${def.units.bond} bond: the joints must be staggered` });
+    const plastered = (def.layers ?? []).some((layer) => layer.material === "plaster" && layer.faces === "both");
+    if (def.core.material === "brick" && !plastered && !EXPOSED_FINISHES.includes(finish ?? "")) out.push({ code: STRUCTURAL_VIOLATION.MISSING_PLASTER, part: part.id, message: `${part.id} is brick without plaster on both faces` });
+    return out;
+  }
+  function masonryViolations(structure) {
+    const walls = structure.parts.filter(isMasonryWall);
+    const columns = structure.parts.filter((p) => p.role === "column" && p.material === "concrete");
+    const out = [];
+    for (const part of walls) {
+      out.push(...assemblyViolations(part, structure.construction.walls.finish));
+      if (part.floor === 0 && structure.supports.some((s) => s.part === part.id && s.on === GROUND))
+        out.push({ code: STRUCTURAL_VIOLATION.MISSING_GROUND_BEAM, part: part.id, message: `${part.id} stands on the soil with no ground beam under it` });
+      if (!part.exterior) continue;
+      const wall = lineOf2(part);
+      const pillars = columns.filter((c) => c.floor === part.floor && onLine(wall, centre(c), AT_POINT) && Math.min(c.y1, part.y1) - Math.max(c.y0, part.y0) > 0.5);
+      const windows = structure.openings.filter((o) => o.wall === part.id).map((o) => [o.from, o.to]);
+      const context = { wall, pillars, stations: pillars.map((p) => alongOfPoint(wall, centre(p))), windows };
+      const others = walls.filter((w) => w !== part && w.floor === part.floor).map(lineOf2);
+      out.push(...pointViolations(context, others), ...bondBeamViolations(context, structure));
+    }
+    return out;
+  }
+
+  // src/validate/openings.ts
+  var TOLERANCE4 = 0.05;
+  var LOW_WINDOW = SILL_BEAM_DEPTH + 0.05;
+  function beamAcross(parts, wall, span, side, y) {
+    return parts.some((part) => {
+      const off = part[side] - y;
+      if (part.role !== "beam" || off < -TOLERANCE4 || off > (side === "y0" ? LINTEL_DEPTH2 : TOLERANCE4)) return false;
+      const [from, to, low, high] = wall.alongU ? [part.aabb[0], part.aabb[2], part.aabb[1], part.aabb[3]] : [part.aabb[1], part.aabb[3], part.aabb[0], part.aabb[2]];
+      return from <= span.from + TOLERANCE4 && to >= span.to - TOLERANCE4 && low <= wall.line + TOLERANCE4 && high >= wall.line - TOLERANCE4;
+    });
+  }
+  function windowViolations(opening2, wall, built) {
+    const line = lineOf2(wall);
+    const out = [];
+    if (!beamAcross(built, line, opening2, "y0", opening2.y1)) out.push({ code: STRUCTURAL_VIOLATION.OPENING_WITHOUT_LINTEL, part: opening2.id, message: `window ${opening2.id} in ${wall.id} has no lintel over it` });
+    if (opening2.y0 - wall.y0 > LOW_WINDOW && !beamAcross(built, line, opening2, "y1", opening2.y0))
+      out.push({ code: STRUCTURAL_VIOLATION.OPENING_WITHOUT_SILL, part: opening2.id, message: `window ${opening2.id} in ${wall.id} has no sill beam under it` });
+    return out;
+  }
+  function wallsBeside(door, walls) {
+    const along = door.axis === "u" ? door.u : door.v;
+    const across = door.axis === "u" ? door.v : door.u;
+    const from = along - door.width / 2;
+    const to = along + door.width / 2;
+    return walls.filter((w) => w.floor === door.floor).map(lineOf2).filter((w) => w.alongU === (door.axis === "u") && Math.abs(w.line - across) <= TOLERANCE4 && (Math.abs(w.to - from) <= TOLERANCE4 || Math.abs(w.from - to) <= TOLERANCE4));
+  }
+  function openingViolations(structure, built, doors) {
+    const walls = structure.parts.filter(isMasonryWall);
+    const hosts = new Map(walls.map((wall) => [wall.id, wall]));
+    const out = [];
+    for (const opening2 of structure.openings) {
+      const wall = hosts.get(opening2.wall);
+      if (wall) out.push(...windowViolations(opening2, wall, built));
+    }
+    for (const door of doors) {
+      const beside = wallsBeside(door, walls);
+      if (!beside.length) continue;
+      const along = door.axis === "u" ? door.u : door.v;
+      const span = { from: along - door.width / 2, to: along + door.width / 2 };
+      const lintel = beamAcross(built, beside[0], span, "y0", (structure.levels[door.floor] ?? 0) + DOOR_HEIGHT);
+      if (!lintel) out.push({ code: STRUCTURAL_VIOLATION.OPENING_WITHOUT_LINTEL, part: door.id, message: `door ${door.id} has no lintel over it` });
+    }
+    return out;
+  }
+
+  // src/validate/spec.ts
+  var EPSILON2 = 5e-3;
+  var carries = (part) => part?.structure !== void 0 && part.structure.role !== "none";
+  function flows(joint, byId) {
+    const bears = joint.bears ?? (carries(byId.get(joint.a)) && carries(byId.get(joint.b)));
+    if (bears === false) return [];
+    if (bears === "a_on_b") return [[joint.a, joint.b]];
+    if (bears === "b_on_a") return [[joint.b, joint.a]];
+    return [[joint.a, joint.b], [joint.b, joint.a]];
+  }
+  function groundedOf(spec, byId) {
+    const grounded = new Set(spec.parts.filter((p) => p.anchored || p.structure?.role === "foundation").map((p) => p.id));
+    const edges = (spec.joints ?? []).flatMap((joint) => flows(joint, byId));
+    let grew = true;
+    while (grew) {
+      grew = false;
+      for (const [part, on] of edges) {
+        if (grounded.has(part) || !grounded.has(on)) continue;
+        grounded.add(part);
+        grew = true;
+      }
+    }
+    return grounded;
+  }
+  function sectionViolation(part) {
+    if (part.material !== "concrete" || part.shape.kind !== "box") return null;
+    const role = part.structure?.role;
+    const [x, y, z] = part.shape.size;
+    if (role === "column" && (Math.min(x, z) < MIN_PILLAR_SIDE - EPSILON2 || x * z < MIN_PILLAR_AREA - EPSILON2))
+      return { code: STRUCTURAL_VIOLATION.CONCRETE_BELOW_MIN_SECTION, part: part.id, message: `${part.id} is ${x.toFixed(2)} x ${z.toFixed(2)} m: NBR 6118 asks at least ${MIN_PILLAR_SIDE} m a side` };
+    if (role === "beam" && Math.min(x, z) < MIN_BEAM_WIDTH - EPSILON2 && y >= Math.min(x, z))
+      return { code: STRUCTURAL_VIOLATION.CONCRETE_BELOW_MIN_SECTION, part: part.id, message: `${part.id} is ${Math.min(x, z).toFixed(2)} m wide: NBR 6118 asks at least ${MIN_BEAM_WIDTH} m` };
+    return null;
+  }
+  function specViolations(spec) {
+    const byId = new Map(spec.parts.map((part) => [part.id, part]));
+    const grounded = groundedOf(spec, byId);
+    const out = [];
+    for (const part of spec.parts) {
+      if (!carries(part)) continue;
+      if (!grounded.has(part.id)) {
+        const pillar = part.structure.role === "column";
+        out.push({ code: pillar ? STRUCTURAL_VIOLATION.PILLAR_NOT_GROUNDED : STRUCTURAL_VIOLATION.FLOATING_PART, part: part.id, message: `${part.id} has no load path to an anchored part` });
+      }
+      const section = sectionViolation(part);
+      if (section) out.push(section);
+    }
+    return out;
+  }
+
+  // src/validate/index.ts
+  function validateStructure(structure, options = {}) {
+    const detail = options.wallDetail ?? "panels";
+    const built = applyPanels({ parts: structure.parts, supports: structure.supports }, structure, detail);
+    const out = [...loadPathViolations(structure), ...concreteViolations({ ...built, construction: structure.construction }, isMasonryWall)];
+    if (structure.construction.system !== "masonry") return out;
+    return [...out, ...masonryViolations(structure), ...openingViolations(structure, built.parts, options.doors ?? [])];
+  }
+  function validateSpec(spec) {
+    return specViolations(spec);
+  }
+  function countViolations(violations) {
+    const out = {};
+    for (const violation of violations) out[violation.code] = (out[violation.code] ?? 0) + 1;
+    return out;
+  }
+
   // src/wall-specimen.ts
   var SYSTEM_OF_ASSEMBLY = { log_wall: "log", wood_frame_wall: "wood_frame", sheet_metal_shack: "improvised" };
   var DOOR_WIDTH2 = 0.9;
@@ -9602,7 +10555,7 @@ var GameFloorplanStructure = (() => {
         parts.push({ id, material: c.material, shape: box(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;
@@ -9613,11 +10566,11 @@ var GameFloorplanStructure = (() => {
           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,