@adatechnology/game-floorplan-structure 2.0.2 → 2.1.1

package/dist/index.js

@@ -334,12 +334,15 @@ function createContext(source, construction, extras, tank, options) {
     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(),
@@ -412,7 +415,8 @@ function addBalconies(context) {
       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");
   }
@@ -483,8 +487,8 @@ function addJoists(context, options) {
   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);
@@ -574,8 +578,8 @@ function addPiers(context) {
     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;
@@ -596,18 +600,115 @@ function addFoundation(context) {
   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) => {
@@ -627,7 +728,7 @@ function runsOf(context, walls, floor) {
 }
 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 = [];
@@ -653,7 +754,7 @@ function addPlates(context, walls, floor) {
     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;
@@ -692,7 +793,11 @@ function addCornerPillars(context, walls, floor, plates) {
 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));
@@ -977,21 +1082,21 @@ function addStairs(context) {
 }
 
 // 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);
@@ -1006,18 +1111,39 @@ function addDoorLintels(context) {
     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
@@ -1197,10 +1323,10 @@ function addWallPart(context, wall, floor) {
   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);
@@ -1218,6 +1344,11 @@ function buildFloors(context) {
     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);
@@ -1225,8 +1356,9 @@ function buildStructure(source, options = {}) {
   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);
@@ -1675,13 +1807,13 @@ function placeMeter(plan) {
   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,
@@ -1872,9 +2004,9 @@ function placeInverter(plan) {
   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;
@@ -2082,6 +2214,8 @@ function addOutbuildingPaths(lot, outbuildings, items) {
 
 // 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;
@@ -2091,26 +2225,27 @@ function capacityOf(source, capacities) {
   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 };
 }
@@ -2147,7 +2282,7 @@ function planWaterTank(source, rng, options = {}) {
     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;
@@ -2252,7 +2387,7 @@ function constructionExtension(context) {
 }
 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) {
@@ -2276,7 +2411,7 @@ function register(engine, options = {}) {
   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" }
@@ -2971,6 +3106,8 @@ function splitIntoCourses(wall, openings, spec) {
 // 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];
@@ -2984,6 +3121,7 @@ function splitIntoPanels(wall, openings, style) {
   const drafts = [];
   const piers = [];
   const lintels = [];
+  const sillBeams = [];
   const spandrels = [];
   const height = wall.y1 - wall.y0;
   let cursor = frame.from;
@@ -2994,23 +3132,26 @@ function splitIntoPanels(wall, openings, style) {
   };
   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(frame.from, opening2.from - LINTEL_BEARING2);
     const lintelTo = Math.min(frame.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(frame.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,
@@ -3025,6 +3166,11 @@ function splitIntoPanels(wall, openings, style) {
     ...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];
@@ -3056,7 +3202,8 @@ function panelSplits(input, structure, lintelDepth) {
       ...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);
   }
@@ -3064,7 +3211,18 @@ function panelSplits(input, structure, lintelDepth) {
 }
 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();
@@ -3128,21 +3286,35 @@ var assemblySpec = (part, capacity) => {
 };
 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;
@@ -3158,7 +3330,9 @@ function toDestructibleSpec(structure, options = {}) {
   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;
@@ -3224,8 +3398,362 @@ function onSoil(spec, structure, options) {
   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 frame = 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] = frame.alongU ? [on.aabb[0], on.aabb[2]] : [on.aabb[1], on.aabb[3]];
+    return { on, from: Math.max(frame.from, low), to: Math.min(frame.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 frame = alongOf2(beam);
+  const length = frame.to - frame.from;
+  const depth = beam.y1 - beam.y0 + context.castOn;
+  if (frame.width < MIN_BEAM_WIDTH - EPSILON) out.push({ code: STRUCTURAL_VIOLATION.CONCRETE_BELOW_MIN_SECTION, part: beam.id, message: `${beam.id} is ${frame.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
+import { getAssembly as getAssembly2 } from "@adatechnology/game-destruction";
+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 = getAssembly2(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 = getAssembly2(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
-import { assemblyDepth, assemblyPart as assemblyPart2, getAssembly as getAssembly2 } from "@adatechnology/game-destruction";
+import { assemblyDepth, assemblyPart as assemblyPart2, getAssembly as getAssembly3 } from "@adatechnology/game-destruction";
 var SYSTEM_OF_ASSEMBLY = { log_wall: "log", wood_frame_wall: "wood_frame", sheet_metal_shack: "improvised" };
 var DOOR_WIDTH2 = 0.9;
 var WINDOW_WIDTH = 1;
@@ -3234,7 +3762,7 @@ function openingOf(kind, height) {
 }
 function buildWallSpecimen(options) {
   const { assembly, w, h, opening: opening2 = null, detail = "panels" } = options;
-  const def = getAssembly2(assembly);
+  const def = getAssembly3(assembly);
   if (!def) throw new Error(`unknown assembly "${assembly}"`);
   const system = SYSTEM_OF_ASSEMBLY[assembly] ?? "masonry";
   const depth = assemblyDepth(def);
@@ -3414,7 +3942,7 @@ function addPunchedFacade(spec, g, options = {}) {
       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;
@@ -3425,11 +3953,11 @@ function addPunchedFacade(spec, g, options = {}) {
         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,
@@ -3950,6 +4478,7 @@ var towerLocales = { en: { labels: en_default.labels }, "pt-BR": { labels: pt_BR
 // src/index.ts
 var version = "0.1.0";
 export {
+  BEAM_DEPTH_RATIO,
   CONSTRUCTIONS,
   CONSTRUCTION_SYSTEMS,
   CORE_DEFAULTS,
@@ -3958,8 +4487,14 @@ export {
   DENSITY,
   FLAT_ROOF_DEFAULTS,
   GROUND,
+  GROUND_BEAM_DEPTH,
+  MAX_LINTEL_ON_MASONRY,
+  MAX_PILLAR_SPACING,
   MECHANICAL_DEFAULTS,
   MEMBER_CAGE,
+  MIN_BEAM_WIDTH,
+  MIN_PILLAR_AREA,
+  MIN_PILLAR_SIDE,
   PILE_AREA,
   PILE_DEFAULTS,
   PLATE_DEFAULTS,
@@ -3967,10 +4502,15 @@ export {
   RAFT_THICKNESS,
   REBAR_RATIOS,
   ROOF_COVERINGS,
+  SILL_BEAM_DEPTH,
   SKYSCRAPER_DEFAULTS,
   SKYSCRAPER_MAX_STOREYS,
   SLAB_PANEL_DEFAULTS,
+  STRUCTURAL_VIOLATION,
+  TANK_PILLAR_SIDE,
   TOWER_DEFAULTS,
+  WALL_PILLAR_SIDE,
+  WALL_PILLAR_SPACING,
   addCore,
   addCurtainWall,
   addFlatRoof2 as addFlatRoof,
@@ -3984,16 +4524,19 @@ export {
   buildStructure,
   buildTower,
   buildWallSpecimen,
+  cageResidualCapacity,
   campConstruction,
   chaletConstruction,
   constructionOfSystem,
   coreSize,
+  countViolations,
   damperMass,
   exteriorWindows,
   logCabinConstruction,
   masonryConstruction,
   mechanicalStoreys,
   pilesFor,
+  pillarStations,
   planToSpace,
   planWaterTank,
   register,
@@ -4014,6 +4557,8 @@ export {
   towerLocales,
   towerPlate,
   towerWater,
+  validateSpec,
+  validateStructure,
   version,
   windExposureOf,
   woodFrameConstruction