@adatechnology/game-floorplan-three 0.3.1 → 0.4.0

package/dist/index.global.js

@@ -42,7 +42,9 @@ var GameFloorplanThree = (() => {
     ptBR: () => ptBR,
     rectsOf: () => rectsOf,
     specimenSpec: () => specimenSpec,
-    tapSpec: () => tapSpec
+    tapSpec: () => tapSpec,
+    wallPiece: () => wallPiece,
+    wallPlan: () => wallPlan
   });
 
   // ../game-props3d/dist/index.js
@@ -3461,7 +3463,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
       light(M, x, y, z, color2, range2, kind) {
         into(M).push({ kind: "point", position: [x, y, z], data: { light: true, color: color2, range: range2, kind } });
       },
-      part(id, pivot, ry, draw) {
+      part(id, pivot, ry, draw2) {
         let children = partChildren.get(id);
         if (!children) {
           children = [];
@@ -3472,7 +3474,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         const outer = current;
         current = children;
         try {
-          draw();
+          draw2();
         } finally {
           current = outer;
         }
@@ -4257,7 +4259,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   // src/house/walls.ts
   function installHouseWalls(K, shared) {
     const { EPS: EPS3, Y0, boxC, bx, cursor, effectiveHeight, pieceRecord, structurePiece, wallColor } = K;
-    function wallBox(alongU, L, a, b, ya, yb, th, cL, cH, mL, mH) {
+    function wallBox2(alongU, L, a, b, ya, yb, th, cL, cH, mL, mH) {
       if (yb - ya < 1e-4 || b - a < 1e-4) return;
       if (alongU) {
         bx(mL, a, ya, L - th / 2, b, yb, L, cL);
@@ -4324,7 +4326,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
           continue;
         }
         const seg = (a, b, ya, yb) => {
-          wallBox(alongU, L, a, b, y0 + ya, y0 + yb, th, sideL.color, sideH.color, sideL.mat, sideH.mat);
+          wallBox2(alongU, L, a, b, y0 + ya, y0 + yb, th, sideL.color, sideH.color, sideL.mat, sideH.mat);
         };
         const win = R.windows.filter((j) => j.floor === f && j.axis === w.axis && Math.abs(j.pos - L) < EPS3 && j.at + j.width / 2 > s0 + EPS3 && j.at - j.width / 2 < s1 - EPS3).sort((p, q) => p.at - q.at);
         let cur = s0;
@@ -4356,13 +4358,13 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         bx(e.color.mat, e.pu - e.th / 2, e.y0, e.pv - e.th / 2, e.pu + e.th / 2, e.y0 + e.hh, e.pv + e.th / 2, e.color.color);
       }
     }
-    Object.assign(K, { wallBox, sideOf, pieceOf, nearestWall, walls });
+    Object.assign(K, { wallBox: wallBox2, sideOf, pieceOf, nearestWall, walls });
   }
 
   // src/house/doors.ts
   function installHouseDoors(K, shared) {
     const seedKey = (id) => K.seedKey(id);
-    const { EPS: EPS3, Y0, boxC, bx, cursor, effectiveHeight, nearestWall, part, pieceOf, pieceRecord, roomAt, sideOf, wallBox } = K;
+    const { EPS: EPS3, Y0, boxC, bx, cursor, effectiveHeight, nearestWall, part, pieceOf, pieceRecord, roomAt, sideOf, wallBox: wallBox2 } = K;
     const SEED = (...a) => K.SEED(...a);
     const definePiece = (...a) => K.definePiece(...a);
     const rngString = (...a) => K.rngString(...a);
@@ -4387,7 +4389,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         if (!cut && wallHeight > dH + 1e-3) {
           const wv = nearestWall(f, p.axis, L, p.at);
           cursor.pc = wv ? pieceOf(wv) : null;
-          wallBox(alongU, L, a, b, y0 + dH, y0 + effectiveHeight(f, wallHeight), th, lL.color, lH.color, lL.mat, lH.mat);
+          wallBox2(alongU, L, a, b, y0 + dH, y0 + effectiveHeight(f, wallHeight), th, lL.color, lH.color, lL.mat, lH.mat);
           cursor.pc = null;
         }
         const fb = (u0, y_0, u1, y_1, tt = th + 0.02, color2 = frame2) => alongU ? bx("wood", u0, y0 + y_0, L - tt / 2, u1, y0 + y_1, L + tt / 2, color2) : bx("wood", L - tt / 2, y0 + y_0, u0, L + tt / 2, y0 + y_1, u1, color2);
@@ -5335,8 +5337,8 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
         t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
         return ((t ^ t >>> 14) >>> 0) / 4294967296;
       };
-      const draw = rnd() < p, light = rnd() < 0.6;
-      void draw;
+      const draw2 = rnd() < p, light = rnd() < 0.6;
+      void draw2;
       const on = true;
       return { on, rnd, color: high ? 3816770 : light ? 15527921 : 10857392, bad: (shared.ctx.colors.meta && shared.ctx.colors.meta.state) === "abandoned" || R.state === "abandoned", fallback: false };
     }
@@ -16157,6 +16159,9 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   };
 
   // ../game-floorplan-structure/dist/index.js
+  var __defProp2 = Object.defineProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   var uniform = (joint) => ({ wall: joint, slab: joint, beam: joint, column: joint, truss: joint });
   var CONSTRUCTION_SYSTEMS = /* @__PURE__ */ new Map([
     ["masonry", { walls: "brick_wall_plastered", joints: { wall: "mortar", slab: "rebar", beam: "mortar", column: "rebar", truss: "bolt" }, slabThickness: 0.12, plateThickness: 0.2, timber: false, wallRole: "rules", wallFill: 1 }],
@@ -16165,10 +16170,59 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     ["improvised", { walls: "sheet_metal_shack", joints: uniform("nail"), slabThickness: 0.2, plateThickness: 0.1, timber: true, wallRole: "partition", wallFill: 1 }],
     ["canvas", { walls: "", joints: uniform("tie"), slabThickness: 0, plateThickness: 0, timber: false, wallRole: "partition", wallFill: 1 }]
   ]);
+  var ROOF_COVERINGS = /* @__PURE__ */ new Map([
+    ["colonial", { material: "ceramic", joint: "resting" }],
+    ["fiber_cement", { material: "concrete", joint: "bolt" }],
+    ["slab", { material: "concrete", joint: "rebar" }],
+    ["asphalt", { material: "plastic", joint: "nail" }],
+    ["zinc", { material: "steel", joint: "nail" }],
+    ["wood", { material: "wood_soft", joint: "nail" }],
+    ["canvas", { material: "fabric", joint: "tie" }],
+    ["thatch", { material: "foliage", joint: "tie" }]
+  ]);
+  var WALL_THICKNESS = 0.15;
   var round2 = (value) => Math.round(value * 100) / 100;
   function touches(a, b, tolerance) {
     return a[0] < b[2] + tolerance && a[2] > b[0] - tolerance && a[1] < b[3] + tolerance && a[3] > b[1] - tolerance;
   }
+  function distanceBetween(a, b) {
+    return Math.hypot(Math.max(a[0] - b[2], b[0] - a[2], 0), Math.max(a[1] - b[3], b[1] - a[3], 0));
+  }
+  function unionOf(rects) {
+    const out = [1e9, 1e9, -1e9, -1e9];
+    for (const rect of rects) {
+      out[0] = Math.min(out[0], rect[0]);
+      out[1] = Math.min(out[1], rect[1]);
+      out[2] = Math.max(out[2], rect[2]);
+      out[3] = Math.max(out[3], rect[3]);
+    }
+    return out;
+  }
+  function wallBox(wall) {
+    const half = (wall.thickness ?? WALL_THICKNESS) / 2;
+    return [Math.min(wall.u0, wall.u1) - half, Math.min(wall.v0, wall.v1) - half, Math.max(wall.u0, wall.u1) + half, Math.max(wall.v0, wall.v1) + half];
+  }
+  var SLAB_COVERING = "slab";
+  var PLASTERED_FINISHES = ["plaster", "partial_plaster"];
+  function masonryConstruction(source) {
+    const unit = source.floorNumber !== void 0;
+    const covering = unit ? SLAB_COVERING : source.facade.roof ?? "colonial";
+    const finish = source.facade.finish ?? "roughcast";
+    const budget = source.style === "budget";
+    const flat = unit || covering === SLAB_COVERING;
+    return {
+      system: "masonry",
+      walls: { material: "brick", cladding: PLASTERED_FINISHES.includes(finish) ? "plaster" : null, finish, thickness: WALL_THICKNESS, ...finish === "exposed_block" ? { assembly: "concrete_block_wall" } : {} },
+      floor: { material: budget ? "concrete" : "ceramic", finish: budget ? "burnt_cement" : "ceramic_tile" },
+      roof: { material: ROOF_COVERINGS.get(covering)?.material ?? "ceramic", covering, shape: flat ? "slab" : "gable", pitch: flat ? 0 : covering === "colonial" ? 30 : 15, timber: "wood_soft" },
+      frame: { material: "concrete", pillars: "concrete", beams: "concrete", slabs: "concrete", timber: "wood_soft", rebar: "steel" },
+      foundation: { type: unit ? "building" : "strip_footing", material: "concrete", elevation: 0 }
+    };
+  }
+  function resolveConstruction(source) {
+    const extras = source.structureExtras ?? {};
+    return { construction: source.construction ?? masonryConstruction(source), extras };
+  }
   var en_default = {
     ui: {
       structure_layer: "Structure",
@@ -16239,8 +16293,950 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   };
   var DEFAULT_DENSITY = 500;
   var densityOf = (material) => DENSITY[material] ?? DEFAULT_DENSITY;
+  var StructureBuilder = class {
+    constructor() {
+      __publicField(this, "parts", []);
+      __publicField(this, "supports", []);
+      __publicField(this, "ids", /* @__PURE__ */ new Set());
+    }
+    add(draft, options = {}) {
+      const { id, role, material, aabb, y0, y1 } = draft;
+      if (this.ids.has(id)) throw new Error(`Part repeated in the structure: ${id}`);
+      this.ids.add(id);
+      const { floor, fill: fill2, ...extras } = options;
+      const volume = Math.max(0, (aabb[2] - aabb[0]) * (aabb[3] - aabb[1]) * (y1 - y0)) * (fill2 ?? 1);
+      const part = {
+        id,
+        role,
+        material,
+        aabb: aabb.map(round2),
+        y0: round2(y0),
+        y1: round2(y1),
+        floor: floor ?? 0,
+        mass: Math.max(1, Math.round(volume * densityOf(material)))
+      };
+      for (const [key, value] of Object.entries(extras)) if (value !== void 0) part[key] = value;
+      this.parts.push(part);
+      return part;
+    }
+    rest(part, on, joint) {
+      const id = typeof part === "string" ? part : part.id;
+      const base = typeof on === "string" ? on : on.id;
+      this.supports.push({ part: id, on: base === GROUND ? GROUND : base, joint });
+    }
+    has(id) {
+      return this.ids.has(id);
+    }
+    find(id) {
+      return this.parts.find((part) => part.id === id);
+    }
+  };
+  function hashLegacyKey(key) {
+    let hash = 1779033703 ^ key.length;
+    for (let i = 0; i < key.length; i++) {
+      hash = Math.imul(hash ^ key.charCodeAt(i), 3432918353);
+      hash = hash << 13 | hash >>> 19;
+    }
+    hash = Math.imul(hash ^ hash >>> 16, 2246822507);
+    hash = Math.imul(hash ^ hash >>> 13, 3266489909);
+    return (hash ^ hash >>> 16) >>> 0;
+  }
   var OPEN_ROOM_TYPES2 = ["balcony", "terrace", "porch"];
+  var GUARD_HEIGHT = 1.1;
+  function createContext(source, construction, extras, tank, options) {
+    const system = CONSTRUCTION_SYSTEMS.get(construction.system);
+    if (!system) throw new Error(`Unknown construction system "${construction.system}"`);
+    const floorCount2 = source.floors.length;
+    const isUnit = source.floorNumber !== void 0;
+    const elevation = construction.foundation.elevation || 0;
+    const level = (floor) => round2(elevation + (source.floors[floor]?.y0 ?? 0));
+    const ceilingOf = (floor) => source.floors[floor]?.ceiling ?? 0;
+    const topOf = (floor) => floor < floorCount2 - 1 && !isUnit ? level(floor + 1) - system.slabThickness : level(floor) + ceilingOf(floor);
+    const rectsOf2 = (floor, exclude = []) => source.rooms.filter((room) => room.floor === floor && !exclude.includes(room.type)).flatMap((room) => room.parts);
+    const builder = new StructureBuilder();
+    const context = {
+      source,
+      construction,
+      system,
+      extras,
+      tank,
+      builder,
+      porchRoofOnPostsOnly: options.porchRoofOnPostsOnly,
+      rafterRoof: options.rafterRoof,
+      floorCount: floorCount2,
+      isUnit,
+      elevation,
+      isTimber: system.timber,
+      walls: [],
+      wallParts: /* @__PURE__ */ new Map(),
+      carriers: /* @__PURE__ */ new Map(),
+      plates: /* @__PURE__ */ new Map(),
+      pillars: /* @__PURE__ */ new Map(),
+      porches: /* @__PURE__ */ new Map(),
+      base0: GROUND,
+      houseBox: [0, 0, 0, 0],
+      topBox: [0, 0, 0, 0],
+      hasBasement: false,
+      roof: { shape: "slab", covering: "", material: "", pitch: 0, bearingFloor: 0, panes: [], trusses: 0 },
+      level,
+      ceilingOf,
+      topOf,
+      rectsOf: rectsOf2,
+      baseOf: (floor) => floor === 0 ? context.base0 : builder.find(`slab_${floor}`)
+    };
+    const closed = rectsOf2(0, ["balcony", "porch"]);
+    context.houseBox = unionOf(closed.length ? closed : rectsOf2(0));
+    context.walls = classifyWalls(context);
+    return context;
+  }
+  var isBearingOnTop = (wall, walls) => {
+    const along = (w, pick2) => w.axis === "u" ? pick2(w.u0, w.u1) : pick2(w.v0, w.v1);
+    const across = (w) => w.axis === "u" ? w.v0 : w.u0;
+    return walls.some(
+      (other) => other.floor === wall.floor + 1 && other.type === "wall" && other.axis === wall.axis && Math.abs(across(other) - across(wall)) < 0.2 && Math.min(along(wall, Math.max), along(other, Math.max)) - Math.max(along(wall, Math.min), along(other, Math.min)) > 0.3
+    );
+  };
+  function roleOf(context, wall, walls, porchIds) {
+    if (wall.type === "railing") return "partition";
+    const { wallRole } = context.system;
+    if (wallRole === "bearing") return "wall";
+    if (wallRole === "partition") return "partition";
+    const bearingFloor = context.construction.roof.bearingFloor ?? context.floorCount - 1;
+    if (wall.floor > bearingFloor) return "partition";
+    if (wall.exterior || wall.sides.some((id) => porchIds.has(id))) return "wall";
+    return wall.floor < context.floorCount - 1 && isBearingOnTop(wall, walls) ? "wall" : "partition";
+  }
+  function materialOf(context, wall) {
+    const { walls, guard } = context.construction;
+    if (wall.type === "railing") return guard ?? (context.isTimber ? "wood_soft" : "steel");
+    if (walls.mixed?.length) return walls.mixed[hashLegacyKey(wall.legacyKey) % walls.mixed.length];
+    return wall.exterior ? walls.material : walls.interior ?? walls.material;
+  }
+  function classifyWalls(context) {
+    const countByFloor = /* @__PURE__ */ new Map();
+    const all = context.source.walls.map((wall) => {
+      const index = countByFloor.get(wall.floor) ?? 0;
+      countByFloor.set(wall.floor, index + 1);
+      return { ...wall, id: `wall_${wall.floor}_${index}`, legacyKey: `w${wall.floor}_${index}`, role: "wall", material: "", box: wallBox(wall) };
+    });
+    const built = all.filter((wall) => wall.type === "wall" || wall.type === "railing");
+    const porchIds = new Set(context.source.rooms.filter((room) => room.type === "porch").map((room) => room.id));
+    for (const wall of built) {
+      wall.role = roleOf(context, wall, built, porchIds);
+      wall.material = materialOf(context, wall);
+    }
+    return built;
+  }
+  var guardHeightOf = (wall) => wall.h || GUARD_HEIGHT;
+  function addBalconies(context) {
+    const { builder, construction, system } = context;
+    for (const room of context.source.rooms.filter((r) => r.type === "balcony" && r.floor >= 0)) {
+      const floor = room.floor;
+      const box22 = unionOf(room.parts);
+      const base = floor === 0 ? void 0 : context.baseOf(floor);
+      const deck = builder.add({ id: `slab_${floor}_${room.id}`, role: "slab", material: construction.frame.slabs, aabb: box22, y0: context.level(floor) - system.slabThickness, y1: context.level(floor) }, { floor });
+      if (base) {
+        builder.rest(deck, base, system.joints.slab);
+        continue;
+      }
+      const pillar = builder.add({ id: `balcony_column_${room.id}`, role: "column", material: construction.frame.pillars, aabb: [box22[0] - 0.08, box22[1] - 0.08, box22[0] + 0.08, box22[1] + 0.08], y0: 0, y1: context.level(floor) - system.slabThickness }, { floor: 0 });
+      builder.rest(pillar, GROUND, "rebar");
+      builder.rest(deck, pillar, "rebar");
+    }
+  }
+  var GROUNDSHEET = 0.02;
+  function buildCanvasStructure(construction, extras) {
+    const builder = new StructureBuilder();
+    const panes = [];
+    for (const tent of extras.tents ?? []) {
+      const [u0, v0, u1, v1] = tent.aabb;
+      const centreU = (u0 + u1) / 2;
+      const centreV = (v0 + v1) / 2;
+      const sheet = builder.add({ id: `groundsheet_${tent.id}`, role: "slab", material: "plastic", aabb: tent.aabb, y0: 0, y1: GROUNDSHEET }, { floor: 0, tent: tent.id });
+      builder.rest(sheet, GROUND, "resting");
+      const canvas = builder.add({ id: `canvas_${tent.id}`, role: "roof", material: "fabric", aabb: tent.aabb, y0: GROUNDSHEET, y1: tent.height }, { floor: 0, fill: 0.04, tent: tent.id, form: tent.kind });
+      panes.push(canvas.id);
+      const poles = tent.kind === "tunnel" ? [0.25, 0.75].map((fraction, k) => [[u0 + (u1 - u0) * fraction - 0.015, v0 + 0.05, u0 + (u1 - u0) * fraction + 0.015, v1 - 0.05], k]) : [[[u0 + 0.05, centreV - 0.015, u1 - 0.05, centreV + 0.015], 0], [[centreU - 0.015, v0 + 0.05, centreU + 0.015, v1 - 0.05], 1]];
+      for (const [aabb, k] of poles) {
+        const pole = builder.add({ id: `pole_${tent.id}_${k}`, role: "column", material: construction.frame.pillars, aabb, y0: GROUNDSHEET, y1: tent.height - GROUNDSHEET }, { floor: 0, fill: 0.05, tent: tent.id });
+        builder.rest(pole, GROUND, "resting");
+        builder.rest(canvas, pole, "tie");
+      }
+      const corners = [[u0 - 0.2, v0 - 0.2], [u1 + 0.2, v0 - 0.2], [u0 - 0.2, v1 + 0.2], [u1 + 0.2, v1 + 0.2]];
+      corners.forEach(([u, v], k) => {
+        const peg = builder.add({ id: `peg_${tent.id}_${k}`, role: "column", material: "wood_soft", aabb: [u - 0.02, v - 0.02, u + 0.02, v + 0.02], y0: 0, y1: 0.2 }, { floor: 0 });
+        builder.rest(peg, GROUND, "nail");
+        builder.rest(canvas, peg, "tie");
+      });
+    }
+    const roof = { shape: "tent", covering: "canvas", material: "fabric", pitch: 0, bearingFloor: 0, panes, trusses: 0 };
+    return { parts: builder.parts, supports: builder.supports, levels: [0], elevation: 0, roof, construction, framed: false, openings: [] };
+  }
+  var CHIMNEY_CLEARANCE_ABOVE_RIDGE = 0.6;
+  function addChimney(context) {
+    const chimney = context.extras.chimney;
+    if (!chimney) return;
+    const { builder } = context;
+    const top = context.floorCount - 1;
+    const ridge = context.roof.ridge || context.level(top) + context.ceilingOf(top);
+    const height = Math.max(ridge, chimney.top || 0) + CHIMNEY_CLEARANCE_ABOVE_RIDGE;
+    const part = builder.add({ id: "chimney", role: "column", material: chimney.material || "brick", aabb: chimney.aabb, y0: chimney.flue ? context.level(0) : 0, y1: height }, { floor: 0, fill: chimney.flue ? 0.15 : 0.7 });
+    if (chimney.flue) builder.rest(part, context.base0 ?? GROUND, "resting");
+    else builder.rest(part, GROUND, "mortar");
+    const walls = builder.parts.filter((wall) => wall.role === "wall" && wall.floor === 0 && !wall.id.startsWith("basement") && touches(wall.aabb, part.aabb, 0.1));
+    for (const wall of walls) builder.rest(part, wall, "bolt");
+    chimney.height = round2(height);
+  }
+  function addWell(context) {
+    const well = context.extras.well;
+    if (!well) return;
+    const part = context.builder.add({ id: "well", role: "column", material: "stone", aabb: well.aabb, y0: -0.5, y1: well.height || 0.9 }, { floor: 0, fill: 0.5 });
+    context.builder.rest(part, GROUND, "mortar");
+  }
+  var JOIST_PITCH = 0.6;
+  function addJoists(context, options) {
+    const { floor, box: box22, thickness, carriers, material, joint, suffix = "" } = options;
+    const length = box22[2] - box22[0];
+    const depth = box22[3] - box22[1];
+    const alongU = length >= depth;
+    const span = alongU ? length : depth;
+    const count = Math.max(2, Math.round(span / JOIST_PITCH) + 1);
+    const top = context.level(floor) - thickness * 0.15;
+    const out = [];
+    for (let k = 0; k < count; k++) {
+      const centre = (alongU ? box22[0] : box22[1]) + 0.05 + k * (span - 0.1) / (count - 1);
+      const aabb = alongU ? [centre - 0.025, box22[1], centre + 0.025, box22[3]] : [box22[0], centre - 0.025, box22[2], centre + 0.025];
+      const 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);
+      const touching = below.filter((carrier) => touches(aabb, carrier.aabb, 0.2));
+      const pool = below.length ? below : carriers;
+      const chosen = touching.length ? touching : pool.slice().sort((a, b) => distanceBetween(aabb, a.aabb) - distanceBetween(aabb, b.aabb)).slice(0, 1);
+      for (const carrier of chosen) context.builder.rest(joist, carrier, joint);
+    }
+    return out;
+  }
+  function addDeck(context, id, material, options, joists) {
+    const { floor, box: box22, thickness, joint } = options;
+    const deck = context.builder.add({ id, role: "slab", material, aabb: box22, y0: context.level(floor) - thickness * 0.15, y1: context.level(floor) }, { floor });
+    for (const joist of joists) context.builder.rest(deck, joist, joint);
+    return deck;
+  }
+  var raft = (context, thickness, material) => {
+    const [u0, v0, u1, v1] = context.houseBox;
+    const part = context.builder.add({ id: "foundation_raft", role: "slab", material, aabb: [u0 - 0.1, v0 - 0.1, u1 + 0.1, v1 + 0.1], y0: 0, y1: thickness }, { floor: 0 });
+    context.builder.rest(part, GROUND, "resting");
+    return part;
+  };
+  function addBuildingBase(context) {
+    const { builder, construction, houseBox: box22 } = context;
+    const corners = [[box22[0], box22[1]], [box22[2], box22[1]], [box22[0], box22[3]], [box22[2], box22[3]]];
+    const top = context.level(0) - context.system.slabThickness;
+    const pillars = corners.map(([u, v], k) => {
+      const pillar = builder.add({ id: `building_column_${k}`, role: "column", material: construction.frame.pillars, aabb: [u - 0.15, v - 0.15, u + 0.15, v + 0.15], y0: 0, y1: top }, { floor: 0 });
+      builder.rest(pillar, GROUND, "rebar");
+      return pillar;
+    });
+    const slab = builder.add({ id: "slab_base", role: "slab", material: construction.frame.slabs, aabb: box22, y0: top, y1: context.level(0) }, { floor: 0, footprint: [box22] });
+    for (const pillar of pillars) builder.rest(slab, pillar, "rebar");
+    context.base0 = slab;
+  }
+  function addBasement(context) {
+    const { builder, houseBox: box22, elevation } = context;
+    const depth = context.construction.foundation.depth || 2.4;
+    const floor = builder.add({ id: "basement_slab", role: "slab", material: "concrete", aabb: box22, y0: -depth - 0.15, y1: -depth }, { floor: -1 });
+    builder.rest(floor, GROUND, "resting");
+    const sides = [
+      ["front", [box22[0], box22[1] - 0.1, box22[2], box22[1] + 0.1]],
+      ["back", [box22[0], box22[3] - 0.1, box22[2], box22[3] + 0.1]],
+      ["left", [box22[0] - 0.1, box22[1], box22[0] + 0.1, box22[3]]],
+      ["right", [box22[2] - 0.1, box22[1], box22[2] + 0.1, box22[3]]]
+    ];
+    const carried = [];
+    for (const [name, aabb] of sides) {
+      const wall = builder.add({ id: `basement_wall_${name}`, role: "wall", material: "concrete", aabb, y0: -depth, y1: elevation }, { floor: -1 });
+      builder.rest(wall, GROUND, "rebar");
+      builder.rest(wall, floor, "rebar");
+      carried.push(wall);
+    }
+    const count = Math.max(1, Math.floor((box22[2] - box22[0]) / 3));
+    for (let k = 0; k < count; k++) {
+      const u = box22[0] + (k + 0.5) * (box22[2] - box22[0]) / count;
+      const v = (box22[1] + box22[3]) / 2;
+      const column = builder.add({ id: `basement_column_${k}`, role: "column", material: "concrete", aabb: [u - 0.15, v - 0.15, u + 0.15, v + 0.15], y0: -depth, y1: elevation - 0.3 }, { floor: -1 });
+      builder.rest(column, floor, "rebar");
+      builder.rest(column, GROUND, "rebar");
+      carried.push(column);
+    }
+    context.hasBasement = true;
+    return carried;
+  }
+  function addPiers(context) {
+    const { builder, houseBox: box22, elevation, construction } = context;
+    const columns = Math.max(2, Math.ceil((box22[2] - box22[0]) / 2) + 1);
+    const rows = Math.max(2, Math.ceil((box22[3] - box22[1]) / 2) + 1);
+    const height = Math.max(0.1, elevation - context.system.slabThickness - 0.15);
+    const piers = [];
+    for (let j = 0; j < rows; j++) {
+      for (let i = 0; i < columns; i++) {
+        const u = box22[0] + i * (box22[2] - box22[0]) / (columns - 1);
+        const v = box22[1] + j * (box22[3] - box22[1]) / (rows - 1);
+        const pier = builder.add({ id: `footing_pier_${j}_${i}`, role: "column", material: construction.foundation.material || "concrete", aabb: [u - 0.12, v - 0.12, u + 0.12, v + 0.12], y0: 0, y1: height }, { floor: 0 });
+        builder.rest(pier, GROUND, "resting");
+        piers.push(pier);
+      }
+    }
+    const alongU = box22[2] - box22[0] >= box22[3] - box22[1];
+    const beams = [];
+    const lines = alongU ? rows : columns;
+    for (let line = 0; line < lines; line++) {
+      const at2 = alongU ? box22[1] + line * (box22[3] - box22[1]) / (rows - 1) : box22[0] + line * (box22[2] - box22[0]) / (columns - 1);
+      const aabb = alongU ? [box22[0], at2 - 0.07, box22[2], at2 + 0.07] : [at2 - 0.07, box22[1], at2 + 0.07, box22[3]];
+      const beam = builder.add({ id: `base_beam_${line}`, role: "beam", material: construction.frame.timber, aabb, y0: height, y1: elevation - context.system.slabThickness }, { floor: 0 });
+      const centre = (q) => alongU ? (q.aabb[1] + q.aabb[3]) / 2 : (q.aabb[0] + q.aabb[2]) / 2;
+      for (const pier of piers.filter((q) => Math.abs(centre(q) - at2) < 0.05)) builder.rest(beam, pier, "bolt");
+      beams.push(beam);
+    }
+    return beams;
+  }
+  function addRaisedFloor(context) {
+    const { construction, system, houseBox: box22 } = context;
+    const carriers = construction.foundation.type === "basement" ? addBasement(context) : addPiers(context);
+    const thickness = system.slabThickness;
+    const joists = addJoists(context, { floor: 0, box: box22, thickness, carriers, material: construction.frame.timber, joint: construction.foundation.type === "basement" ? "bolt" : "nail" });
+    const deckMaterial = context.isTimber ? construction.floor.material === "wood_hard" ? "wood_hard" : "plywood" : construction.frame.slabs;
+    context.base0 = addDeck(context, "slab_0", deckMaterial, { floor: 0, box: box22, thickness, joint: "nail" }, joists);
+  }
+  function addFoundation(context) {
+    const { type, material } = context.construction.foundation;
+    if (context.isUnit) return addBuildingBase(context);
+    if (type === "raft") context.base0 = raft(context, Math.max(0.1, context.elevation), material || "concrete");
+    else if (type === "crawl_space" || type === "piles" || type === "basement") addRaisedFloor(context);
+    else if (context.isTimber && type !== "ground") context.base0 = raft(context, Math.max(0.12, context.elevation), "concrete");
+  }
+  var MAX_GAP_WITHIN_RUN = 3.2;
+  var POST_SPACING = 2.4;
+  var POST_SIDE = 0.05;
+  var alongOf = (wall, pick2) => wall.axis === "u" ? pick2(wall.u0, wall.u1) : pick2(wall.v0, wall.v1);
+  var acrossOf = (wall) => wall.axis === "u" ? wall.v0 : wall.u0;
+  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)}`;
+      lines.set(key, [...lines.get(key) ?? [], wall]);
+    }
+    return [...lines.values()].map((line) => {
+      const sorted = line.slice().sort((a, b) => alongOf(a, Math.min) - alongOf(b, Math.min));
+      const runs = [];
+      for (const wall of sorted) {
+        const from = alongOf(wall, Math.min);
+        const to = alongOf(wall, Math.max);
+        const last = runs[runs.length - 1];
+        if (last && from - last.to <= MAX_GAP_WITHIN_RUN) {
+          last.to = Math.max(last.to, to);
+          last.walls.push(wall);
+        } else runs.push({ from, to, walls: [wall] });
+      }
+      return runs;
+    });
+  }
+  function addShackPosts(context, run, plate, floor, index) {
+    const first = run.walls[0];
+    const across = acrossOf(first);
+    const top = context.wallParts.get(first.id).y1;
+    const count = Math.max(1, Math.ceil((run.to - run.from) / POST_SPACING));
+    const posts = [];
+    for (let k = 0; k <= count; k++) {
+      const along = run.from + (run.to - run.from) * k / count;
+      const [u, v] = first.axis === "u" ? [along, across] : [across, along];
+      const half = 0.05 + POST_SIDE / 2;
+      const post = context.builder.add({ id: `post_${floor}_${index}_${k}`, role: "column", material: "wood_soft", aabb: [u - half, v - half, u + half, v + half], y0: context.level(floor), y1: top }, { floor });
+      const base = context.baseOf(floor);
+      if (base === GROUND || !base) context.builder.rest(post, GROUND, "tie");
+      else context.builder.rest(post, base, "nail");
+      context.builder.rest(plate, post, "nail");
+      posts.push(post);
+    }
+    return posts;
+  }
+  function addPlates(context, walls, floor) {
+    const { builder, system, construction } = context;
+    const plates = [];
+    const pillars = [];
+    let counter = 0;
+    for (const runs of runsOf(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 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;
+        const plate = builder.add({ id: `plate_${floor}_${counter++}`, role: "beam", material, aabb, y0: top, y1: top + system.plateThickness }, { floor, beamKind: context.isTimber ? "plate" : "bond_beam" });
+        if (construction.system === "improvised") pillars.push(...addShackPosts(context, run, plate, floor, counter));
+        else for (const wall of run.walls) builder.rest(plate, context.wallParts.get(wall.id), system.joints.beam);
+        plates.push(plate);
+      }
+    }
+    return { plates, pillars };
+  }
+  function cornerPoints(walls) {
+    const ends = walls.filter((wall) => wall.exterior && wall.type === "wall").flatMap(
+      (wall) => wall.axis === "u" ? [[Math.min(wall.u0, wall.u1), wall.v0, "u"], [Math.max(wall.u0, wall.u1), wall.v0, "u"]] : [[wall.u0, Math.min(wall.v0, wall.v1), "v"], [wall.u0, Math.max(wall.v0, wall.v1), "v"]]
+    );
+    const points = [];
+    for (const a of ends) {
+      const joinsOtherAxis = ends.some((b) => b[2] !== a[2] && Math.hypot(a[0] - b[0], a[1] - b[1]) < 0.12);
+      if (joinsOtherAxis && !points.some((q) => Math.hypot(q[0] - a[0], q[1] - a[1]) < 0.12)) points.push([a[0], a[1]]);
+    }
+    return points;
+  }
+  function addCornerPillars(context, walls, floor, plates) {
+    const { builder } = context;
+    const topOfFloor = context.topOf(floor);
+    return cornerPoints(walls).map(([u, v], k) => {
+      const box22 = [u - 0.1, v - 0.1, u + 0.1, v + 0.1];
+      const top = Math.max(topOfFloor, ...plates.filter((plate) => touches(plate.aabb, box22, 0.05)).map((plate) => plate.y0));
+      const pillar = builder.add({ id: `column_${floor}_${k}`, role: "column", material: context.construction.frame.pillars, aabb: box22, y0: context.level(floor), y1: top }, { floor });
+      const base = context.baseOf(floor);
+      builder.rest(pillar, base === GROUND || !base ? GROUND : base, "rebar");
+      for (const plate of plates.filter((p) => touches(p.aabb, pillar.aabb, 0.05))) builder.rest(plate, pillar, "rebar");
+      return pillar;
+    });
+  }
+  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));
+    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));
+    context.carriers.set(floor, [...plates, ...pillars, ...innerBearing]);
+  }
+  var POST_HALF = 0.08;
+  var FOOTING_HALF = 0.12;
+  var BEAM_DEPTH = 0.2;
+  var BEAM_WIDTH = 0.16;
+  function addPosts(context, porchId, rect, deck, floor) {
+    const { builder, construction } = context;
+    const hasUpperFloor = floor < context.floorCount - 1;
+    const ceilingY = hasUpperFloor ? context.level(floor + 1) - context.system.slabThickness : context.level(floor) + context.ceilingOf(floor);
+    const deckDepth = Math.min(0.2, Math.max(0.06, context.elevation * 0.5));
+    const spots = [[rect[0] + 0.1, rect[1] + 0.1], [rect[2] - 0.1, rect[1] + 0.1]];
+    if (rect[2] - rect[0] > 4.5) spots.push([(rect[0] + rect[2]) / 2, rect[1] + 0.1]);
+    const posts = spots.map(([u, v], k) => {
+      const footing = builder.add({ id: `porch_footing_${porchId}_${k}`, role: "column", material: "concrete", aabb: [u - FOOTING_HALF, v - FOOTING_HALF, u + FOOTING_HALF, v + FOOTING_HALF], y0: 0, y1: context.level(floor) - deckDepth }, { floor: 0 });
+      builder.rest(footing, GROUND, "resting");
+      builder.rest(deck, footing, "resting");
+      const material = context.isTimber ? construction.frame.timber : construction.frame.pillars;
+      const post = builder.add({ id: `porch_post_${porchId}_${k}`, role: "column", material, aabb: [u - POST_HALF, v - POST_HALF, u + POST_HALF, v + POST_HALF], y0: context.level(floor), y1: hasUpperFloor ? ceilingY - BEAM_DEPTH : ceilingY }, { floor });
+      builder.rest(post, deck, context.isTimber ? "nail" : "rebar");
+      return post;
+    });
+    context.porches.set(porchId, { posts, ceilingY });
+    return posts;
+  }
+  function addUpperBeams(context, porchId, rect, posts, floor) {
+    const { builder, construction } = context;
+    const material = context.isTimber ? construction.frame.timber : construction.frame.beams;
+    const joint = context.isTimber ? "nail" : "rebar";
+    const ceilingY = context.porches.get(porchId).ceilingY;
+    const y0 = ceilingY - BEAM_DEPTH;
+    const carriers = context.carriers.get(floor);
+    const head = builder.add({ id: `porch_beam_${porchId}`, role: "beam", material, aabb: [rect[0], rect[1], rect[2], rect[1] + BEAM_WIDTH], y0, y1: ceilingY }, { floor });
+    for (const post of posts) builder.rest(head, post, joint);
+    carriers.push(head);
+    const sides = [["e", [rect[0], rect[1], rect[0] + BEAM_WIDTH, rect[3]], posts[0]], ["d", [rect[2] - BEAM_WIDTH, rect[1], rect[2], rect[3]], posts[1]]];
+    for (const [name, aabb, post] of sides) {
+      const side = builder.add({ id: `porch_beam_${porchId}_${name}`, role: "beam", material, aabb, y0, y1: ceilingY }, { floor });
+      builder.rest(side, post, joint);
+      builder.rest(side, head, joint);
+      for (const wall of context.walls.filter((w) => w.floor === floor && w.role === "wall" && touches(w.box, side.aabb, 0.3))) builder.rest(side, context.wallParts.get(wall.id), joint);
+      carriers.push(side);
+    }
+  }
+  function addPorches(context, floor) {
+    const { builder, construction } = context;
+    for (const room of context.source.rooms.filter((r) => r.type === "porch" && r.floor === floor)) {
+      const rect = room.parts[0];
+      const base = context.baseOf(floor);
+      const deckDepth = Math.min(0.2, Math.max(0.06, context.elevation * 0.5));
+      const deck = builder.add({ id: `porch_floor_${room.id}`, role: "slab", material: context.isTimber ? "wood_soft" : construction.frame.slabs, aabb: rect, y0: context.level(floor) - deckDepth, y1: context.level(floor) }, { floor });
+      if (base && base !== GROUND) builder.rest(deck, base, context.isTimber ? "nail" : context.system.joints.slab);
+      const posts = addPosts(context, room.id, rect, deck, floor);
+      if (floor < context.floorCount - 1) addUpperBeams(context, room.id, rect, posts, floor);
+    }
+  }
+  var ROOF_RISE = 0.6;
+  function addPorchRoofs(context) {
+    const { builder, construction } = context;
+    for (const room of context.source.rooms.filter((r) => r.type === "porch")) {
+      const floor = room.floor;
+      const rect = room.parts[0];
+      const posts = context.porches.get(room.id);
+      if (floor !== context.floorCount - 1 || !posts) continue;
+      const material = ROOF_COVERINGS.get(construction.roof.covering)?.material ?? "ceramic";
+      const roof = builder.add({ id: `porch_roof_${room.id}`, role: "roof", material, aabb: [rect[0] - 0.3, rect[1] - 0.5, rect[2] + 0.3, rect[3]], y0: posts.ceilingY, y1: posts.ceilingY + ROOF_RISE }, { floor });
+      for (const post of posts.posts) builder.rest(roof, post, context.isTimber ? "nail" : "bolt");
+      const housewalls = context.walls.filter((w) => w.floor === floor && !w.exterior && w.sides.includes(room.id) && w.type === "wall");
+      for (const wall of housewalls) {
+        if (context.porchRoofOnPostsOnly) builder.supports.push({ part: roof.id, on: wall.id, joint: "nail", bears: false });
+        else builder.rest(roof, context.wallParts.get(wall.id), "nail");
+      }
+    }
+  }
+  var TRUSS_PITCH = 1.2;
+  var DEFAULT_PITCH = 20;
+  var DEFAULT_EAVE = 0.4;
   var CLOSED_ONLY = [...OPEN_ROOM_TYPES2, "void"];
+  function roofUnits(context, bearing) {
+    const units = [{ suffix: "", box: context.topBox, floor: bearing, annex: false }];
+    if (context.floorCount <= 1 || context.isUnit || bearing !== context.floorCount - 1) return units;
+    for (let floor = 0; floor < context.floorCount - 1; floor++) {
+      const above = context.source.rooms.filter((room) => room.floor === floor + 1).flatMap((room) => room.parts);
+      const rooms = context.source.rooms.filter((room) => room.floor === floor && !OPEN_ROOM_TYPES2.includes(room.type) && room.type !== "void" && room.type !== "elevator");
+      for (const room of rooms) {
+        const area3 = room.parts.reduce((total, part) => total + (part[2] - part[0]) * (part[3] - part[1]), 0);
+        const covered = room.parts.reduce((total, part) => total + above.reduce((sum, other) => sum + Math.max(0, Math.min(part[2], other[2]) - Math.max(part[0], other[0])) * Math.max(0, Math.min(part[3], other[3]) - Math.max(part[1], other[1])), 0), 0);
+        if (covered < area3 * 0.7) units.push({ suffix: `_${room.id}`, box: unionOf(room.parts), floor, annex: true });
+      }
+    }
+    return units;
+  }
+  function roofCarriers(context, unit) {
+    const platesHere = context.plates.get(unit.floor) ?? [];
+    const allPlates = [...context.plates.values()].flat();
+    const eaveHeight = platesHere.length ? Math.max(...platesHere.map((plate) => plate.y1)) : 0;
+    const plates = allPlates.filter((plate) => Math.abs(plate.y1 - eaveHeight) < 0.4 && touches(plate.aabb, unit.box, 0.3));
+    const pillars = (context.pillars.get(unit.floor) ?? []).filter((pillar) => touches(pillar.aabb, unit.box, 0.3));
+    const walls = context.walls.filter((wall) => wall.floor === unit.floor && wall.role === "wall" && !wall.exterior && touches(wall.box, unit.box, 0.2)).map((wall) => context.wallParts.get(wall.id));
+    return [...plates, ...pillars, ...walls];
+  }
+  function addFlatRoof(context, unit, carriers) {
+    const { builder, construction, system } = context;
+    const top = context.level(unit.floor) + context.ceilingOf(unit.floor);
+    const [u0, v0, u1, v1] = unit.box;
+    const slab = builder.add({ id: `slab_top${unit.suffix}`, role: "slab", material: construction.frame.slabs, aabb: [u0 - 0.15, v0 - 0.15, u1 + 0.15, v1 + 0.15], y0: top, y1: top + 0.12 }, { floor: unit.floor, cover: true, footprint: [unit.box] });
+    for (const carrier of carriers.length ? carriers : context.plates.get(unit.floor) ?? []) builder.rest(slab, carrier, system.joints.slab);
+    if (unit.suffix === "") context.topSlab = slab;
+    return { id: slab.id, aabb: slab.aabb, y0: slab.y0, y1: slab.y1, flat: true };
+  }
+  function addTrusses(context, unit, carriers, geometry) {
+    const { builder, construction, system } = context;
+    const { box: box22 } = unit;
+    const { axis, length, eave, rise, eaveY } = geometry;
+    const count = Math.max(2, Math.ceil(length / TRUSS_PITCH) + 1);
+    const trusses = [];
+    for (let k = 0; k < count; k++) {
+      const at2 = (axis === "u" ? box22[0] : box22[1]) + k * length / (count - 1);
+      const aabb = axis === "u" ? [at2 - 0.04, box22[1] - eave * 0.5, at2 + 0.04, box22[3] + eave * 0.5] : [box22[0] - eave * 0.5, at2 - 0.04, box22[2] + eave * 0.5, at2 + 0.04];
+      const truss = builder.add({ id: `truss${unit.suffix}_${k}`, role: "beam", material: construction.frame.timber, aabb, y0: eaveY, y1: eaveY + rise }, { floor: unit.floor, fill: 0.25 });
+      const touching = carriers.filter((carrier) => touches(aabb, carrier.aabb, 0.2) && carrier.role !== "slab");
+      const chosen = touching.length ? touching : carriers.slice().sort((a, b) => distanceBetween(aabb, a.aabb) - distanceBetween(aabb, b.aabb)).slice(0, 2);
+      for (const carrier of chosen) builder.rest(truss, carrier, system.joints.truss);
+      trusses.push(truss);
+    }
+    return trusses;
+  }
+  function geometryOf(context, unit) {
+    const { box: box22 } = unit;
+    const roof = context.construction.roof;
+    const platesHere = context.plates.get(unit.floor) ?? [];
+    const width = box22[2] - box22[0];
+    const depth = box22[3] - box22[1];
+    const axis = roof.axis ?? (width >= depth ? "u" : "v");
+    const span = axis === "u" ? depth : width;
+    const pitch = unit.annex ? Math.min(roof.pitch || DEFAULT_PITCH, 20) : roof.pitch || DEFAULT_PITCH;
+    const eaveY = platesHere.length ? Math.max(...platesHere.map((plate) => plate.y1)) : context.level(unit.floor) + context.ceilingOf(unit.floor);
+    return { axis, length: axis === "u" ? width : depth, eave: roof.eave ?? DEFAULT_EAVE, rise: round2(span / 2 * Math.tan(pitch * Math.PI / 180)), eaveY };
+  }
+  function addRafters(context, unit, carriers, geometry) {
+    const { builder, construction, system } = context;
+    const { box: box22 } = unit;
+    const { axis, length, eave, rise, eaveY } = geometry;
+    const count = Math.max(2, Math.ceil(length / TRUSS_PITCH) + 1);
+    const middle = axis === "u" ? (box22[1] + box22[3]) / 2 : (box22[0] + box22[2]) / 2;
+    const frames = { all: [], sideA: [], sideB: [] };
+    for (let k = 0; k < count; k++) {
+      const at2 = (axis === "u" ? box22[0] : box22[1]) + k * length / (count - 1);
+      const halves = axis === "u" ? [["a", [at2 - 0.04, box22[1] - eave * 0.5, at2 + 0.04, middle]], ["b", [at2 - 0.04, middle, at2 + 0.04, box22[3] + eave * 0.5]]] : [["a", [box22[0] - eave * 0.5, at2 - 0.04, middle, at2 + 0.04]], ["b", [middle, at2 - 0.04, box22[2] + eave * 0.5, at2 + 0.04]]];
+      for (const [side, aabb] of halves) {
+        const rafter = builder.add({ id: `rafter${unit.suffix}_${side}_${k}`, role: "beam", material: construction.frame.timber, aabb, y0: eaveY, y1: eaveY + rise }, { floor: unit.floor, fill: 0.25 });
+        const touching = carriers.filter((carrier) => touches(aabb, carrier.aabb, 0.2) && carrier.role !== "slab");
+        const chosen = touching.length ? touching : carriers.slice().sort((x, y) => distanceBetween(aabb, x.aabb) - distanceBetween(aabb, y.aabb)).slice(0, 2);
+        for (const carrier of chosen) builder.rest(rafter, carrier, system.joints.truss);
+        frames.all.push(rafter);
+        if (side === "a") frames.sideA.push(rafter);
+        else frames.sideB.push(rafter);
+      }
+    }
+    if (!unit.annex) {
+      const ridgeBox = axis === "u" ? [box22[0] - eave, middle - 0.05, box22[2] + eave, middle + 0.05] : [middle - 0.05, box22[1] - eave, middle + 0.05, box22[3] + eave];
+      const ridge = builder.add({ id: `ridge${unit.suffix}`, role: "beam", material: construction.frame.timber, aabb: ridgeBox, y0: eaveY + rise - 0.12, y1: eaveY + rise }, { floor: unit.floor });
+      for (const rafter of frames.all) builder.rest(ridge, rafter, system.joints.truss);
+    }
+    context.roof.trusses += count;
+    return frames;
+  }
+  function panesOf(unit, geometry) {
+    const [u0, v0, u1, v1] = unit.box;
+    const { eave, axis } = geometry;
+    if (unit.annex) return [[u0 - eave, v0 - eave, u1 + eave, v1 + eave]];
+    const midV = (v0 + v1) / 2;
+    const midU = (u0 + u1) / 2;
+    return axis === "u" ? [[u0 - eave, v0 - eave, u1 + eave, midV], [u0 - eave, midV, u1 + eave, v1 + eave]] : [[u0 - eave, v0 - eave, midU, v1 + eave], [midU, v0 - eave, u1 + eave, v1 + eave]];
+  }
+  function coarseFrames(context, unit, carriers, geometry) {
+    const trusses = addTrusses(context, unit, carriers, geometry);
+    context.roof.trusses += trusses.length;
+    return { all: trusses, sideA: trusses, sideB: trusses };
+  }
+  function addGableRoof(context, unit, carriers, covering) {
+    const { builder, construction } = context;
+    const geometry = geometryOf(context, unit);
+    const frames = context.rafterRoof ? addRafters(context, unit, carriers, geometry) : coarseFrames(context, unit, carriers, geometry);
+    const panes = [];
+    panesOf(unit, geometry).forEach((aabb, k) => {
+      const name = unit.annex ? "annex" : k === 0 ? "a" : "b";
+      const options = { floor: unit.floor, fill: construction.roof.covering === "colonial" ? 0.12 : 0.05, ...construction.roof.pitch === void 0 ? {} : { pitch: construction.roof.pitch } };
+      const pane = builder.add({ id: `roof${unit.suffix}_${name}`, role: "roof", material: construction.roof.material, aabb, y0: geometry.eaveY, y1: geometry.eaveY + geometry.rise + 0.05 }, options);
+      const carried = unit.annex || !context.rafterRoof ? frames.all : k === 0 ? frames.sideA : frames.sideB;
+      for (const frame2 of carried) builder.rest(pane, frame2, covering);
+      panes.push({ id: pane.id, aabb: pane.aabb, y0: pane.y0, y1: pane.y1 });
+    });
+    if (!unit.annex) {
+      const roof = context.roof;
+      roof.axis = geometry.axis;
+      roof.ridge = round2(geometry.eaveY + geometry.rise);
+      roof.eave = geometry.eave;
+      roof.y0 = round2(geometry.eaveY);
+      roof.aabb = [unit.box[0] - geometry.eave, unit.box[1] - geometry.eave, unit.box[2] + geometry.eave, unit.box[3] + geometry.eave].map(round2);
+    }
+    return panes;
+  }
+  function addCeilingJoists(context) {
+    const { builder, construction } = context;
+    const bearing = context.roof.bearingFloor;
+    const rects = context.rectsOf(bearing, CLOSED_ONLY);
+    const box22 = unionOf(rects.length ? rects : [context.topBox]);
+    const carriers = [...context.plates.get(bearing) ?? [], ...context.walls.filter((w) => w.floor === bearing && w.role === "wall" && !w.exterior).map((w) => context.wallParts.get(w.id))];
+    const length = box22[2] - box22[0];
+    const depth = box22[3] - box22[1];
+    const alongU = length >= depth;
+    const span = alongU ? length : depth;
+    const count = Math.max(2, Math.round(span / 0.6) + 1);
+    const beamTops = carriers.filter((carrier) => carrier.role === "beam").map((carrier) => carrier.y0);
+    const y0 = carriers.length ? Math.max(...beamTops, context.level(bearing) + 1) : context.topOf(bearing);
+    const joists = [];
+    for (let k = 0; k < count; k++) {
+      const at2 = (alongU ? box22[0] : box22[1]) + 0.05 + k * (span - 0.1) / (count - 1);
+      const aabb = alongU ? [at2 - 0.025, box22[1], at2 + 0.025, box22[3]] : [box22[0], at2 - 0.025, box22[2], at2 + 0.025];
+      const joist = builder.add({ id: `ceiling_joist_${k}`, role: "beam", material: construction.frame.timber, aabb, y0: y0 - 0.02, y1: y0 + context.system.plateThickness - 0.02 }, { floor: bearing, spacing: 0.6 });
+      const beams = carriers.filter((carrier) => carrier.role === "beam" && touches(aabb, carrier.aabb, 0.2));
+      for (const carrier of beams.length ? beams : carriers.slice(0, 2)) builder.rest(joist, carrier, "nail");
+      joists.push(joist);
+    }
+    context.ceilingJoists = joists;
+  }
+  function addRoof(context) {
+    const { construction } = context;
+    const covering = ROOF_COVERINGS.get(construction.roof.covering);
+    const bearing = construction.roof.bearingFloor ?? context.floorCount - 1;
+    const open = context.rectsOf(context.floorCount - 1, OPEN_ROOM_TYPES2);
+    const topRects = context.rectsOf(context.floorCount - 1, CLOSED_ONLY);
+    const body = unionOf(open.length ? open : topRects);
+    context.topBox = context.floorCount - 1 === bearing ? body : unionOf(context.rectsOf(bearing, OPEN_ROOM_TYPES2));
+    context.roof = { shape: construction.roof.shape, covering: construction.roof.covering, material: construction.roof.material, pitch: construction.roof.pitch || 0, bearingFloor: bearing, panes: [], trusses: 0 };
+    for (const unit of roofUnits(context, bearing)) {
+      const carriers = roofCarriers(context, unit);
+      if (construction.roof.shape === "slab") context.roof.panes.push(addFlatRoof(context, unit, carriers));
+      else context.roof.panes.push(...addGableRoof(context, unit, carriers, covering?.joint ?? "nail"));
+    }
+    if (context.isTimber && construction.roof.shape !== "slab") addCeilingJoists(context);
+  }
+  function flightsOf(items) {
+    const flights = /* @__PURE__ */ new Map();
+    for (const item of items.filter((it) => it.category === "stairs" && it.link)) {
+      const key = `${item.link.from}_${item.link.to}`;
+      if (!flights.has(key) || item.floor === item.link.from) flights.set(key, item);
+    }
+    return flights;
+  }
+  function addStairs(context) {
+    const { builder, construction } = context;
+    const material = context.isTimber ? construction.frame.timber : construction.stairs ?? "concrete";
+    for (const [key, item2] of flightsOf(context.source.items)) {
+      const { from, to } = item2.link;
+      const flight2 = builder.add({ id: `stairs_${key}`, role: "stair", material, aabb: item2.aabb, y0: context.level(from), y1: context.level(to) }, { floor: from, steps: Math.round((context.level(to) - context.level(from)) / 0.18) });
+      const base = context.baseOf(from);
+      builder.rest(flight2, !base || base === GROUND ? GROUND : base, !base || base === GROUND ? "resting" : context.isTimber ? "nail" : "mortar");
+      const upper = context.baseOf(to);
+      if (upper && upper !== GROUND) builder.rest(flight2, upper, context.isTimber ? "nail" : "bolt");
+    }
+    if (!context.hasBasement) return;
+    const item = context.source.items.find((it) => it.type === "basement_stairs");
+    if (!item?.aabb) return;
+    const depth = construction.foundation.depth || 2.4;
+    const flight = builder.add({ id: "basement_stairs", role: "stair", material: "wood_soft", aabb: item.aabb, y0: -depth, y1: context.level(0) }, { floor: -1, steps: Math.round((context.level(0) + depth) / 0.18) });
+    builder.rest(flight, builder.find("basement_slab"), "resting");
+    if (context.base0 && context.base0 !== GROUND) builder.rest(flight, context.base0, "nail");
+  }
+  var TOLERANCE = 0.02;
+  var 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)];
+  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 (!wall) continue;
+      const base = context.level(window.floor);
+      openings.push({ id: window.id, kind: "window", wall: wall.id, from, to, y0: base + window.y0, y1: base + window.y1 });
+    }
+    return openings;
+  }
+  function addDoorLintels(context) {
+    const { builder, construction, system } = context;
+    for (const door of context.source.doors.filter((d) => d.a !== void 0 && d.type !== "zipper")) {
+      const along = door.axis === "u" ? door.u : door.v;
+      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));
+      if (!beside.length) continue;
+      const half = (beside[0].thickness ?? 0.15) / 2;
+      const lo = from - LINTEL_BEARING;
+      const hi = to + LINTEL_BEARING;
+      const box22 = door.axis === "u" ? [lo, cross - half, hi, cross + half] : [cross - half, lo, cross + half, hi];
+      const y0 = context.level(door.floor) + DOOR_HEIGHT;
+      const lintel = builder.add({ id: `lintel_${door.id}`, role: "beam", material: system.timber ? construction.frame.timber : "concrete", aabb: box22, y0, y1: y0 + LINTEL_DEPTH }, { floor: door.floor, ...system.timber ? {} : { assembly: "reinforced_concrete" } });
+      for (const wall of beside) builder.rest(lintel, context.wallParts.get(wall.id), system.joints.beam);
+      for (const plate of context.plates.get(door.floor) ?? []) if (overlapsInPlan(plate.aabb, box22)) builder.rest(plate, lintel, system.joints.beam);
+    }
+  }
+  var overlapsInPlan = (a, b) => a[0] < b[2] && a[2] > b[0] && a[1] < b[3] && a[3] > b[1];
+  var RISER = 0.18;
+  var TREAD = 0.28;
+  var stepCount = (elevation) => Math.max(1, Math.ceil(elevation / RISER));
+  function addPorchSteps(context) {
+    const { builder } = context;
+    for (const room of context.source.rooms.filter((r) => r.type === "porch")) {
+      const deck = builder.find(`porch_floor_${room.id}`);
+      for (const door of context.source.doors.filter((d) => d.floor === room.floor && d.b === "outside" && d.a === room.id)) {
+        const count = stepCount(context.elevation);
+        const depth = count * TREAD;
+        const aabb = [door.u - door.width / 2, door.v - depth, door.u + door.width / 2, door.v];
+        const flight = builder.add({ id: `steps_${door.id}`, role: "stair", material: context.isTimber ? "wood_soft" : "concrete", aabb, y0: 0, y1: context.level(room.floor) }, { floor: 0, steps: count, door: door.id });
+        builder.rest(flight, GROUND, "resting");
+        if (deck) builder.rest(flight, deck, context.isTimber ? "nail" : "mortar");
+      }
+    }
+  }
+  function boxOfSteps(door, depth) {
+    const direction = door.axis === "u" ? door.side === "front" ? -1 : 1 : door.side === "left" ? -1 : 1;
+    if (door.axis === "u") return [door.u - door.width / 2, Math.min(door.v, door.v + direction * depth), door.u + door.width / 2, Math.max(door.v, door.v + direction * depth)];
+    return [Math.min(door.u, door.u + direction * depth), door.v - door.width / 2, Math.max(door.u, door.u + direction * depth), door.v + door.width / 2];
+  }
+  function addDoorSteps(context) {
+    if (context.elevation <= 0.1) return;
+    const { builder } = context;
+    const doors = context.source.doors.filter((d) => d.floor === 0 && d.exterior && d.model !== "steel" && d.type !== "steps" && d.type !== "zipper");
+    for (const door of doors) {
+      const count = stepCount(context.elevation);
+      const depth = Math.min(TREAD * count, 0.9);
+      const flight = builder.add({ id: `steps_${door.id}`, role: "stair", material: context.isTimber ? "wood_soft" : "concrete", aabb: boxOfSteps(door, depth), y0: 0, y1: context.level(0) }, { floor: 0, steps: count, door: door.id });
+      builder.rest(flight, GROUND, "resting");
+      const base = context.base0;
+      if (base && base !== GROUND) builder.rest(flight, base, context.isTimber ? "nail" : "mortar");
+    }
+  }
+  function addExteriorSteps(context) {
+    addPorchSteps(context);
+    addDoorSteps(context);
+  }
+  var TANK_FILL = 0.08;
+  var squareAround = (u, v, side) => [u - side / 2, v - side / 2, u + side / 2, v + side / 2];
+  function addTank(context, tank, floor, y0) {
+    return context.builder.add({ id: "water_tank", role: "none", material: tank.material ?? "plastic", aabb: tank.aabb, y0, y1: y0 + tank.h }, { floor, fill: TANK_FILL, liters: tank.capacity });
+  }
+  function ensureCeilingSlab(context, y) {
+    const { builder, construction, system } = context;
+    const existing = builder.find("slab_ceiling");
+    if (existing) return existing;
+    const top = context.floorCount - 1;
+    const box22 = context.topBox;
+    const carriers = builder.parts.filter(
+      (part) => (part.role === "beam" && part.id.startsWith(`plate_${top}_`) || part.role === "column" && part.floor === top || part.role === "wall" && part.floor === top && !part.id.startsWith("basement")) && touches(box22, part.aabb, 0.1)
+    );
+    const slab = builder.add({ id: "slab_ceiling", role: "slab", material: construction.frame.slabs, aabb: box22, y0: y - 0.12, y1: y }, { floor: top, footprint: [box22] });
+    for (const carrier of carriers) builder.rest(slab, carrier, system.joints.slab);
+    return slab;
+  }
+  function addRaisedPlatform(context, tank) {
+    const { builder, construction } = context;
+    const platform = tank.platform;
+    const top = context.floorCount - 1;
+    const ceiling = ensureCeilingSlab(context, platform.baseY);
+    const pillars = platform.pillars.map((q, k) => {
+      const pillar = builder.add({ id: `tank_column_${k}`, role: "column", material: construction.frame.pillars, aabb: squareAround(q.u, q.v, q.side), y0: platform.baseY, y1: platform.topY - platform.thickness }, { floor: top });
+      builder.rest(pillar, ceiling, "rebar");
+      return pillar;
+    });
+    const slab = builder.add({ id: "tank_slab", role: "slab", material: construction.frame.slabs, aabb: platform.aabb, y0: platform.topY - platform.thickness, y1: platform.topY }, { floor: top });
+    for (const pillar of pillars) builder.rest(slab, pillar, "rebar");
+    builder.rest(addTank(context, tank, top, tank.y), slab, "resting");
+  }
+  function addAtticTank(context, tank) {
+    const { builder } = context;
+    const top = context.floorCount - 1;
+    if (!context.isTimber) {
+      const ceiling = ensureCeilingSlab(context, tank.y);
+      builder.rest(addTank(context, tank, top, tank.y), ceiling, "resting");
+      return;
+    }
+    const supports = context.topSlab ? [context.topSlab] : context.ceilingJoists ?? builder.parts.filter((part) => part.role === "beam" && part.id.startsWith(`plate_${top}_`));
+    const y0 = supports[0] ? supports[0].y1 : tank.y - 0.03;
+    const floor = builder.add({ id: "attic_floor", role: "slab", material: "plywood", aabb: context.topBox, y0, y1: y0 + 0.03 }, { floor: top });
+    for (const support of supports) if (touches(floor.aabb, support.aabb, 0.1)) builder.rest(floor, support, "nail");
+    builder.rest(addTank(context, tank, top, tank.y), floor, "resting");
+  }
+  function addSlabTank(context, tank) {
+    const { builder } = context;
+    const supports = builder.parts.filter((part2) => part2.role === "slab" && Math.abs(part2.y1 - tank.y) < 0.3 && touches(part2.aabb, tank.aabb, 0.1));
+    const carrier = supports.sort((a, b) => Math.abs(a.y1 - tank.y) - Math.abs(b.y1 - tank.y))[0] ?? context.topSlab;
+    const part = addTank(context, tank, tank.floor, tank.y);
+    builder.rest(part, carrier ?? GROUND, "resting");
+  }
+  function addTrestleTank(context, tank) {
+    const { builder } = context;
+    const stand = tank.stand;
+    const columns = stand.pillars.map((q, k) => {
+      const column = builder.add({ id: `trestle_column_${k}`, role: "column", material: stand.material, aabb: squareAround(q.u, q.v, q.side), y0: 0, y1: stand.height }, { floor: 0 });
+      builder.rest(column, GROUND, stand.baseJoint ?? "resting");
+      return column;
+    });
+    const [u0, v0, u1, v1] = tank.aabb;
+    const beams = [[u0 - 0.1, v0 - 0.1, u1 + 0.1, v0 + 0.05], [u0 - 0.1, v1 - 0.05, u1 + 0.1, v1 + 0.1]].map((aabb, k) => {
+      const beam = builder.add({ id: `trestle_beam_${k}`, role: "beam", material: stand.material, aabb, y0: stand.height - 0.12, y1: stand.height }, { floor: 0 });
+      for (const column of columns.filter((c) => touches(beam.aabb, c.aabb, 0.15))) builder.rest(beam, column, stand.joint ?? "nail");
+      return beam;
+    });
+    const part = addTank(context, tank, 0, stand.height);
+    for (const beam of beams) builder.rest(part, beam, stand.tie ?? "resting");
+  }
+  function addWaterTank(context) {
+    const tank = context.tank;
+    if (!tank) return;
+    switch (tank.place) {
+      case "slab":
+        return addSlabTank(context, tank);
+      case "raised_slab":
+        return addRaisedPlatform(context, tank);
+      case "attic":
+        return addAtticTank(context, tank);
+      case "trestle":
+        return addTrestleTank(context, tank);
+    }
+  }
+  function addUpperFloor(context, floor) {
+    if (floor >= context.floorCount - 1 || context.isUnit) return;
+    const next = floor + 1;
+    const rects = context.rectsOf(next, ["balcony", "porch", "void"]);
+    const box22 = rects.length ? unionOf(rects) : context.houseBox;
+    const carriers = context.carriers.get(floor);
+    const { system, construction, builder } = context;
+    const thickness = system.slabThickness;
+    if (context.isTimber) {
+      const joists = addJoists(context, { floor: next, box: box22, thickness, carriers, material: construction.frame.timber, joint: system.joints.beam });
+      addDeck(context, `slab_${next}`, construction.frame.slabs, { floor: next, box: box22, thickness, joint: system.joints.slab }, joists);
+      return;
+    }
+    const slab = builder.add({ id: `slab_${next}`, role: "slab", material: construction.frame.slabs, aabb: box22, y0: context.level(next) - thickness, y1: context.level(next) }, { floor: next, footprint: rects.length ? rects : [context.houseBox] });
+    const below = carriers.filter((carrier) => carrier.y0 <= slab.y0 + 0.05);
+    const touching = below.filter((carrier) => touches(slab.aabb, carrier.aabb, 0.2));
+    for (const carrier of touching.length ? touching : below) builder.rest(slab, carrier, system.joints.slab);
+  }
+  function wallCeiling(context, wall) {
+    const rooms = wall.sides.map((id) => context.source.rooms.find((room) => room.id === id && room.floor === wall.floor)).filter((room) => room !== void 0);
+    return Math.max(context.ceilingOf(wall.floor), ...rooms.map((room) => room.ceiling || 0));
+  }
+  function wallTop(context, wall, floor) {
+    const y0 = context.level(floor);
+    if (wall.type === "railing") return y0 + guardHeightOf(wall);
+    const ceiling = wallCeiling(context, wall);
+    const height = wall.structureHeight || wall.h || context.ceilingOf(floor);
+    if (wall.exterior && floor < context.floorCount - 1 && !context.isUnit && ceiling > context.ceilingOf(floor) + 0.01) return y0 + ceiling;
+    if (floor === context.floorCount - 1 || context.isUnit) return y0 + Math.max(height, ceiling);
+    const top = context.topOf(floor);
+    return Math.max(y0 + height, y0 + ceiling > top ? top : y0 + ceiling);
+  }
+  function railingBase(context, wall, floor) {
+    const open = wall.sides.map((id) => context.source.rooms.find((room) => room.id === id && room.floor === floor)).find((room) => room && (room.type === "balcony" || room.type === "porch"));
+    if (!open) return context.baseOf(floor);
+    return open.type === "porch" ? `porch_floor_${open.id}` : `slab_${floor}_${open.id}`;
+  }
+  var assemblyOf = (context) => context.construction.walls.assembly ?? (context.system.walls || void 0);
+  function addWallPart(context, wall, floor) {
+    const { system, builder } = context;
+    const isRailing = wall.type === "railing";
+    const y0 = context.level(floor);
+    const top = wallTop(context, wall, floor);
+    const y1 = isRailing ? top : wall.exterior && !wall.gable ? top - system.plateThickness : top;
+    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) } }
+    );
+    context.wallParts.set(wall.id, part);
+    const base = isRailing ? railingBase(context, wall, floor) : 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);
+  }
+  function addWalls(context, floor) {
+    for (const wall of context.walls.filter((w) => w.floor === floor)) addWallPart(context, wall, floor);
+  }
+  function buildFloors(context) {
+    for (let floor = 0; floor < context.floorCount; floor++) {
+      addWalls(context, floor);
+      addPlatesAndPillars(context, floor);
+      addPorches(context, floor);
+      addUpperFloor(context, floor);
+    }
+  }
+  function buildStructure(source, options = {}) {
+    const refined = options.wallDetail !== "coarse";
+    const built = options.construction ? { construction: options.construction, extras: options.extras ?? {} } : resolveConstruction(source);
+    const construction = built.construction;
+    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 });
+    addFoundation(context);
+    buildFloors(context);
+    addBalconies(context);
+    addPorchRoofs(context);
+    addExteriorSteps(context);
+    addStairs(context);
+    if (options.roof !== false) addRoof(context);
+    if (refined) addDoorLintels(context);
+    addWaterTank(context);
+    addChimney(context);
+    addWell(context);
+    const levels = source.floors.map((_, floor) => context.level(floor));
+    const framed = construction.system === "masonry" && (context.isUnit || source.style === "commercial" || context.floorCount >= 3);
+    return { parts: context.builder.parts, supports: context.builder.supports, levels, elevation: context.elevation, roof: context.roof, construction, framed, openings: findOpenings(context) };
+  }
   var entry = (itemId, min, max, group, pickable, weight) => ({ itemId, min, max, group, pickable, weight });
   var FRIDGE = [
     entry("water_bottle", 1, 3, "water", true, 3),
@@ -20373,10 +21369,10 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
 
   // ../game-floorplan-residential/dist/index.js
-  var __defProp2 = Object.defineProperty;
+  var __defProp3 = Object.defineProperty;
   var __export2 = (target, all) => {
     for (var name in all)
-      __defProp2(target, name, { get: all[name], enumerable: true });
+      __defProp3(target, name, { get: all[name], enumerable: true });
   };
   var residentialItems = [
     { type: "sofa_3seat", category: "sofa", w: 2.1, d: 0.9, h: 0.85, color: { role: "fabric_main" } },
@@ -21577,7 +22573,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
   }
   function recordSpec(THREE, name, root, run, opts) {
     const o = { chairs: opts.chairs };
-    const materialOf = { ...BASE_MATERIAL, ...opts.materials };
+    const materialOf2 = { ...BASE_MATERIAL, ...opts.materials };
     const drawn = [];
     const counters = /* @__PURE__ */ new Map();
     const q = new THREE.Quaternion();
@@ -21633,7 +22629,7 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     if (!drawn.length) throw new Error(`game-floorplan-three: the builder of "${name}" drew no box or cylinder`);
     const parts = drawn.map((p) => {
       const thin = Math.min(...p.shape.kind === "box" ? p.shape.size : p.shape.kind === "cylinder" ? [p.shape.radius * 2, p.shape.height] : [p.shape.radius * 2]);
-      let material = materialOf[p.key] ?? "plastic";
+      let material = materialOf2[p.key] ?? "plastic";
       if (p.key === "wood" && material === "wood_hard" && thin < WOOD_THIN) material = "wood_soft";
       const part = { id: p.id, material, shape: p.shape, position: p.position };
       if (p.rotation) part.rotation = p.rotation;
@@ -21759,6 +22755,66 @@ uniform mat4 uNodes[${nodes.length}]; attribute float aNodeIndex; attribute vec3
     K.PARTS.length = before;
     return { spec: made.spec, build: made.build, spout: [water.pos[0] - root.x, water.pos[1], water.pos[2] - root.z] };
   }
+
+  // src/wall.ts
+  var PLASTER = 15262420;
+  var WALL_ID = "wall_0_0";
+  function wallPlan(options) {
+    const { w, h, thickness = 0.15, finish = "plaster", color: color2 = PLASTER } = options;
+    const facade = { finish, roof: "none", floors: 1 };
+    const wall = { id: WALL_ID, floor: 0, axis: "u", u0: -w / 2, v0: 0, u1: w / 2, v1: 0, thickness, sides: ["outside", "outside"], exterior: true, type: "wall", h };
+    const plan = {
+      template: "wall",
+      name: "wall",
+      style: "mid",
+      state: "normal",
+      w,
+      d: thickness,
+      floors: [{ index: 0, y0: 0, ceiling: h }],
+      rooms: [],
+      walls: [wall],
+      doors: [],
+      windows: [],
+      items: [],
+      stateItems: [],
+      openPairs: [],
+      partyWalls: [],
+      missing: [],
+      facade,
+      colors: { facade: color2, wall: color2 },
+      lot: null,
+      building: null,
+      waterTank: null,
+      outbuildings: []
+    };
+    plan.construction = masonryConstruction({ ...plan, facade: { ...facade, roof: "colonial" } });
+    plan.structure = buildStructure(plan, { wallDetail: "coarse", construction: plan.construction, roof: false });
+    return plan;
+  }
+  function draw(THREE, plan, options) {
+    return create3(THREE, { ...options, fleet: null }).build(plan, { quality: "game", terrain: false, noPerimeter: true, pieces: "meshes" });
+  }
+  function label(house) {
+    for (const [id, items] of Object.entries(house.destruction.ranges())) {
+      for (const item of items) {
+        const object2 = item.isObject3D ? item : item.mesh;
+        object2.userData.destructionPart = id;
+      }
+    }
+    return house.group;
+  }
+  function wallPiece(THREE, options) {
+    const plan = wallPlan(options);
+    const houseOptions = options.house ?? {};
+    const probe = draw(THREE, plan, { ...houseOptions, destruction: void 0, destructionRenderer: void 0 });
+    const spec = probe.structure.spec({ wallDetail: "coarse" });
+    probe.dispose();
+    return {
+      plan,
+      spec,
+      build: (T2) => label(draw(T2, plan, houseOptions))
+    };
+  }
   return __toCommonJS(index_exports);
 })();
 //# sourceMappingURL=index.global.js.map