@adatechnology/game-floorplan-structure 0.0.0-stage → 1.0.1

package/dist/index.global.js

@@ -0,0 +1,3690 @@
+"use strict";
+var GameFloorplanStructure = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    CONSTRUCTIONS: () => CONSTRUCTIONS,
+    CONSTRUCTION_SYSTEMS: () => CONSTRUCTION_SYSTEMS,
+    DENSITY: () => DENSITY,
+    GROUND: () => GROUND,
+    ROOF_COVERINGS: () => ROOF_COVERINGS,
+    buildStructure: () => buildStructure,
+    buildWallSpecimen: () => buildWallSpecimen,
+    campConstruction: () => campConstruction,
+    chaletConstruction: () => chaletConstruction,
+    constructionOfSystem: () => constructionOfSystem,
+    logCabinConstruction: () => logCabinConstruction,
+    masonryConstruction: () => masonryConstruction,
+    planWaterTank: () => planWaterTank,
+    register: () => register,
+    registerConstruction: () => registerConstruction,
+    registerConstructionSystem: () => registerConstructionSystem,
+    registerRoofCovering: () => registerRoofCovering,
+    shackConstruction: () => shackConstruction,
+    structureLayer: () => structureLayer,
+    toDestructibleSpec: () => toDestructibleSpec,
+    version: () => version,
+    woodFrameConstruction: () => woodFrameConstruction
+  });
+
+  // src/registry.ts
+  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 }],
+    ["wood_frame", { walls: "wood_frame_wall", joints: uniform("nail"), slabThickness: 0.28, plateThickness: 0.1, timber: true, wallRole: "rules", wallFill: 0.35, studs: { spacing: 0.4, section: "38x89" } }],
+    ["log", { walls: "log_wall", joints: { wall: "bolt", slab: "nail", beam: "bolt", column: "bolt", truss: "bolt" }, slabThickness: 0.2, plateThickness: 0.1, timber: true, wallRole: "bearing", wallFill: 1 }],
+    ["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 }]
+  ]);
+  function registerConstructionSystem(id, def) {
+    CONSTRUCTION_SYSTEMS.set(id, def);
+  }
+  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" }]
+  ]);
+  function registerRoofCovering(id, def) {
+    ROOF_COVERINGS.set(id, def);
+  }
+  var CONSTRUCTIONS = /* @__PURE__ */ new Map();
+  function registerConstruction(id, builder) {
+    CONSTRUCTIONS.set(id, builder);
+  }
+
+  // src/geometry.ts
+  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];
+  }
+
+  // src/presets.ts
+  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 }
+    };
+  }
+  var FOUNDATIONS = {
+    basement: { type: "basement", material: "concrete", elevation: 0.5, depth: 2.4 },
+    crawl_space: { type: "crawl_space", material: "concrete", elevation: 0.6 },
+    raft: { type: "raft", material: "concrete", elevation: 0.2 }
+  };
+  var TIMBER_FRAME = { material: "wood_soft", pillars: "wood_soft", beams: "wood_soft", slabs: "plywood", timber: "wood_soft", rebar: null };
+  function woodFrameConstruction(options = {}) {
+    const covering = options.covering ?? "asphalt";
+    return {
+      system: "wood_frame",
+      walls: { material: "wood_soft", interior: "plaster", cladding: options.cladding ?? "wood_soft", finish: options.finish ?? "wood_siding", thickness: WALL_THICKNESS, studs: "38x89 every 40 cm", insulation: "foam" },
+      floor: { material: "wood_hard", finish: "wood_boards" },
+      roof: { material: ROOF_COVERINGS.get(covering)?.material ?? "plastic", covering, shape: "gable", pitch: 28, timber: "wood_soft", eave: 0.5 },
+      frame: { ...TIMBER_FRAME },
+      foundation: { ...FOUNDATIONS[options.foundation ?? "raft"] }
+    };
+  }
+  function chaletConstruction(options = {}) {
+    const covering = options.covering ?? "colonial";
+    return {
+      system: "wood_frame",
+      walls: { material: "wood_soft", interior: "wood_soft", cladding: "wood_hard", finish: options.finish ?? "vertical_boards", thickness: WALL_THICKNESS, studs: "38x140 every 40 cm" },
+      floor: { material: "wood_hard", finish: "wood_boards" },
+      roof: { material: ROOF_COVERINGS.get(covering)?.material ?? "wood_soft", covering, shape: "gable", pitch: 52, timber: "wood_soft", eave: 0.8, axis: "v", profile: "a_frame", gables: ["front", "back"] },
+      frame: { ...TIMBER_FRAME },
+      foundation: options.piles ? { type: "piles", material: "stone", elevation: 0.9 } : { type: "raft", material: "concrete", elevation: 0.2 }
+    };
+  }
+  function logCabinConstruction(options = {}) {
+    const covering = options.covering ?? "wood";
+    return {
+      system: "log",
+      walls: { material: "wood_hard", interior: "wood_hard", cladding: null, finish: "log", thickness: WALL_THICKNESS, logDiameter: 0.26, joint: "notched_corners" },
+      floor: { material: "wood_hard", finish: "wood_boards" },
+      roof: { material: ROOF_COVERINGS.get(covering)?.material ?? "wood_soft", covering, shape: "gable", pitch: 32, timber: "wood_hard", eave: 0.6 },
+      frame: { material: "wood_hard", pillars: "wood_hard", beams: "wood_hard", slabs: "wood_hard", timber: "wood_hard", rebar: null },
+      foundation: { type: "piles", material: "stone", elevation: 0.5 }
+    };
+  }
+  var MIXED_SCRAP = ["wood_soft", "steel", "plywood", "steel", "wood_soft"];
+  function shackConstruction(options = {}) {
+    const material = options.material === "zinc" ? "steel" : "wood_soft";
+    const onSoil = options.floor === "soil";
+    return {
+      system: "improvised",
+      walls: { material, interior: options.material === "zinc" ? "plywood" : material, cladding: null, finish: "scrap", thickness: WALL_THICKNESS, ...options.material === "mixed" ? { mixed: MIXED_SCRAP } : {} },
+      floor: onSoil ? { material: "soil", finish: "packed_earth" } : { material: "concrete", finish: "burnt_cement" },
+      roof: { material: "steel", covering: "zinc", shape: "gable", pitch: 12, timber: "wood_soft", eave: 0.3, fastening: "nails_and_stones" },
+      frame: { material: "wood_soft", pillars: "wood_soft", beams: "wood_soft", slabs: "concrete", timber: "wood_soft", rebar: null },
+      foundation: onSoil ? { type: "ground", material: "soil", elevation: 0 } : { type: "raft", material: "concrete", elevation: 0.08 }
+    };
+  }
+  function campConstruction() {
+    return {
+      system: "canvas",
+      walls: { material: "fabric", interior: "fabric", cladding: null, finish: "nylon", thickness: 2e-3 },
+      floor: { material: "plastic", finish: "waterproof_mat" },
+      roof: { material: "fabric", covering: "canvas", shape: "tent", pitch: 0, timber: "aluminium", eave: 0 },
+      frame: { material: "aluminium", pillars: "aluminium", beams: "aluminium", slabs: "plastic", timber: "aluminium", rebar: null },
+      foundation: { type: "ground", material: "soil", elevation: 0 }
+    };
+  }
+  function constructionOfSystem(system, source) {
+    const covering = source.facade.roof;
+    const keep = covering && covering !== SLAB_COVERING ? { covering } : {};
+    switch (system) {
+      case "masonry":
+        return masonryConstruction(source);
+      case "wood_frame":
+        return woodFrameConstruction(keep);
+      case "log":
+        return logCabinConstruction(keep);
+      case "improvised":
+        return shackConstruction();
+      case "canvas":
+        return campConstruction();
+      default:
+        return void 0;
+    }
+  }
+
+  // src/construction.ts
+  function resolveConstruction(source) {
+    const extras = source.structureExtras ?? {};
+    return { construction: source.construction ?? masonryConstruction(source), extras };
+  }
+  var TENT_LABEL = /^tent_(dome|tunnel)(?:_|$)/;
+  function tentsOf(source) {
+    const tents = [];
+    for (const room of source.rooms) {
+      if (room.type !== "tent" || room.floor !== 0 || !room.parts[0]) continue;
+      const { label } = room;
+      tents.push({ id: room.id, kind: TENT_LABEL.exec(typeof label === "string" ? label : "")?.[1] ?? "tunnel", height: room.ceiling ?? source.floors[0]?.ceiling ?? 2.4, aabb: room.parts[0] });
+    }
+    return tents;
+  }
+  function constructionFor(context) {
+    const forced = context.options?.construction;
+    const named = typeof forced === "string" ? forced : context.template?.construction;
+    if (named === void 0) return { construction: masonryConstruction(context.result) };
+    const registered = CONSTRUCTIONS.get(named);
+    if (registered) return registered(context);
+    const preset = constructionOfSystem(named, context.result);
+    if (preset) return { construction: preset, ...named === "canvas" ? { extras: { tents: tentsOf(context.result) } } : {} };
+    throw new Error(`Unknown construction "${named}": register it with registerConstruction`);
+  }
+
+  // src/locales/en.json
+  var en_default = {
+    ui: {
+      structure_layer: "Structure",
+      structure_column_concrete: "Concrete pillar",
+      structure_column_steel: "Steel post",
+      structure_column_masonry: "Masonry pillar",
+      structure_column_wood: "Wood post",
+      structure_beam_concrete: "Bond beam / beam (concrete)",
+      structure_beam_wood: "Plate / beam (wood)",
+      structure_roof_frame: "Trusses, rafters and ridge (roof view)"
+    }
+  };
+
+  // src/locales/pt-BR.json
+  var pt_BR_default = {
+    ui: {
+      structure_layer: "Estrutura",
+      structure_column_concrete: "Pilar de concreto",
+      structure_column_steel: "Poste de a\xE7o",
+      structure_column_masonry: "Pilar de alvenaria",
+      structure_column_wood: "Pilar de madeira",
+      structure_beam_concrete: "Cinta / viga (concreto)",
+      structure_beam_wood: "Prato / viga (madeira)",
+      structure_roof_frame: "Tesouras, caibros e cumeeira (vista do telhado)"
+    }
+  };
+
+  // src/types.ts
+  var GROUND = "ground";
+
+  // src/density.ts
+  var DENSITY = {
+    steel: 7850,
+    cast_iron: 7200,
+    aluminium: 2700,
+    copper: 8900,
+    wood_soft: 500,
+    wood_hard: 800,
+    plywood: 600,
+    mdf: 750,
+    glass: 2500,
+    tempered_glass: 2500,
+    ceramic: 2e3,
+    concrete: 2400,
+    brick: 1800,
+    plaster: 1e3,
+    stone: 2600,
+    plastic: 950,
+    rubber: 1100,
+    fabric: 400,
+    foam: 30,
+    leather: 900,
+    paper: 800,
+    foliage: 100,
+    green_wood: 900,
+    cactus: 700,
+    flesh_fruit: 900,
+    wax: 900,
+    soil: 1600
+  };
+  var DEFAULT_DENSITY = 500;
+  var densityOf = (material) => DENSITY[material] ?? DEFAULT_DENSITY;
+
+  // src/structure/builder.ts
+  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, ...extras } = options;
+      const volume = Math.max(0, (aabb[2] - aabb[0]) * (aabb[3] - aabb[1]) * (y1 - y0)) * (fill ?? 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);
+    }
+  };
+
+  // src/structure/legacy-key.ts
+  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;
+  }
+
+  // src/structure/context.ts
+  var OPEN_ROOM_TYPES = ["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 floorCount = 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 < floorCount - 1 && !isUnit ? level(floor + 1) - system.slabThickness : level(floor) + ceilingOf(floor);
+    const rectsOf = (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,
+      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,
+      baseOf: (floor) => floor === 0 ? context.base0 : builder.find(`slab_${floor}`)
+    };
+    const closed = rectsOf(0, ["balcony", "porch"]);
+    context.houseBox = unionOf(closed.length ? closed : rectsOf(0));
+    context.walls = classifyWalls(context);
+    return context;
+  }
+  var isBearingOnTop = (wall, walls) => {
+    const along = (w, pick) => w.axis === "u" ? pick(w.u0, w.u1) : pick(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;
+
+  // src/structure/balconies.ts
+  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 box = 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: box, 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: [box[0] - 0.08, box[1] - 0.08, box[0] + 0.08, box[1] + 0.08], y0: 0, y1: context.level(floor) - system.slabThickness }, { floor: 0 });
+      builder.rest(pillar, GROUND, "rebar");
+      builder.rest(deck, pillar, "rebar");
+    }
+  }
+
+  // src/structure/canvas.ts
+  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: [] };
+  }
+
+  // src/structure/extras.ts
+  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");
+  }
+
+  // src/structure/floor-deck.ts
+  var JOIST_PITCH = 0.6;
+  function addJoists(context, options) {
+    const { floor, box, thickness, carriers, material, joint, suffix = "" } = options;
+    const length = box[2] - box[0];
+    const depth = box[3] - box[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 ? box[0] : box[1]) + 0.05 + k * (span - 0.1) / (count - 1);
+      const aabb = alongU ? [centre - 0.025, box[1], centre + 0.025, box[3]] : [box[0], centre - 0.025, box[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, thickness, joint } = options;
+    const deck = context.builder.add({ id, role: "slab", material, aabb: box, 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;
+  }
+
+  // src/structure/foundation.ts
+  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: box } = context;
+    const corners = [[box[0], box[1]], [box[2], box[1]], [box[0], box[3]], [box[2], box[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: box, y0: top, y1: context.level(0) }, { floor: 0 });
+    for (const pillar of pillars) builder.rest(slab, pillar, "rebar");
+    context.base0 = slab;
+  }
+  function addBasement(context) {
+    const { builder, houseBox: box, elevation } = context;
+    const depth = context.construction.foundation.depth || 2.4;
+    const floor = builder.add({ id: "basement_slab", role: "slab", material: "concrete", aabb: box, y0: -depth - 0.15, y1: -depth }, { floor: -1 });
+    builder.rest(floor, GROUND, "resting");
+    const sides = [
+      ["front", [box[0], box[1] - 0.1, box[2], box[1] + 0.1]],
+      ["back", [box[0], box[3] - 0.1, box[2], box[3] + 0.1]],
+      ["left", [box[0] - 0.1, box[1], box[0] + 0.1, box[3]]],
+      ["right", [box[2] - 0.1, box[1], box[2] + 0.1, box[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((box[2] - box[0]) / 3));
+    for (let k = 0; k < count; k++) {
+      const u = box[0] + (k + 0.5) * (box[2] - box[0]) / count;
+      const v = (box[1] + box[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: box, elevation, construction } = context;
+    const columns = Math.max(2, Math.ceil((box[2] - box[0]) / 2) + 1);
+    const rows = Math.max(2, Math.ceil((box[3] - box[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 = box[0] + i * (box[2] - box[0]) / (columns - 1);
+        const v = box[1] + j * (box[3] - box[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 = box[2] - box[0] >= box[3] - box[1];
+    const beams = [];
+    const lines = alongU ? rows : columns;
+    for (let line = 0; line < lines; line++) {
+      const at2 = alongU ? box[1] + line * (box[3] - box[1]) / (rows - 1) : box[0] + line * (box[2] - box[0]) / (columns - 1);
+      const aabb = alongU ? [box[0], at2 - 0.07, box[2], at2 + 0.07] : [at2 - 0.07, box[1], at2 + 0.07, box[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: box } = context;
+    const carriers = construction.foundation.type === "basement" ? addBasement(context) : addPiers(context);
+    const thickness = system.slabThickness;
+    const joists = addJoists(context, { floor: 0, box, 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, 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");
+  }
+
+  // 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;
+  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 box = [u - 0.1, v - 0.1, u + 0.1, v + 0.1];
+      const top = Math.max(topOfFloor, ...plates.filter((plate) => touches(plate.aabb, box, 0.05)).map((plate) => plate.y0));
+      const pillar = builder.add({ id: `column_${floor}_${k}`, role: "column", material: context.construction.frame.pillars, aabb: box, 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]);
+  }
+
+  // src/structure/porch.ts
+  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);
+    }
+  }
+
+  // src/structure/porch-roof.ts
+  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");
+      }
+    }
+  }
+
+  // src/structure/roof.ts
+  var TRUSS_PITCH = 1.2;
+  var DEFAULT_PITCH = 20;
+  var DEFAULT_EAVE = 0.4;
+  var CLOSED_ONLY = [...OPEN_ROOM_TYPES, "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_TYPES.includes(room.type) && room.type !== "void" && room.type !== "elevator");
+      for (const room of rooms) {
+        const area = 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 < area * 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 });
+    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 } = 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" ? box[0] : box[1]) + k * length / (count - 1);
+      const aabb = axis === "u" ? [at2 - 0.04, box[1] - eave * 0.5, at2 + 0.04, box[3] + eave * 0.5] : [box[0] - eave * 0.5, at2 - 0.04, box[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 } = unit;
+    const roof = context.construction.roof;
+    const platesHere = context.plates.get(unit.floor) ?? [];
+    const width = box[2] - box[0];
+    const depth = box[3] - box[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 } = unit;
+    const { axis, length, eave, rise, eaveY } = geometry;
+    const count = Math.max(2, Math.ceil(length / TRUSS_PITCH) + 1);
+    const middle = axis === "u" ? (box[1] + box[3]) / 2 : (box[0] + box[2]) / 2;
+    const frames = { all: [], sideA: [], sideB: [] };
+    for (let k = 0; k < count; k++) {
+      const at2 = (axis === "u" ? box[0] : box[1]) + k * length / (count - 1);
+      const halves = axis === "u" ? [["a", [at2 - 0.04, box[1] - eave * 0.5, at2 + 0.04, middle]], ["b", [at2 - 0.04, middle, at2 + 0.04, box[3] + eave * 0.5]]] : [["a", [box[0] - eave * 0.5, at2 - 0.04, middle, at2 + 0.04]], ["b", [middle, at2 - 0.04, box[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" ? [box[0] - eave, middle - 0.05, box[2] + eave, middle + 0.05] : [middle - 0.05, box[1] - eave, middle + 0.05, box[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 frame of carried) builder.rest(pane, frame, 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 box = 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 = box[2] - box[0];
+    const depth = box[3] - box[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 ? box[0] : box[1]) + 0.05 + k * (span - 0.1) / (count - 1);
+      const aabb = alongU ? [at2 - 0.025, box[1], at2 + 0.025, box[3]] : [box[0], at2 - 0.025, box[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_TYPES);
+    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_TYPES));
+    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);
+  }
+
+  // src/structure/stairs.ts
+  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");
+  }
+
+  // src/structure/openings.ts
+  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 box = 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: box, 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, box)) 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];
+
+  // src/structure/steps.ts
+  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);
+  }
+
+  // src/structure/tank-parts.ts
+  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 box = 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(box, part.aabb, 0.1)
+    );
+    const slab = builder.add({ id: "slab_ceiling", role: "slab", material: construction.frame.slabs, aabb: box, y0: y - 0.12, y1: y }, { floor: top });
+    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);
+    }
+  }
+
+  // src/structure/upper-floor.ts
+  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 box = 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, thickness, carriers, material: construction.frame.timber, joint: system.joints.beam });
+      addDeck(context, `slab_${next}`, construction.frame.slabs, { floor: next, box, thickness, joint: system.joints.slab }, joists);
+      return;
+    }
+    const slab = builder.add({ id: `slab_${next}`, role: "slab", material: construction.frame.slabs, aabb: box, y0: context.level(next) - thickness, y1: context.level(next) }, { floor: next });
+    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);
+  }
+
+  // src/structure/walls.ts
+  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);
+  }
+
+  // src/structure/index.ts
+  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);
+    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) };
+  }
+
+  // src/utilities/content-tables.ts
+  var entry = (itemId, min, max, group, pickable, weight) => ({ itemId, min, max, group, pickable, weight });
+  var FRIDGE = [
+    entry("water_bottle", 1, 3, "water", true, 3),
+    entry("milk_carton", 1, 2, "food", true, 2),
+    entry("eggs", 1, 1, "food", true, 2),
+    entry("packed_meat", 1, 2, "food", true, 1.5),
+    entry("fruit", 1, 4, "food", true, 2),
+    entry("yogurt", 1, 3, "food", true, 1),
+    entry("soda", 1, 2, "water", true, 1),
+    entry("cheese", 1, 1, "food", true, 1),
+    entry("insulin", 1, 1, "medicine", true, 0.4),
+    entry("leftovers", 1, 2, "food", true, 1)
+  ];
+  var BEDSIDE = [entry("medicine", 1, 2, "medicine", true, 2), entry("book", 1, 2, "document", true, 1.5), entry("charger", 1, 1, "tool", true, 1), entry("flashlight", 1, 1, "tool", true, 0.7), entry("glasses", 1, 1, "tool", true, 0.7)];
+  var WARDROBE = [
+    entry("shirt", 2, 6, "clothes", true, 3),
+    entry("trousers", 1, 4, "clothes", true, 3),
+    entry("coat", 1, 2, "clothes", true, 1.5),
+    entry("sneakers", 1, 2, "clothes", true, 1.5),
+    entry("shoes", 1, 2, "clothes", true, 1),
+    entry("blanket", 1, 2, "clothes", true, 1.5),
+    entry("backpack", 1, 1, "tool", true, 0.8)
+  ];
+  var DRESSER = [entry("underwear", 2, 6, "clothes", true, 3), entry("socks", 2, 6, "clothes", true, 2), entry("t_shirt", 1, 4, "clothes", true, 2), entry("documents", 1, 2, "document", true, 1), entry("flashlight", 1, 1, "tool", true, 0.7), entry("batteries", 1, 2, "tool", true, 0.7)];
+  var FILING = [entry("documents", 1, 4, "document", true, 3), entry("pen", 1, 3, "tool", true, 1.5), entry("keys", 1, 2, "tool", true, 1), entry("stapler", 1, 1, "improvised_weapon", true, 0.5)];
+  var TRASH = [entry("full_trash_bag", 1, 1, "trash", false, 2), entry("packaging", 1, 4, "trash", true, 3), entry("empty_can", 1, 3, "trash", true, 2), entry("crumpled_paper", 1, 3, "trash", true, 1)];
+  var CONTENT_TABLES = {
+    fridge: FRIDGE,
+    display_fridge: [entry("soda", 2, 6, "water", true, 3), entry("water_bottle", 2, 6, "water", true, 3), entry("yogurt", 2, 5, "food", true, 2)],
+    freezer: [entry("frozen_meat", 2, 5, "food", true, 3), entry("ice_cream", 1, 2, "food", true, 1)],
+    kitchen_cabinet: [
+      entry("pot", 1, 2, "tool", true, 1.5),
+      entry("kitchen_knife", 1, 2, "improvised_weapon", true, 1.5),
+      entry("dish_soap", 1, 2, "cleaning", true, 2),
+      entry("sponge", 1, 2, "cleaning", true, 1),
+      entry("rice", 1, 2, "food", true, 1.5),
+      entry("beans", 1, 2, "food", true, 1.5),
+      entry("pasta", 1, 2, "food", true, 1),
+      entry("cooking_oil", 1, 1, "food", true, 1),
+      entry("canned_tuna", 1, 3, "food", true, 1.5),
+      entry("disinfectant", 1, 1, "cleaning", true, 1),
+      entry("trash_bag", 1, 2, "trash", true, 0.7)
+    ],
+    overhead_cabinet: [entry("plates", 4, 8, "utensil", false, 3), entry("glasses", 3, 6, "utensil", false, 3), entry("mug", 1, 3, "utensil", true, 1.5), entry("coffee", 1, 2, "food", true, 1.5), entry("canned_corn", 1, 3, "food", true, 1.5), entry("spices", 1, 3, "food", true, 1)],
+    washbasin: [
+      entry("painkiller", 1, 2, "medicine", true, 2),
+      entry("bandages", 1, 2, "medicine", true, 2),
+      entry("soap", 1, 3, "cleaning", true, 2),
+      entry("toilet_paper", 1, 4, "cleaning", true, 2),
+      entry("shampoo", 1, 2, "cleaning", true, 1),
+      entry("toothbrush", 1, 2, "cleaning", true, 1),
+      entry("scissors", 1, 1, "improvised_weapon", true, 0.5),
+      entry("rubbing_alcohol", 1, 1, "medicine", true, 1)
+    ],
+    wardrobe: WARDROBE,
+    wardrobe_large: WARDROBE,
+    dresser: DRESSER,
+    console_table: DRESSER,
+    nightstand: BEDSIDE,
+    filing_cabinet: FILING,
+    pantry: [
+      entry("rice", 2, 4, "food", true, 2),
+      entry("beans", 2, 4, "food", true, 2),
+      entry("canned_tuna", 2, 5, "food", true, 2),
+      entry("water_jug", 1, 2, "water", true, 2),
+      entry("flour", 1, 2, "food", true, 1),
+      entry("sugar", 1, 2, "food", true, 1),
+      entry("cooking_oil", 1, 2, "food", true, 1),
+      entry("biscuits", 1, 4, "food", true, 1.5)
+    ],
+    tv_unit: [entry("remote_control", 1, 1, "tool", true, 2), entry("dvds", 1, 4, "document", true, 1), entry("cables", 1, 3, "tool", true, 1.5), entry("batteries", 1, 2, "tool", true, 1)],
+    laundry_cabinet: [entry("washing_powder", 1, 2, "cleaning", true, 3), entry("bleach", 1, 2, "cleaning", true, 2), entry("disinfectant", 1, 2, "cleaning", true, 2), entry("bucket", 1, 1, "tool", true, 1), entry("broom", 1, 1, "improvised_weapon", true, 1), entry("rubber_gloves", 1, 2, "cleaning", true, 1)],
+    laundry_shelf: [entry("washing_powder", 1, 1, "cleaning", true, 2), entry("softener", 1, 2, "cleaning", true, 2), entry("clothespins", 1, 1, "tool", true, 1)],
+    workbench: [entry("hammer", 1, 1, "improvised_weapon", true, 2), entry("screwdriver", 1, 2, "tool", true, 2), entry("pliers", 1, 1, "tool", true, 1.5), entry("insulating_tape", 1, 2, "tool", true, 1), entry("screws", 1, 2, "tool", true, 1)],
+    tool_shelf: [entry("hammer", 1, 1, "improvised_weapon", true, 1.5), entry("hand_saw", 1, 1, "improvised_weapon", true, 1), entry("paint_can", 1, 3, "trash", true, 1.5), entry("rope", 1, 1, "tool", true, 1), entry("nails", 1, 2, "tool", true, 1.5)],
+    mailbox: [entry("letter", 1, 4, "document", true, 3), entry("bill", 1, 2, "document", true, 2), entry("flyer", 1, 4, "trash", true, 2)],
+    trash_bin: TRASH,
+    outdoor_bin: TRASH,
+    china_cabinet: [entry("china_plates", 3, 6, "utensil", false, 3), entry("wine_glasses", 2, 5, "utensil", false, 2)]
+  };
+  var SUPPLY_GROUPS = ["food", "water", "medicine", "tool"];
+
+  // src/utilities/content.ts
+  var FRIDGES = ["fridge", "display_fridge", "freezer"];
+  var isSupply = (entry2) => SUPPLY_GROUPS.includes(entry2.group);
+  var CONTENT_STATES = {
+    normal: { kinds: (base) => base, weight: (entry2) => entry2.weight, extraQuantity: () => 0 },
+    fortified: { kinds: (base, available) => Math.min(available, base + 2), weight: (entry2) => isSupply(entry2) ? entry2.weight * 2.5 : entry2.weight, extraQuantity: (entry2) => isSupply(entry2) ? 1 : 0 },
+    abandoned: {
+      kinds: (_base, _available, rng) => rng() < 0.4 ? 0 : 1,
+      weight: (entry2) => entry2.weight,
+      extraQuantity: () => 0,
+      leftovers(found, container, rng) {
+        if (found.length === 0 && rng() < 0.5) found.push({ itemId: "scraps_and_papers", count: 1, pickable: false, group: "trash" });
+        if (FRIDGES.includes(container)) found.push({ itemId: "spoiled_food", count: 1, pickable: false, group: "trash" });
+      }
+    }
+  };
+  function weightedOrder(candidates, rng) {
+    const pool = candidates.slice();
+    const out = [];
+    while (pool.length) {
+      let x = rng() * pool.reduce((sum, c) => sum + c.weight, 0);
+      let i = 0;
+      for (; i < pool.length - 1; i++) {
+        x -= pool[i].weight;
+        if (x < 0) break;
+      }
+      out.push(pool.splice(i, 1)[0]);
+    }
+    return out;
+  }
+  function contentOf(query) {
+    const pool = CONTENT_TABLES[query.container];
+    if (!pool) return [];
+    const rule = CONTENT_STATES[query.state] ?? CONTENT_STATES.normal;
+    const { rng } = query;
+    const base = Math.max(2, Math.min(5, Math.round(1.5 + query.footprint * 3 + rng() * 1.5)));
+    const kinds = rule.kinds(base, pool.length, rng);
+    const found = [];
+    for (const candidate of weightedOrder(pool.map((entry2) => ({ entry: entry2, weight: rule.weight(entry2) })), rng).slice(0, kinds)) {
+      const { entry: entry2 } = candidate;
+      const count = entry2.min + Math.floor(rng() * (entry2.max - entry2.min + 1)) + rule.extraQuantity(entry2);
+      found.push({ itemId: entry2.itemId, count, pickable: entry2.pickable, group: entry2.group });
+    }
+    rule.leftovers?.(found, query.container, rng);
+    return found;
+  }
+  var hasContent = (container) => container in CONTENT_TABLES;
+
+  // src/utilities/shared.ts
+  var HALF_WALL = 0.075;
+  var round22 = (value) => Math.round(value * 100) / 100;
+  var clamp = (value, low, high) => Math.max(low, Math.min(high, value));
+  var overlaps = (a, b, epsilon = 1e-6) => a[0] < b[2] - epsilon && a[2] > b[0] + epsilon && a[1] < b[3] - epsilon && a[3] > b[1] + epsilon;
+  var inner = (rect) => [rect[0] + HALF_WALL, rect[1] + HALF_WALL, rect[2] - HALF_WALL, rect[3] - HALF_WALL];
+  var isSolid = (item) => !item.flat && !item.on && (!item.decor || item.mount === "floor");
+  var distanceToRect = (u, v, rect) => Math.hypot(Math.max(rect[0] - u, 0, u - rect[2]), Math.max(rect[1] - v, 0, v - rect[3]));
+  var NO_SOCKET_ROOMS = ["void", "elevator", "stairs", "balcony", "terrace", "porch", "tent"];
+  var outwardOf = (wall) => {
+    const sign = wall.sides[0] === "outside" ? -1 : 1;
+    return wall.axis === "u" ? [0, sign] : [sign, 0];
+  };
+  var sideNameOf = (vector) => Math.abs(vector[0]) > Math.abs(vector[1]) ? vector[0] > 0 ? "right" : "left" : vector[1] > 0 ? "back" : "front";
+  function groundExteriorWalls(plan) {
+    return plan.walls.filter((wall) => wall.exterior && wall.floor === 0 && wall.type === "wall" && Math.hypot(wall.u1 - wall.u0, wall.v1 - wall.v0) >= 1);
+  }
+
+  // src/utilities/wall-points.ts
+  var STEP = 0.05;
+  var SURFACE_OFFSET = 0.012;
+  function wallPointsOf(plan, room, items, margin = 0.3) {
+    const points = [];
+    const windows = plan.windows.filter((w) => w.floor === room.floor);
+    const solids = items.filter((m) => m.floor === room.floor && !m.outdoor && m.room === room.id && isSolid(m));
+    for (const wall of plan.walls) {
+      if (wall.floor !== room.floor || wall.type !== "wall" || !wall.sides.includes(room.id)) continue;
+      const side = wall.sides[1] === room.id ? 1 : -1;
+      const a0 = wall.axis === "u" ? Math.min(wall.u0, wall.u1) : Math.min(wall.v0, wall.v1);
+      const a1 = wall.axis === "u" ? Math.max(wall.u0, wall.u1) : Math.max(wall.v0, wall.v1);
+      const pos = wall.axis === "u" ? wall.v0 : wall.u0;
+      const nearby = windows.filter((w) => w.axis === wall.axis && Math.abs(w.pos - pos) < 1e-3 && w.at + w.width / 2 > a0 && w.at - w.width / 2 < a1);
+      for (let c = a0 + margin; c <= a1 - margin + 1e-9; c += STEP) {
+        const u = wall.axis === "u" ? c : pos + side * (HALF_WALL + SURFACE_OFFSET);
+        const v = wall.axis === "u" ? pos + side * (HALF_WALL + SURFACE_OFFSET) : c;
+        points.push({
+          u: round22(u),
+          v: round22(v),
+          c: round22(c),
+          axis: wall.axis,
+          pos,
+          side,
+          nu: wall.axis === "u" ? 0 : side,
+          nv: wall.axis === "u" ? side : 0,
+          a0,
+          a1,
+          exterior: wall.exterior,
+          windows: nearby,
+          blocked: (height) => solids.some((m) => m.aabb && Math.hypot(Math.max(m.aabb[0] - u, 0, u - m.aabb[2]), Math.max(m.aabb[1] - v, 0, v - m.aabb[3])) < 0.12 && (m.y || 0) + m.h > height)
+        });
+      }
+    }
+    return points;
+  }
+  var hasWindowAt = (point, y, clearance = 0.2) => point.windows.some((w) => y + 0.1 > w.y0 - 0.05 && y - 0.1 < w.y1 + 0.05 && Math.abs(point.c - w.at) < w.width / 2 + clearance);
+  var atDoor = (plan, room, point, clearance) => plan.doors.some((d) => d.floor === room.floor && d.axis === point.axis && Math.abs(d.pos - point.pos) < 1e-3 && Math.abs(d.at - point.c) < d.width / 2 + clearance);
+
+  // src/utilities/electrical-outlets.ts
+  var APPLIANCES = ["fridge", "display_fridge", "freezer", "tv", "appliance", "washing_machine", "air_conditioner", "cash_register", "table_light"];
+  var COUNTERS = ["kitchen_cabinet", "workbench", "checkout_counter"];
+  var LAMPS = ["table_light", "lamp"];
+  var needsSocket = (item) => APPLIANCES.includes(item.category) || item.category === "shower";
+  function addOutlets(layout) {
+    const { plan, items, rooms, electrical, pointsOf } = layout;
+    let counter = 0;
+    const outletsOf = (room) => electrical.outlets.filter((t) => t.room === room.id && t.floor === room.floor);
+    const newOutlet = (room, point, y) => {
+      const outlet = { id: `outlet${++counter}`, room: room.id, floor: room.floor, u: point.u, v: point.v, y, c: point.c, axis: point.axis, pos: point.pos, frontU: point.nu, frontV: point.nv, type: "2P+T", voltage: 127 };
+      electrical.outlets.push(outlet);
+      return outlet;
+    };
+    const counters = items.filter((m) => COUNTERS.includes(m.category) && !m.outdoor);
+    const heightFor = (room, point) => room.type === "kitchen" && counters.some((m) => m.floor === room.floor && m.room === room.id && distanceToRect(point.u, point.v, m.aabb) < 0.45) ? 1.1 : 0.3;
+    const valid = (room, point, y) => !hasWindowAt(point, y, 0.25) && !atDoor(plan, room, point, 0.45) && !outletsOf(room).some((t) => Math.hypot(t.u - point.u, t.v - point.v) < 0.5 && t.y === y);
+    const pick = (room, score, fixedY, ignoreBlocked) => {
+      let best = null;
+      for (const point of pointsOf.get(keyOf(room)) ?? []) {
+        const y = fixedY ?? heightFor(room, point);
+        if (!valid(room, point, y)) continue;
+        const total = score(point) + (point.blocked(y) && !ignoreBlocked ? 5 : 0);
+        if (!best || total < best.score) best = { point, y, score: total };
+      }
+      return best;
+    };
+    const roomOf = (item) => rooms.find((x) => x.id === item.room && x.floor === item.floor);
+    const appliances = items.filter((m) => !m.outdoor && needsSocket(m) && rooms.some((c) => c.id === m.room && c.floor === m.floor) && m.category !== "table_light");
+    for (const item of appliances) connectAppliance(item);
+    function connectAppliance(item) {
+      const room = roomOf(item);
+      const target = item.aabb;
+      const nearest = outletsOf(room).map((t) => ({ t, d: distanceToRect(t.u, t.v, target) })).filter((o) => o.d <= 1.2 && o.t.y <= 1.1).sort((a, b) => a.d - b.d)[0];
+      const isShower = item.category === "shower";
+      let outlet = nearest && !isShower ? nearest.t : null;
+      if (!outlet) {
+        const height = isShower ? 1.1 : item.y > 0.7 ? 1.1 : null;
+        const best = pick(room, (p) => {
+          const d = distanceToRect(p.u, p.v, target);
+          return isShower && d < 0.6 ? 50 + d : d;
+        }, height);
+        let chosen = best;
+        if (!isShower && (!best || distanceToRect(best.point.u, best.point.v, target) > 1.4)) {
+          const behind = pick(room, (p) => distanceToRect(p.u, p.v, target), item.y > 0.7 ? 1.1 : null, true);
+          if (behind && (!best || distanceToRect(behind.point.u, behind.point.v, target) < distanceToRect(best.point.u, best.point.v, target))) chosen = behind;
+        }
+        if (chosen) outlet = newOutlet(room, chosen.point, chosen.y);
+      }
+      if (!outlet) return;
+      item.outlet = outlet.id;
+      if (isShower) item.showerHeater = { electric: true, powerW: 5500, outlet: outlet.id };
+    }
+    for (const room of rooms) {
+      const area = room.parts.reduce((sum, q) => sum + (q[2] - q[0]) * (q[3] - q[1]), 0);
+      const wanted = Math.max(room.type === "kitchen" ? 3 : 2, Math.min(6, Math.round(area / 7)));
+      const farthest = (existing) => (p) => -Math.min(9, ...existing.map((t) => Math.hypot(t.u - p.u, t.v - p.v)));
+      for (let guard = 0; outletsOf(room).length < wanted && guard < 12; guard++) {
+        const best = pick(room, farthest(outletsOf(room)), null);
+        if (!best) break;
+        newOutlet(room, best.point, best.y);
+      }
+      if (room.type !== "kitchen" || !counters.some((m) => m.room === room.id)) continue;
+      for (let guard = 0; outletsOf(room).filter((t) => t.y === 1.1).length < 2 && guard < 4; guard++) {
+        const existing = outletsOf(room);
+        const best = pick(room, (p) => (heightFor(room, p) === 1.1 ? 0 : 20) - Math.min(9, ...existing.map((t) => Math.hypot(t.u - p.u, t.v - p.v))), 1.1);
+        if (!best) break;
+        newOutlet(room, best.point, 1.1);
+      }
+    }
+    for (const item of appliances) {
+      if (item.category === "shower" || !item.outlet) continue;
+      const room = roomOf(item);
+      const current = outletsOf(room).find((t) => t.id === item.outlet);
+      if (!current || distanceToRect(current.u, current.v, item.aabb) <= 1.2) continue;
+      const other = outletsOf(room).filter((t) => t.y <= 1.1).map((t) => ({ t, d: distanceToRect(t.u, t.v, item.aabb) })).sort((a, b) => a.d - b.d)[0];
+      if (other && other.d < distanceToRect(current.u, current.v, item.aabb) && other.d <= 1.2) item.outlet = other.t.id;
+    }
+    for (const item of items.filter((m) => LAMPS.includes(m.category) && !m.outdoor)) {
+      const room = roomOf(item);
+      if (!room) continue;
+      const nearest = outletsOf(room).map((t) => ({ t, d: distanceToRect(t.u, t.v, item.aabb) })).sort((a, b) => a.d - b.d)[0];
+      if (nearest) item.outlet = nearest.t.id;
+    }
+  }
+
+  // src/utilities/electrical-entrance.ts
+  var METER_SIZE = { w: 0.35, d: 0.2, h: 0.5 };
+  var mainDoorOf = (plan) => plan.doors.find((p) => p.floor === 0 && p.exterior && p.side === "front") || plan.doors.find((p) => p.floor === 0 && p.exterior);
+  function placeEntrance(layout) {
+    const { plan, electrical } = layout;
+    const gate = plan.gates.find((g) => g.type === "pedestrian");
+    const door = mainDoorOf(plan);
+    const lot = plan.lot;
+    if (lot && plan.style !== "commercial") {
+      const rect = lot.rect;
+      const poleU = clamp(gate ? gate.u + 3 : plan.w / 2, rect[0] + 0.5, rect[2] - 0.5);
+      const poleV = rect[1] - 0.6;
+      let meter;
+      if (gate) {
+        const direction = gate.u - gate.width / 2 - 0.4 >= rect[0] + 0.3 ? -1 : 1;
+        meter = { place: "gate_pillar", u: round22(gate.u + direction * (gate.width / 2 + 0.25)), v: round22(gate.v), y: 1.4, side: "front", ...METER_SIZE };
+      } else meter = { place: "facade", u: round22(door ? door.at + 1.2 : plan.w / 2), v: -0.1, y: 1.4, side: "front", ...METER_SIZE };
+      meter.id = "meter";
+      electrical.serviceEntrance = { pole: { u: round22(poleU), v: round22(poleV), h: 7.5 }, drop: [[round22(poleU), round22(poleV), 6.5], [meter.u, meter.v, 2.6]], meter, descent: [[meter.u, meter.v, 2.6], [meter.u, meter.v, 1.65]], internalRun: null };
+    } else if (lot === null || plan.style === "commercial") {
+      const front = door ? { u: round22(door.at + 1), v: -0.1 } : { u: round22(plan.w / 2), v: -0.1 };
+      electrical.serviceEntrance = {
+        pole: { u: round22(front.u + 2), v: -3, h: 7.5 },
+        drop: [[round22(front.u + 2), -3, 6.5], [front.u, front.v, 3.2]],
+        meter: { id: "meter", place: "facade", u: front.u, v: front.v, y: 1.4, side: "front", ...METER_SIZE },
+        descent: [[front.u, front.v, 3.2], [front.u, front.v, 1.65]],
+        internalRun: null
+      };
+    }
+  }
+  function placePanel(layout) {
+    const { plan, rooms, electrical, pointsOf } = layout;
+    const door = mainDoorOf(plan);
+    const room = door && rooms.find((c) => c.id === door.a && c.floor === 0) || rooms.find((c) => c.floor === 0) || rooms[0];
+    if (!room) return;
+    const meter = electrical.serviceEntrance?.meter;
+    const targetU = meter ? meter.u : plan.w / 2;
+    const targetV = meter ? Math.max(0, meter.v) : 0;
+    let best = null;
+    for (const point of pointsOf.get(keyOf(room)) ?? []) {
+      if (point.blocked(1.5) || hasWindowAt(point, 1.5, 0.3) || atDoor(plan, room, point, 0.8)) continue;
+      const score = Math.hypot(point.u - targetU, point.v - targetV) + (point.exterior ? 0 : 3);
+      if (!best || score < best.score) best = { point, score };
+    }
+    if (!best) best = { point: (pointsOf.get(keyOf(room)) ?? [])[0], score: 0 };
+    if (best.point) {
+      const p = best.point;
+      electrical.panel = { id: "panel", room: room.id, floor: room.floor, u: p.u, v: p.v, y: 1.5, c: p.c, axis: p.axis, pos: p.pos, frontU: p.nu, frontV: p.nv, w: 0.3, h: 0.4, breakers: 0 };
+    }
+    if (electrical.serviceEntrance && electrical.panel) {
+      const entrance = electrical.serviceEntrance;
+      entrance.internalRun = [[entrance.meter.u, entrance.meter.v, 0.1], [electrical.panel.u, electrical.panel.v, heightOf(plan, electrical.panel.floor, electrical.panel.y)]];
+    }
+  }
+
+  // src/utilities/electrical-circuits.ts
+  var LAMP_CATEGORIES = ["ceiling_light", "lamp", "table_light"];
+  var lampsOf = (layout) => layout.items.filter((m) => !m.outdoor && LAMP_CATEGORIES.includes(m.category));
+  function addSwitches(layout) {
+    const { plan, items, rooms, electrical, pointsOf } = layout;
+    const lamps = lampsOf(layout);
+    const door = mainDoorOf(plan);
+    let counter = 0;
+    const positionFor = (room) => {
+      const doors = plan.doors.filter((p) => p.floor === room.floor && (p.a === room.id || p.b === room.id)).sort((a, b) => (a.opensTo === room.id ? 0 : 1) - (b.opensTo === room.id ? 0 : 1) || (a.width < b.width ? 1 : -1));
+      const points = wallPointsOf(plan, room, items, 0.12);
+      for (const tolerance of [0.16, 0.3]) {
+        for (const d of doors) {
+          for (const direction of [1, -1]) {
+            const target = d.at + direction * (d.width / 2 + 0.18);
+            const point = points.filter((q) => q.axis === d.axis && Math.abs(q.pos - d.pos) < 1e-3 && !hasWindowAt(q, 1.1, 0.2)).sort((a, b) => Math.abs(a.c - target) - Math.abs(b.c - target))[0];
+            if (point && Math.abs(point.c - target) <= tolerance && !atDoor(plan, room, point, 0) && Math.abs(point.c - d.at) >= d.width / 2 + 0.12) return { point, door: d, latch: direction === 1 };
+          }
+        }
+      }
+      return null;
+    };
+    for (const room of rooms.concat(plan.rooms.filter((x) => ["stairs"].includes(x.type)))) {
+      const roomLamps = lamps.filter((m) => m.room === room.id && m.floor === room.floor);
+      const extra = door && door.a === room.id && room.floor === 0 && plan.lot ? [`outdoor_${door.id}`] : [];
+      if (!roomLamps.length && !extra.length) continue;
+      if (!pointsOf.get(keyOf(room))) pointsOf.set(keyOf(room), wallPointsOf(plan, room, items));
+      const found = positionFor(room);
+      if (!found) continue;
+      const p = found.point;
+      electrical.switches.push({ id: `switch${++counter}`, room: room.id, floor: room.floor, u: p.u, v: p.v, y: 1.1, c: p.c, axis: p.axis, pos: p.pos, frontU: p.nu, frontV: p.nv, door: found.door.id, latchSide: found.latch, controls: roomLamps.map((m) => m.id).concat(extra) });
+    }
+    if (door && plan.lot) {
+      const id = `outdoor_${door.id}`;
+      electrical.outdoorLamps.push({ id, u: round22(door.at + door.width / 2 + 0.32), v: round22(door.pos), y: 2.15, door: door.id, switch: electrical.switches.find((s) => s.controls.includes(id))?.id ?? null });
+    }
+  }
+  function addConduits(layout) {
+    const { plan, rooms, electrical } = layout;
+    const panel = electrical.panel;
+    const lamps = lampsOf(layout);
+    for (const room of rooms) {
+      const outlets = electrical.outlets.filter((t) => t.room === room.id && t.floor === room.floor);
+      const switches = electrical.switches.filter((i) => i.room === room.id && i.floor === room.floor);
+      const roomLamps = lamps.filter((m) => m.room === room.id && m.floor === room.floor);
+      if (!outlets.length && !switches.length) continue;
+      const ceiling = (room.ceiling || plan.floors[room.floor].ceiling) - 0.12;
+      const part = room.parts[0];
+      const centreU = round22((part[0] + part[2]) / 2);
+      const centreV = round22((part[1] + part[3]) / 2);
+      const circuit = { id: `circuit_${room.id}_${room.floor}`, room: room.id, floor: room.floor, outlets: outlets.map((t) => t.id), switches: switches.map((i) => i.id), lamps: roomLamps.map((m) => m.id), exposed: electrical.exposed, gauge_mm2: outlets.length > 3 ? 2.5 : 1.5 };
+      electrical.circuits.push(circuit);
+      const base = heightOf(plan, room.floor, 0);
+      const riser = panel ? [[panel.u, panel.v, heightOf(plan, panel.floor, panel.y)], [panel.u, panel.v, heightOf(plan, panel.floor, 0) + ceiling]] : [];
+      if (panel) electrical.conduits.push({ id: `conduit_${circuit.id}`, circuit: circuit.id, from: "panel", to: room.id, exposed: electrical.exposed, diameter: 0.025, points: riser.concat([[centreU, centreV, base + ceiling]]) });
+      for (const point of outlets.concat(switches)) {
+        electrical.conduits.push({ id: `conduit_${point.id}`, circuit: circuit.id, from: circuit.id, to: point.id, exposed: electrical.exposed, diameter: 0.02, points: [[centreU, centreV, base + ceiling], [point.u, point.v, base + ceiling], [point.u, point.v, base + point.y]] });
+      }
+    }
+    if (panel) panel.breakers = electrical.circuits.length + 1;
+  }
+
+  // src/utilities/electrical.ts
+  var keyOf = (room) => `${room.id}@${room.floor}`;
+  var absolute = (plan, floor, y) => (plan.floors[floor] ? plan.floors[floor].y0 : 0) + y;
+  var heightOf = absolute;
+  function planElectrical(context) {
+    const { plan, items, rng, energy } = context;
+    const mode = energy?.mode ?? "grid";
+    const electrical = { mode, serviceEntrance: null, panel: null, outlets: [], switches: [], circuits: [], conduits: [], exposed: false, outdoorLamps: [] };
+    electrical.exposed = plan.style === "budget" ? rng() < 0.65 : plan.style === "mid" ? rng() < 0.12 : false;
+    if (mode !== "grid") electrical.exposed = true;
+    if (mode === "offgrid") {
+      electrical.source = energy?.solar ? "solar" : "lamp";
+      return electrical;
+    }
+    const rooms = plan.rooms.filter((room) => !NO_SOCKET_ROOMS.includes(room.type) && !room.outdoor);
+    const pointsOf = /* @__PURE__ */ new Map();
+    for (const room of rooms) pointsOf.set(keyOf(room), wallPointsOf(plan, room, items));
+    const layout = { plan, items, rooms, electrical, pointsOf };
+    addOutlets(layout);
+    placeEntrance(layout);
+    placePanel(layout);
+    addSwitches(layout);
+    addConduits(layout);
+    if (mode === "tap" && electrical.serviceEntrance?.meter) {
+      const entrance = electrical.serviceEntrance;
+      const meter = entrance.meter;
+      entrance.tap = true;
+      entrance.connection = { u: meter.u, v: meter.v, y: 2.6 };
+      entrance.meter = null;
+    }
+    return electrical;
+  }
+
+  // src/utilities/gas.ts
+  var CYLINDER_TYPE = "cooking_gas_cylinder";
+  var CYLINDER = { w: 0.36, d: 0.36, h: 0.48 };
+  var CYLINDER_KG = 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 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),
+      y: 1.2,
+      side: sideNameOf(vector),
+      w: 0.3,
+      d: 0.15,
+      h: 0.4
+    };
+  }
+  function besideStove(context, stove, room, solids, doorZones) {
+    const t = [-stove.frontV, stove.frontU];
+    const parts = room.parts.map(inner);
+    for (const s of context.rng() < 0.5 ? [1, -1] : [-1, 1]) {
+      const cx = stove.x + t[0] * s * (stove.w / 2 + CYLINDER.w / 2 + 0.03) - stove.frontU * (stove.d - CYLINDER.d) / 2;
+      const cz = stove.z + t[1] * s * (stove.w / 2 + CYLINDER.w / 2 + 0.03) - stove.frontV * (stove.d - CYLINDER.d) / 2;
+      const rect = [cx - CYLINDER.w / 2, cz - CYLINDER.d / 2, cx + CYLINDER.w / 2, cz + CYLINDER.d / 2].map(round22);
+      const inside = parts.some((q) => rect[0] >= q[0] - 0.011 && rect[2] <= q[2] + 0.011 && rect[1] >= q[1] - 0.011 && rect[3] <= q[3] + 0.011);
+      if (inside && !solids.some((o) => overlaps(rect, o, 0.011)) && !doorZones.some((z) => overlaps(rect, z, 0.011))) return { mode: "beside", x: cx, z: cz, rect };
+    }
+    return void 0;
+  }
+  function inNiche(context, stove, room, doorZones) {
+    const { plan, items, stateItems } = context;
+    const wall = plan.walls.find(
+      (p) => p.exterior && p.floor === stove.floor && p.type === "wall" && p.sides.includes(room.id) && (p.axis === "u" ? Math.abs(stove.x - clamp(stove.x, p.u0, p.u1)) < 1.6 && Math.abs(stove.z - p.v0) < 1.6 : Math.abs(stove.z - clamp(stove.z, p.v0, p.v1)) < 1.6 && Math.abs(stove.x - p.u0) < 1.6)
+    );
+    if (!wall || stove.floor !== 0) return void 0;
+    const vector = outwardOf(wall);
+    const cx = wall.axis === "u" ? clamp(stove.x, wall.u0 + 0.4, wall.u1 - 0.4) : wall.u0 + vector[0] * (HALF_WALL + CYLINDER.w / 2 + 0.05);
+    const cz = wall.axis === "u" ? wall.v0 + vector[1] * (HALF_WALL + CYLINDER.d / 2 + 0.05) : clamp(stove.z, wall.v0 + 0.4, wall.v1 - 0.4);
+    const rect = [cx - CYLINDER.w / 2, cz - CYLINDER.d / 2, cx + CYLINDER.w / 2, cz + CYLINDER.d / 2].map(round22);
+    const blockedByItem = items.some((o) => o.outdoor && isSolid(o) && overlaps(rect, o.aabb, 0.011));
+    const blockedByState = stateItems.some((o) => o.outdoor && o.aabb && !o.flat && o.mount !== "ground" && overlaps(rect, o.aabb, 0.011));
+    const blockedByPath = plan.paths.some((c) => c.rects.some((z) => overlaps(rect, z, 0.011)));
+    const blockedByGate = plan.gates.some((g) => g.zones.some((z) => overlaps(rect, z, 0.011)));
+    const blockedByFence = !plan.lot || plan.lot.perimeter.some((q) => overlaps(rect, [Math.min(q.u0, q.u1) - HALF_WALL, Math.min(q.v0, q.v1) - HALF_WALL, Math.max(q.u0, q.u1) + HALF_WALL, Math.max(q.v0, q.v1) + HALF_WALL], 0.011));
+    if (blockedByItem || blockedByState || blockedByPath || doorZones.some((z) => overlaps(rect, z, 0.011)) || blockedByGate || blockedByFence) return void 0;
+    return { mode: "niche", x: cx, z: cz, rect, outdoor: true };
+  }
+  function underCounter(context, stove) {
+    const distance = (m) => Math.hypot(m.x - stove.x, m.z - stove.z);
+    const cabinets = context.items.filter(
+      (m) => m.floor === stove.floor && m.room === stove.room && !m.outdoor && !m.on && !m.flat && ["kitchen_cabinet", "workbench"].includes(m.category) && m.aabb && m.id !== stove.id && Math.min(m.aabb[2] - m.aabb[0], m.aabb[3] - m.aabb[1]) >= CYLINDER.d - 0.011 && Math.max(m.aabb[2] - m.aabb[0], m.aabb[3] - m.aabb[1]) >= CYLINDER.w + 0.02
+    ).sort((a, b) => (a.category === "kitchen_cabinet" ? 0 : 1) - (b.category === "kitchen_cabinet" ? 0 : 1) || distance(a) - distance(b));
+    for (const cabinet of cabinets) {
+      if (distance(cabinet) > 3) continue;
+      const box = cabinet.aabb;
+      const hw = CYLINDER.w / 2;
+      const hd = CYLINDER.d / 2;
+      const cx = clamp(stove.x, box[0] + hw + 0.01, box[2] - hw - 0.01);
+      const cz = clamp(stove.z, box[1] + hd + 0.01, box[3] - hd - 0.01);
+      const rect = [cx - hw, cz - hd, cx + hw, cz + hd].map(round22);
+      if (rect[0] < box[0] || rect[2] > box[2] || rect[1] < box[1] || rect[3] > box[3] || overlaps(rect, stove.aabb, 0.011)) continue;
+      return { mode: "under", x: cx, z: cz, rect, cabinet: cabinet.id };
+    }
+    return void 0;
+  }
+  var PLACEMENT = { beside: "beside", niche: "external_niche", under: "under_counter" };
+  function cylinderItem(stove, spot) {
+    const item = {
+      id: `${stove.room}.${CYLINDER_TYPE}`,
+      type: CYLINDER_TYPE,
+      category: CYLINDER_TYPE,
+      x: round22(spot.x),
+      z: round22(spot.z),
+      ry: 0,
+      w: CYLINDER.w,
+      d: CYLINDER.d,
+      h: CYLINDER.h,
+      y: 0,
+      frontU: -stove.frontU,
+      frontV: -stove.frontV,
+      room: stove.room,
+      floor: stove.floor,
+      outdoor: !!spot.outdoor,
+      slot: "cylinder",
+      on: null,
+      mode: null,
+      clearance: 0,
+      flat: false,
+      low: false,
+      aabb: spot.rect,
+      link: stove.id,
+      placement: PLACEMENT[spot.mode],
+      hose: [[round22(spot.x), round22(spot.z), 0.3], [stove.x, stove.z, 0.5]],
+      capacityKg: CYLINDER_KG
+    };
+    if (spot.cabinet) {
+      item.on = spot.cabinet;
+      item.hidden = true;
+    }
+    if (spot.outdoor) item.floor = -1;
+    item.color = stove.color;
+    return item;
+  }
+  function planGas(context) {
+    const { plan, items, stateItems, rng } = context;
+    const stoves = items.filter((m) => m.category === "stove" && !m.outdoor);
+    if (!stoves.length) return null;
+    const high = plan.style === "high";
+    const piped = plan.style !== "commercial" && (high ? rng() < 0.8 : plan.style === "mid" ? rng() < 0.1 : false);
+    const out = { type: piped ? "piped" : "cylinder", meter: null };
+    const ensureMeter = () => {
+      if (!out.meter) out.meter = placeMeter(plan);
+    };
+    for (const stove of stoves) {
+      const room = plan.rooms.find((c) => c.id === stove.room && c.floor === stove.floor);
+      if (!room) continue;
+      stove.gas = piped ? "piped" : "cylinder";
+      if (piped) {
+        ensureMeter();
+        stove.gasMeter = "gas.meter";
+        continue;
+      }
+      const solids = items.filter((m) => m.floor === stove.floor && m.room === stove.room && isSolid(m) && m.id !== stove.id).map((m) => m.aabb).concat(stateItems.filter((m) => m.aabb && m.room === stove.room && m.floor === stove.floor && !m.flat && !m.on && m.mount !== "window" && m.mount !== "ground").map((m) => m.aabb));
+      const doorZones = plan.doors.filter((p) => p.floor === stove.floor).flatMap((p) => p.zones);
+      const order = rng() < 0.7 ? ["beside", "niche", "under"] : ["niche", "beside", "under"];
+      let spot;
+      for (const mode of order) {
+        if (spot) break;
+        spot = mode === "beside" ? besideStove(context, stove, room, solids, doorZones) : mode === "niche" ? inNiche(context, stove, room, doorZones) : underCounter(context, stove);
+      }
+      if (!spot) {
+        stove.gas = "piped";
+        out.type = "piped";
+        ensureMeter();
+        stove.gasMeter = "gas.meter";
+        continue;
+      }
+      const cylinder = cylinderItem(stove, spot);
+      items.push(cylinder);
+      stove.cylinder = cylinder.id;
+    }
+    return out;
+  }
+
+  // src/utilities/plumbing.ts
+  var FIXTURES = { kitchen_cabinet: "tap", washbasin: "tap", shower: "shower", toilet: "flush", laundry_tub: "tub", washing_machine: "machine" };
+  var FLOW_LPM = { tap: 6, shower: 9, flush: 6, tub: 8, machine: 12 };
+  var POINT_HEIGHT = { shower: 2.1, flush: 0.9, machine: 0.8 };
+  var DEFAULT_CAPACITY = { budget: 500, mid: 1e3 };
+  var absolute2 = (plan, floor, y) => (plan.floors[floor] ? plan.floors[floor].y0 : 0) + y;
+  function planPlumbing(context) {
+    const { plan, items, tank } = context;
+    const fixtures = items.filter((m) => FIXTURES[m.category] && !m.decor);
+    const points = [];
+    const runs = [];
+    const capacity = tank?.capacity ?? (plan.style === "budget" ? DEFAULT_CAPACITY.budget : plan.style === "mid" ? DEFAULT_CAPACITY.mid : plan.tpl?.id === "mansion" ? 3e3 : 2e3);
+    const plumbing = { tank: tank ? "water_tank" : null, capacityL: tank || !plan.tpl.noWalls ? capacity : 0, points, visibleRuns: runs };
+    const top = plan.floors.length - 1;
+    fixtures.forEach((item, index) => {
+      const kind = FIXTURES[item.category];
+      points.push({ id: `pt${index + 1}`, kind, item: item.id, room: item.room, floor: item.outdoor ? -1 : item.floor, u: item.x, v: item.z, y: POINT_HEIGHT[kind] ?? 0.9, flowLpm: FLOW_LPM[kind], run: null });
+    });
+    if (!tank) return plumbing;
+    const slabY = absolute2(plan, top, plan.floors[top].ceiling);
+    const tankY = tank.place === "raised_slab" ? tank.platform.topY : tank.place === "attic" ? slabY + 0.5 : tank.y;
+    runs.push({ id: "run_outlet", from: "water_tank", to: "ceiling", points: [[tank.u, tank.v, round22(tankY + 0.15)], [tank.u, tank.v, round22(slabY - 0.15)]], diameter: 0.032, exposed: "tank_outlet" });
+    for (const point of points) {
+      const item = fixtures.find((x) => x.id === point.item);
+      if (point.kind !== "tap" || item.outdoor) continue;
+      const front = [item.frontU || 0, item.frontV || 1];
+      const behind = [item.x - front[0] * (item.d / 2 + 0.02), item.z - front[1] * (item.d / 2 + 0.02)];
+      runs.push({ id: `run_under_${point.id}`, from: "valve", to: point.id, points: [[round22(behind[0]), round22(behind[1]), absolute2(plan, item.floor, 0.5)], [item.x, item.z, absolute2(plan, item.floor, 0.5)], [item.x, item.z, absolute2(plan, item.floor, 0.75)]], diameter: 0.025, exposed: "under_sink" });
+    }
+    const wet = [];
+    for (const point of points) {
+      if (!wet.some((c) => c.room === point.room && c.floor === point.floor)) wet.push({ room: point.room, floor: point.floor, points: points.filter((q) => q.room === point.room && q.floor === point.floor) });
+    }
+    for (const room of wet) {
+      const found = plan.rooms.find((c) => c.id === room.room && c.floor === room.floor);
+      const zone = plan.zones.find((z) => z.id === room.room);
+      const parts = (found || zone || { parts: [[tank.u, tank.v, tank.u, tank.v]] }).parts;
+      const centreU = (parts[0][0] + parts[0][2]) / 2;
+      const centreV = (parts[0][1] + parts[0][3]) / 2;
+      const ceiling = found ? found.ceiling || plan.floors[found.floor].ceiling : 2.8;
+      const y0 = found ? absolute2(plan, found.floor, 0) : 0;
+      const id = `run_wall_${room.room}${room.floor === -1 ? "_outside" : `_${room.floor}`}`;
+      runs.push({ id, from: "water_tank", to: room.room, points: [[tank.u, tank.v, round22(slabY - 0.15)], [round22(centreU), round22(centreV), round22(slabY - 0.15)], [round22(centreU), round22(centreV), round22(y0 + ceiling - 0.15)], [round22(centreU), round22(centreV), round22(y0 + 0.6)]], diameter: 0.025, exposed: "wall" });
+      for (const point of room.points) point.run = id;
+    }
+    return plumbing;
+  }
+
+  // src/utilities/solar.ts
+  var PANEL_WIDTH = 1;
+  var PANEL_LENGTH = 1.65;
+  var NO_PANELS_UNDER = ["void", "elevator", "stairs", "balcony", "terrace", "porch"];
+  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 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" };
+  }
+  function planSolar(context) {
+    const { plan, rng, energy } = context;
+    if (!plan.lot || plan.style === "commercial" || !plan.facade) return null;
+    const chance = plan.style === "budget" ? 0.06 : plan.style === "mid" ? 0.25 : 0.5;
+    const forced = energy ? energy.solar ? 1 : 0 : null;
+    const draw = rng();
+    if (forced !== null ? !forced : draw >= chance) return null;
+    const floor = plan.floors.length - 1;
+    const level = plan.floors[floor];
+    const flat = plan.facade.roof === "slab";
+    const tops = plan.rooms.filter((c) => c.floor === floor && !NO_PANELS_UNDER.includes(c.type));
+    if (!tops.length) return null;
+    const parts = tops.flatMap((c) => c.parts);
+    const box = [Math.min(...parts.map((q) => q[0])), Math.min(...parts.map((q) => q[1])), Math.max(...parts.map((q) => q[2])), Math.max(...parts.map((q) => q[3]))];
+    const north = rng() < 0.5 ? "front" : "back";
+    const angle = flat ? 15 : 25;
+    const projection = round22(PANEL_LENGTH * Math.cos(angle * Math.PI / 180));
+    const margin = 0.6;
+    const uStart = box[0] + margin;
+    const uEnd = box[2] - margin;
+    const columns = Math.max(1, Math.floor((uEnd - uStart) / (PANEL_WIDTH + 0.05)));
+    const vMiddle = (box[1] + box[3]) / 2;
+    const vArea = flat ? [box[1] + margin, box[3] - margin] : north === "front" ? [box[1] + 0.4, vMiddle - 0.2] : [vMiddle + 0.2, box[3] - 0.4];
+    const step = flat ? projection + 0.5 : projection + 0.05;
+    const rowsMax = Math.max(1, Math.floor((vArea[1] - vArea[0]) / step));
+    const wanted = forced !== null ? 1 + Math.floor(rng() * 2) : 3 + Math.floor(rng() * (plan.style === "high" ? 12 : 8));
+    const rows = Math.max(1, Math.min(rowsMax, Math.ceil(wanted / columns)));
+    const count = Math.min(wanted, rows * columns);
+    const u0 = uStart + (uEnd - uStart - columns * (PANEL_WIDTH + 0.05)) / 2;
+    const vStart = north === "front" ? vArea[0] : vArea[1] - rows * step;
+    const panels = [];
+    for (let k = 0; k < count; k++) {
+      const row = Math.floor(k / columns);
+      const column = k % columns;
+      panels.push({ id: `pv${k + 1}`, u: round22(u0 + column * (PANEL_WIDTH + 0.05) + PANEL_WIDTH / 2), v: round22(vStart + row * step + (flat ? 0.25 : 0) + projection / 2), w: PANEL_WIDTH, d: projection, length: PANEL_LENGTH });
+    }
+    const area = [round22(u0), round22(vStart), round22(u0 + columns * (PANEL_WIDTH + 0.05)), round22(vStart + rows * step)];
+    return { type: flat ? "slab_rack" : "roof", orientation: "north", north, slopeSide: flat ? null : north, tilt: angle, area, areaM2: round22(count * PANEL_WIDTH * PANEL_LENGTH), count, floor, y: round22(level.y0 + level.ceiling), panels, inverter: placeInverter(plan) };
+  }
+
+  // src/utilities/index.ts
+  function planUtilities(context) {
+    const { plan, items, stateItems, tank, energy, rngFor } = context;
+    const gas = planGas({ plan, items, stateItems, rng: rngFor("gas") });
+    const electrical = planElectrical({ plan, items, rng: rngFor("eletrica"), ...energy ? { energy } : {} });
+    const solar = planSolar({ plan, rng: rngFor("solar"), ...energy ? { energy } : {} });
+    const plumbing = planPlumbing({ plan, items, tank });
+    return { gas, electrical, solar, plumbing };
+  }
+  var OVERHEAD = "overhead_cabinet";
+  var ALWAYS_HOLD = ["trash_bin", "outdoor_bin", "mailbox"];
+  function planContents(context) {
+    const out = {};
+    const ask = (item, container, key) => context.findsFor({ place: context.place, container, state: context.state, rng: context.rngFor(key), footprint: item.w * item.d, key: item.id, ...context.day === void 0 ? {} : { day: context.day }, ...context.region === void 0 ? {} : { region: context.region } });
+    for (const item of context.items) {
+      if (item.decor && item.mount !== "wall_top") continue;
+      const container = hasContent(item.type) ? item.type : item.category;
+      if (!hasContent(container)) continue;
+      if (!ALWAYS_HOLD.includes(container) && item.decor) continue;
+      out[item.id] = ask(item, container, `content:${item.id}`);
+      if (container === "kitchen_cabinet" && item.overhead !== false) out[`${item.id}#overhead`] = ask(item, OVERHEAD, `content:${item.id}:overhead`);
+    }
+    return out;
+  }
+
+  // src/utilities/outbuildings.ts
+  var WALL = 0.15;
+  var DOOR_WIDTH = 0.85;
+  var DOOR_HEIGHT2 = 2.1;
+  var USES = { guest_room: ["single_bed", "nightstand"], office: ["desk", "shelf_unit_small"], storage: ["tool_shelf", "crate"], gourmet: ["dining_table_small", "workbench"] };
+  var USE_WEIGHTS = { guest_room: 3, office: 2, storage: 2, gourmet: 2 };
+  var PATH_WIDTH = 1;
+  var LEGACY_ROOMS = { backyard: "quintal" };
+  var LEGACY_SLOTS = { outbuilding: "edicula" };
+  var streamOf = (itemId) => {
+    const [room = "", ...slot] = itemId.split(".");
+    return `edif:${LEGACY_ROOMS[room] ?? room}.${slot.map((part) => LEGACY_SLOTS[part] ?? part).join(".")}`;
+  };
+  function pickWeighted(rng, weights) {
+    const keys = Object.keys(weights);
+    let x = rng() * keys.reduce((sum, key) => sum + weights[key], 0);
+    for (const key of keys) {
+      x -= weights[key];
+      if (x < 0) return key;
+    }
+    return keys[keys.length - 1];
+  }
+  var sideOf = (x, z) => Math.abs(x) > Math.abs(z) ? x > 0 ? "right" : "left" : z > 0 ? "back" : "front";
+  var at = (frame, a, b) => [frame.cx + frame.n[0] * a + frame.t[0] * b, frame.cz + frame.n[1] * a + frame.t[1] * b];
+  function opening(frame, id, a, b, vector, width, extra) {
+    const [u, v] = at(frame, a, b);
+    const alongU = Math.abs(vector[0]) !== 1;
+    return { id, axis: alongU ? "u" : "v", pos: round22(alongU ? v : u), at: round22(alongU ? u : v), u: round22(u), v: round22(v), width: round22(width), side: sideOf(vector[0], vector[1]), ...extra };
+  }
+  function wallsOf(box, door, height) {
+    const walls = [];
+    const sides = [
+      { axis: "u", pos: box[1], i0: box[0], i1: box[2], side: "front" },
+      { axis: "u", pos: box[3], i0: box[0], i1: box[2], side: "back" },
+      { axis: "v", pos: box[0], i0: box[1], i1: box[3], side: "left" },
+      { axis: "v", pos: box[2], i0: box[1], i1: box[3], side: "right" }
+    ];
+    for (const w of sides) {
+      const cut = w.axis === door.axis && Math.abs(w.pos - door.pos) < 0.02 ? [door.at - door.width / 2, door.at + door.width / 2] : null;
+      const segments = cut ? [[w.i0, cut[0]], [cut[1], w.i1]] : [[w.i0, w.i1]];
+      for (const [x0, x1] of segments) {
+        if (x1 - x0 <= 1e-3) continue;
+        walls.push(w.axis === "u" ? { axis: "u", u0: round22(x0), v0: round22(w.pos), u1: round22(x1), v1: round22(w.pos), thickness: WALL, h: height, side: w.side } : { axis: "v", u0: round22(w.pos), v0: round22(x0), u1: round22(w.pos), v1: round22(x1), thickness: WALL, h: height, side: w.side });
+      }
+    }
+    return walls;
+  }
+  function furnish(context, frame, use, interior, insideDoor) {
+    const placed = [];
+    USES[use].forEach((type, k) => {
+      const def = context.catalog[type];
+      const facing = k === 0 ? frame.n : [frame.t[0] * frame.sideToMiddle, frame.t[1] * frame.sideToMiddle];
+      const [a, b] = k === 0 ? [-frame.depth / 2 + WALL + def.d / 2, frame.sideToMiddle * -0.4] : [-0.1, -frame.sideToMiddle * (frame.width / 2 - WALL - def.d / 2)];
+      const [u, v] = at(frame, a, b);
+      const eu = Math.abs(facing[0]) === 1 ? def.d : def.w;
+      const ev = Math.abs(facing[0]) === 1 ? def.w : def.d;
+      const box = [u - eu / 2, v - ev / 2, u + eu / 2, v + ev / 2].map(round22);
+      if (box[0] < interior[0] - 0.011 || box[2] > interior[2] + 0.011 || box[1] < interior[1] - 0.011 || box[3] > interior[3] + 0.011 || overlaps(box, insideDoor) || placed.some((o) => overlaps(box, o.aabb))) return;
+      placed.push({ type, category: def.category, u: round22(u), v: round22(v), w: def.w, d: def.d, h: def.h, ry: Math.atan2(facing[0], facing[1]), frontU: facing[0], frontV: facing[1], aabb: box });
+    });
+    return placed;
+  }
+  function planOutbuildings(context) {
+    const { plan, items } = context;
+    const lot = plan.lot;
+    if (!lot) return [];
+    const out = [];
+    for (const item of items.filter((m) => m.category === "outbuilding")) {
+      const rng = context.rngFor(streamOf(item.id));
+      const [a0, a1, a2, a3] = item.aabb;
+      const n = [item.frontU, item.frontV];
+      const t = [-item.frontV, item.frontU];
+      const horizontal = Math.abs(item.frontU) === 1;
+      const cx = (a0 + a2) / 2;
+      const cz = (a1 + a3) / 2;
+      const depth = horizontal ? a2 - a0 : a3 - a1;
+      const width = horizontal ? a3 - a1 : a2 - a0;
+      const sideToMiddle = ((lot.rect[0] + lot.rect[2]) / 2 - cx) * t[0] + ((lot.rect[1] + lot.rect[3]) / 2 - cz) * t[1] >= 0 ? 1 : -1;
+      const frame = { n, t, cx, cz, depth, width, horizontal, sideToMiddle };
+      const doorOffset = sideToMiddle * (width / 2 - 0.95);
+      const door = opening(frame, `${item.id}.d0`, depth / 2, doorOffset, n, DOOR_WIDTH, { height: DOOR_HEIGHT2, exterior: true });
+      const windowFront = opening(frame, `${item.id}.w0`, depth / 2, -sideToMiddle * (width / 2 - 0.9), n, Math.min(1, width / 2 - 0.6), { y0: 1, y1: 2 });
+      const windowSide = opening(frame, `${item.id}.w1`, 0, sideToMiddle * width / 2, [t[0] * sideToMiddle, t[1] * sideToMiddle], Math.min(1, depth - 0.8), { y0: 1, y1: 2 });
+      const [p, q] = [at(frame, depth / 2, doorOffset), at(frame, depth / 2 - 0.9, doorOffset)];
+      door.zone = (horizontal ? [Math.min(p[0], q[0]), p[1] - door.width / 2, Math.max(p[0], q[0]), p[1] + door.width / 2] : [p[0] - door.width / 2, Math.min(p[1], q[1]), p[0] + door.width / 2, Math.max(p[1], q[1])]).map(round22);
+      const interior = [a0 + WALL, a1 + WALL, a2 - WALL, a3 - WALL];
+      const use = pickWeighted(rng, USE_WEIGHTS);
+      out.push({ id: item.id, type: "outbuilding", use, floor: 0, aabb: item.aabb.slice(), interior: [interior.map(round22)], ceiling: item.h, thickness: WALL, front: n, walls: wallsOf(item.aabb, door, item.h), doors: [door], windows: [windowFront, windowSide], items: furnish(context, frame, use, interior, door.zone) });
+    }
+    return out;
+  }
+  function addOutbuildingPaths(lot, outbuildings, items) {
+    const half = PATH_WIDTH / 2;
+    const rect = lot.rect;
+    const solids = items.filter((m) => m.outdoor && m.aabb && isSolid(m)).map((m) => m.aabb);
+    const fence = lot.perimeter.map((q) => [Math.min(q.u0, q.u1) - 0.075, Math.min(q.v0, q.v1) - 0.075, Math.max(q.u0, q.u1) + 0.075, Math.max(q.v0, q.v1) + 0.075]);
+    const strip = (p, q) => [Math.min(p[0], q[0]) - half, Math.min(p[1], q[1]) - half, Math.max(p[0], q[0]) + half, Math.max(p[1], q[1]) + half];
+    for (const building of outbuildings) {
+      for (const door of building.doors) {
+        if (lot.paths.some((c) => c.to === door.id)) continue;
+        const z = door.zone;
+        const zc = door.axis === "v" ? (z[0] + z[2]) / 2 : (z[1] + z[3]) / 2;
+        const outside = zc > door.pos ? -1 : 1;
+        const A = door.axis === "v" ? [door.pos, door.at] : [door.at, door.pos];
+        const S = door.axis === "v" ? [door.pos + outside * PATH_WIDTH, door.at] : [door.at, door.pos + outside * PATH_WIDTH];
+        const stub = door.axis === "v" ? [Math.min(A[0], S[0]), A[1] - half, Math.max(A[0], S[0]), A[1] + half] : [A[0] - half, Math.min(A[1], S[1]), A[0] + half, Math.max(A[1], S[1])];
+        const cost = (rs) => {
+          let n = 0;
+          for (const r of rs) {
+            const c = [r[0] + 0.02, r[1] + 0.02, r[2] - 0.02, r[3] - 0.02];
+            for (const q of solids) if (overlaps(c, q, 0.011)) n += 2;
+            if (overlaps(c, building.aabb, 0.011)) n += 3;
+            for (const q of fence) if (overlaps(c, q, 0.011)) n += 3;
+            if (r[0] < rect[0] || r[1] < rect[1] || r[2] > rect[2] || r[3] > rect[3]) n += 3;
+          }
+          return n;
+        };
+        let best = null;
+        for (const c of lot.paths.filter((p) => p.type === "pedestrian" || p.id === "cargo_path")) {
+          for (const r of c.rects) {
+            const T = [Math.min(Math.max(S[0], r[0] + half), r[2] - half), Math.min(Math.max(S[1], r[1] + half), r[3] - half)];
+            const candidates = [];
+            if (Math.abs(T[0] - S[0]) < 1e-6 && Math.abs(T[1] - S[1]) < 1e-6) candidates.push({ rects: [stub], points: [A, S] });
+            else for (const via of [[T[0], S[1]], [S[0], T[1]]]) candidates.push({ rects: [stub, strip(S, via), strip(via, T)].filter((q) => q[2] - q[0] > 1e-6), points: [A, S, via, T] });
+            for (const k of candidates) {
+              const distance = k.points.slice(1).reduce((sum, q, i) => sum + Math.abs(q[0] - k.points[i][0]) + Math.abs(q[1] - k.points[i][1]), 0);
+              const value = cost(k.rects.slice(1)) * 100 + distance;
+              if (!best || value < best.v) best = { v: value, k, from: c.from };
+            }
+          }
+        }
+        const chosen = best ? best.k : { rects: [stub], points: [A, S] };
+        lot.paths.push({ id: `path_${door.id}`, type: "pedestrian", from: best ? best.from : null, to: door.id, width: PATH_WIDTH, rects: chosen.rects.map((q) => q.map(round22)), points: chosen.points.map((q) => q.map(round22)) });
+      }
+    }
+  }
+
+  // src/water-tank.ts
+  var TANK_SIDE = 1.1;
+  var NOT_UNDER_TANK = ["void", "elevator", "stairs", "balcony", "porch"];
+  var WET_ROOMS = ["bathroom", "kitchen", "laundry"];
+  var ATTIC_CHANCE = 0.12;
+  var clamp2 = (value, low, high) => Math.max(low, Math.min(high, value));
+  var DEFAULT_CAPACITIES = { budget: 500, mid: 1e3, mansion: 3e3 };
+  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];
+    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]);
+        if (!best || weight < best.weight) best = { roomType: room.type, roomId: room.id, rect, weight };
+      }
+    }
+    return best;
+  }
+  function raisedPlatform(source, u, v, baseY) {
+    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 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 };
+  }
+  function planWaterTank(source, rng, options = {}) {
+    if (!source.lot || source.style === "commercial") return null;
+    if (options.custom) return options.custom(source, rng);
+    const floor = source.floors.length - 1;
+    const level = source.floors[floor];
+    const capacity = capacityOf(source, { ...DEFAULT_CAPACITIES, ...options.capacities });
+    const height = capacity >= 2e3 ? 1.4 : capacity === 1e3 ? 1 : 0.85;
+    const place = options.location ? options.location(source, rng) : source.facade.roof === "slab" ? "slab" : rng() < ATTIC_CHANCE ? "attic" : "raised_slab";
+    const reference = source.facade.slab?.waterTank;
+    const spot = bestSpot(source, floor, reference);
+    if (!spot) return null;
+    const target = reference ? [reference.u, reference.v] : [(spot.rect[0] + spot.rect[2]) / 2, (spot.rect[1] + spot.rect[3]) / 2];
+    const u = clamp2(target[0], spot.rect[0] + TANK_SIDE / 2, spot.rect[2] - TANK_SIDE / 2);
+    const v = clamp2(target[1], spot.rect[1] + TANK_SIDE / 2, spot.rect[3] - TANK_SIDE / 2);
+    const where = spot.roomType === "terrace" ? "slab" : place;
+    const slabY = round2(spot.roomType === "terrace" ? level.y0 : level.y0 + level.ceiling);
+    const tank = {
+      id: "water_tank",
+      kind: "water_tank",
+      itemType: "water_tank",
+      place: where,
+      floor,
+      room: spot.roomId,
+      u: round2(u),
+      v: round2(v),
+      y: slabY,
+      w: TANK_SIDE,
+      d: TANK_SIDE,
+      h: height,
+      capacity,
+      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.y = tank.platform.topY;
+    }
+    return tank;
+  }
+
+  // src/viewer-layer.ts
+  var COLORS = { concrete: "#7d8590", steel: "#3d6fb0", masonry: "#b5654b", wood: "#a0693a" };
+  var BEAM_IDS = ["plate_", "porch_beam", "base_beam", "trestle_beam"];
+  var LAYER_ID = "structure";
+  function groupOf(material) {
+    if (material === "concrete") return "concrete";
+    if (material === "steel" || material === "aluminium" || material === "cast_iron") return "steel";
+    if (material === "brick" || material === "stone" || material === "ceramic") return "masonry";
+    return "wood";
+  }
+  var isRoofFrame = (part) => ["truss", "rafter", "ridge"].some((prefix) => part.id.startsWith(prefix));
+  var isDrawnBeam = (part) => part.role === "beam" && BEAM_IDS.some((prefix) => part.id.startsWith(prefix));
+  function drawColumns(context, parts) {
+    for (const part of parts.filter((p) => p.role === "column")) {
+      const color = COLORS[groupOf(part.material)];
+      if (groupOf(part.material) === "wood") context.rect(part.aabb, null, color, 2);
+      else context.rect(part.aabb, color, null);
+      context.hit(part.aabb, `${part.id} \xB7 column \xB7 ${part.material} \xB7 ${part.mass} kg`);
+    }
+  }
+  function drawBeams(context, parts) {
+    context.g.save();
+    context.g.setLineDash([6, 4]);
+    for (const part of parts.filter(isDrawnBeam)) {
+      context.rect(part.aabb, null, COLORS[groupOf(part.material)], 1.5);
+      context.hit(part.aabb, `${part.id} \xB7 beam \xB7 ${part.material} \xB7 ${part.mass} kg`);
+    }
+    context.g.restore();
+  }
+  function drawRoofFrames(context, parts) {
+    context.g.save();
+    context.g.strokeStyle = COLORS.wood;
+    context.g.lineWidth = 1;
+    for (const part of parts.filter(isRoofFrame)) {
+      const [u0, v0, u1, v1] = part.aabb;
+      const alongV = v1 - v0 > u1 - u0;
+      context.g.beginPath();
+      if (alongV) {
+        context.g.moveTo(context.X((u0 + u1) / 2), context.Z(v0));
+        context.g.lineTo(context.X((u0 + u1) / 2), context.Z(v1));
+      } else {
+        context.g.moveTo(context.X(u0), context.Z((v0 + v1) / 2));
+        context.g.lineTo(context.X(u1), context.Z((v0 + v1) / 2));
+      }
+      context.g.stroke();
+    }
+    context.g.restore();
+  }
+  function drawPorchRoofs(context, parts) {
+    context.g.save();
+    context.g.setLineDash([2, 4]);
+    for (const part of parts.filter((p) => p.id.startsWith("porch_roof"))) context.rect(part.aabb, null, COLORS.wood, 1);
+    context.g.restore();
+  }
+  function drawStructure(context) {
+    const structure = context.plan.structure;
+    if (!structure) return;
+    const floor = context.all ? 0 : context.floor;
+    const here = structure.parts.filter((part) => part.floor === floor);
+    drawPorchRoofs(context, here);
+    if (floor === (context.plan.roof?.bearingFloor ?? 0)) drawRoofFrames(context, structure.parts);
+    drawBeams(context, here);
+    drawColumns(context, here);
+  }
+  function structureLegend(plan) {
+    const parts = plan.structure?.parts ?? [];
+    const entries = [];
+    for (const group of ["concrete", "steel", "masonry", "wood"]) {
+      const columns = parts.some((p) => p.role === "column" && groupOf(p.material) === group);
+      if (columns) entries.push({ label: `structure_column_${group}`, color: COLORS[group], shape: group === "wood" ? "hollow" : "filled" });
+    }
+    for (const group of ["concrete", "wood"]) {
+      if (parts.some((p) => isDrawnBeam(p) && groupOf(p.material) === group)) entries.push({ label: `structure_beam_${group}`, color: COLORS[group], shape: "dashed" });
+    }
+    if (parts.some(isRoofFrame)) entries.push({ label: "structure_roof_frame", color: COLORS.wood, shape: "line" });
+    return entries;
+  }
+  var structureLayer = {
+    id: LAYER_ID,
+    label: "structure_layer",
+    defaultOn: false,
+    draw: drawStructure,
+    legend: structureLegend
+  };
+
+  // src/register.ts
+  var CACHE = /* @__PURE__ */ new WeakMap();
+  var cacheOf = (result) => {
+    const cache = CACHE.get(result);
+    if (!cache) throw new Error("The construction extension did not run for this plan");
+    return cache;
+  };
+  function constructionExtension(context) {
+    const build = constructionFor({ result: context.result, seed: context.seed, template: context.plan.tpl, options: context.options });
+    CACHE.set(context.result, { build });
+    return build.construction;
+  }
+  function structureExtension(context) {
+    const cache = cacheOf(context.result);
+    const options = { construction: cache.build.construction, extras: cache.build.extras ?? {}, tank: context.result.waterTank ?? null, wallDetail: context.options.wallDetail ?? "panels" };
+    const { roof, ...structure } = buildStructure(context.result, options);
+    cache.roof = roof;
+    for (const part of structure.parts) {
+      if (part.door === void 0 || part.steps === void 0) continue;
+      const door = context.result.doors.find((d) => d.id === part.door);
+      if (door) door.steps = part.steps;
+    }
+    return structure;
+  }
+  var COOKING_CYLINDER = { type: "cooking_gas_cylinder", category: "cooking_gas_cylinder", w: 0.36, d: 0.36, h: 0.48 };
+  function energyOf(context) {
+    const energy = context.plan.tpl.energy;
+    return typeof energy === "function" ? energy(context.options, context.plan.w, context.plan.d) : void 0;
+  }
+  function register(engine, options = {}) {
+    engine.registerLocale("en", en_default);
+    engine.registerLocale("pt-BR", pt_BR_default);
+    engine.registerResultExtension("construction", constructionExtension);
+    engine.registerResultExtension("structureExtras", (context) => cacheOf(context.result).build.extras ?? {}, { after: ["construction"] });
+    engine.registerResultExtension(
+      "waterTank",
+      (context) => {
+        const tank = { capacities: options.tankCapacities, custom: context.plan.tpl.tank, location: context.plan.tpl.tankLocation };
+        return planWaterTank(context.result, context.rng, tank);
+      },
+      { after: ["construction"], seedKey: "caixa" }
+    );
+    engine.registerResultExtension("structure", structureExtension, { after: ["construction", "structureExtras", "waterTank"] });
+    engine.registerResultExtension("roof", (context) => cacheOf(context.result).roof ?? null, { after: ["structure"] });
+    engine.registerViewerLayer(structureLayer);
+    engine.registerItem(COOKING_CYLINDER);
+    engine.registerResultExtension("contents", (context) => planContents({ items: context.result.items, state: context.result.state, place: context.plan.tpl.place ?? "house", ...typeof context.options.day === "number" ? { day: context.options.day } : {}, ...typeof context.options.region === "string" ? { region: context.options.region } : {}, rngFor: (key) => engine.createRng(context.seed, key), findsFor: (query) => {
+      const answered = engine.findsAnswer(query);
+      return answered ?? contentOf({ container: query.container, state: query.state, rng: query.rng, footprint: query.footprint ?? 0.5 });
+    } }));
+    engine.registerResultExtension("outbuildings", (context) => {
+      const outbuildings = planOutbuildings({ plan: context.plan, items: context.result.items, catalog: engine.catalog, rngFor: (key) => engine.createRng(context.seed, key) });
+      if (context.result.lot) addOutbuildingPaths(context.result.lot, outbuildings, context.result.items);
+      return outbuildings;
+    }, { after: ["contents"] });
+    engine.registerResultExtension("utilities", (context) => planUtilities({ plan: context.plan, items: context.result.items, stateItems: context.result.stateItems, tank: context.result.waterTank ?? null, ...energyOf(context) ? { energy: energyOf(context) } : {}, rngFor: (key) => engine.createRng(context.seed, key) }), { after: ["outbuildings", "waterTank"] });
+  }
+
+  // ../game-destruction/dist/index.js
+  var materials_default = [
+    {
+      id: "steel",
+      density: 7850,
+      hpPerKg: 400,
+      penetration: 110,
+      ductility: 0.9,
+      fracture: "none",
+      damageScale: {
+        slash: 0.1,
+        blunt: 0.8
+      },
+      hitDebris: "sparks",
+      breakDebris: "sparks",
+      ricochetDeg: 20,
+      thermal: {
+        meltC: 1450,
+        meltRate: 0.05,
+        conductivity: 0.5,
+        heatCapacity: 3
+      },
+      visual: {
+        glows: true
+      },
+      tags: [
+        "metal",
+        "conductive"
+      ],
+      compressive: 2e6
+    },
+    {
+      id: "cast_iron",
+      density: 7200,
+      hpPerKg: 150,
+      penetration: 160,
+      ductility: 0.2,
+      fracture: "snap",
+      fragmentSize: [
+        0.08,
+        0.3
+      ],
+      damageScale: {
+        slash: 0.1,
+        blunt: 1.2
+      },
+      hitDebris: "sparks",
+      breakDebris: "chips",
+      ricochetDeg: 15,
+      thermal: {
+        meltC: 1200,
+        meltRate: 0.05,
+        conductivity: 0.45,
+        heatCapacity: 3
+      },
+      visual: {
+        glows: true
+      },
+      tags: [
+        "metal",
+        "conductive"
+      ],
+      compressive: 15e5
+    },
+    {
+      id: "aluminium",
+      density: 2700,
+      hpPerKg: 250,
+      penetration: 60,
+      ductility: 0.85,
+      fracture: "none",
+      damageScale: {
+        slash: 0.2
+      },
+      hitDebris: "sparks",
+      breakDebris: "sparks",
+      ricochetDeg: 15,
+      thermal: {
+        meltC: 660,
+        meltRate: 0.06,
+        conductivity: 0.8,
+        heatCapacity: 1.5
+      },
+      visual: {
+        glows: true
+      },
+      tags: [
+        "metal",
+        "conductive"
+      ],
+      compressive: 8e5
+    },
+    {
+      id: "copper",
+      density: 8960,
+      hpPerKg: 300,
+      penetration: 70,
+      ductility: 0.95,
+      fracture: "none",
+      damageScale: {
+        slash: 0.2
+      },
+      hitDebris: "sparks",
+      breakDebris: "sparks",
+      ricochetDeg: 15,
+      thermal: {
+        meltC: 1085,
+        meltRate: 0.05,
+        conductivity: 1,
+        heatCapacity: 2.5
+      },
+      visual: {
+        glows: true
+      },
+      tags: [
+        "metal",
+        "conductive"
+      ],
+      compressive: 1e6
+    },
+    {
+      id: "wood_soft",
+      density: 500,
+      hpPerKg: 90,
+      penetration: 9,
+      ductility: 0.35,
+      fracture: "splinter",
+      fragmentSize: [
+        0.03,
+        0.15
+      ],
+      damageScale: {
+        blunt: 1.2,
+        slash: 1.5
+      },
+      hitDebris: "splinters",
+      breakDebris: "splinters",
+      thermal: {
+        ignitionC: 300,
+        flameC: 800,
+        fuelFraction: 0.9,
+        burnRate: 0.012,
+        conductivity: 0.05,
+        heatCapacity: 1.2,
+        smoke: "grey"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "wood",
+        "organic",
+        "flammable"
+      ],
+      compressive: 1e5
+    },
+    {
+      id: "wood_hard",
+      density: 750,
+      hpPerKg: 140,
+      penetration: 14,
+      ductility: 0.3,
+      fracture: "splinter",
+      fragmentSize: [
+        0.03,
+        0.2
+      ],
+      damageScale: {
+        slash: 1.2
+      },
+      hitDebris: "splinters",
+      breakDebris: "splinters",
+      thermal: {
+        ignitionC: 330,
+        flameC: 800,
+        fuelFraction: 0.9,
+        burnRate: 0.01,
+        conductivity: 0.06,
+        heatCapacity: 1.4,
+        smoke: "grey"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "wood",
+        "organic",
+        "flammable"
+      ],
+      compressive: 15e4
+    },
+    {
+      id: "plywood",
+      density: 600,
+      hpPerKg: 70,
+      penetration: 7,
+      ductility: 0.3,
+      fracture: "snap",
+      fragmentSize: [
+        0.1,
+        0.4
+      ],
+      damageScale: {
+        slash: 1.3
+      },
+      hitDebris: "splinters",
+      breakDebris: "splinters",
+      thermal: {
+        ignitionC: 300,
+        flameC: 800,
+        fuelFraction: 0.85,
+        burnRate: 0.013,
+        conductivity: 0.05,
+        heatCapacity: 1.2,
+        smoke: "grey"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "wood",
+        "organic",
+        "flammable"
+      ],
+      compressive: 6e4
+    },
+    {
+      id: "mdf",
+      density: 750,
+      hpPerKg: 45,
+      penetration: 6,
+      ductility: 0.15,
+      fracture: "snap",
+      fragmentSize: [
+        0.08,
+        0.35
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        ignitionC: 290,
+        flameC: 750,
+        fuelFraction: 0.85,
+        burnRate: 0.014,
+        conductivity: 0.05,
+        heatCapacity: 1.2,
+        smoke: "grey"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "wood",
+        "organic",
+        "flammable"
+      ],
+      compressive: 3e4
+    },
+    {
+      id: "glass",
+      density: 2500,
+      hpPerKg: 12,
+      penetration: 6,
+      ductility: 0.02,
+      fracture: "shatter",
+      fragmentSize: [
+        0.05,
+        0.25
+      ],
+      damageScale: {
+        blunt: 1.5
+      },
+      hitDebris: "shards",
+      breakDebris: "shards",
+      ricochetDeg: 8,
+      thermal: {
+        meltC: 1400,
+        meltRate: 0.03,
+        conductivity: 0.1,
+        heatCapacity: 1.5,
+        thermalShockC: 150
+      },
+      visual: {
+        glows: true,
+        transparent: true
+      },
+      tags: [
+        "glass",
+        "brittle"
+      ],
+      compressive: 1e5
+    },
+    {
+      id: "tempered_glass",
+      density: 2500,
+      hpPerKg: 30,
+      penetration: 9,
+      ductility: 0.02,
+      fracture: "crumble",
+      fragmentSize: [
+        6e-3,
+        0.02
+      ],
+      hitDebris: "shards",
+      breakDebris: "shards",
+      ricochetDeg: 8,
+      thermal: {
+        meltC: 1400,
+        meltRate: 0.03,
+        conductivity: 0.1,
+        heatCapacity: 1.5,
+        thermalShockC: 250
+      },
+      visual: {
+        glows: true,
+        transparent: true
+      },
+      tags: [
+        "glass",
+        "brittle"
+      ],
+      compressive: 2e5
+    },
+    {
+      id: "ceramic",
+      density: 2400,
+      hpPerKg: 25,
+      penetration: 12,
+      ductility: 0.02,
+      fracture: "shatter",
+      fragmentSize: [
+        0.03,
+        0.12
+      ],
+      damageScale: {
+        blunt: 1.3
+      },
+      hitDebris: "chips",
+      breakDebris: "shards",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 1.5,
+        thermalShockC: 200
+      },
+      tags: [
+        "ceramic",
+        "brittle"
+      ],
+      compressive: 15e4
+    },
+    {
+      id: "concrete",
+      density: 2300,
+      hpPerKg: 14,
+      penetration: 18,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.05,
+        0.25
+      ],
+      damageScale: {
+        explosive: 1.2
+      },
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 444e3
+    },
+    {
+      id: "brick",
+      density: 1900,
+      hpPerKg: 12,
+      penetration: 14,
+      ductility: 0.05,
+      fracture: "crumble",
+      fragmentSize: [
+        0.04,
+        0.12
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.15,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 4e4
+    },
+    {
+      id: "plaster",
+      density: 850,
+      hpPerKg: 18,
+      penetration: 3,
+      ductility: 0.05,
+      fracture: "crumble",
+      fragmentSize: [
+        0.05,
+        0.3
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 1.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 8e3
+    },
+    {
+      id: "stone",
+      density: 2700,
+      hpPerKg: 25,
+      penetration: 25,
+      ductility: 0.03,
+      fracture: "crumble",
+      fragmentSize: [
+        0.06,
+        0.3
+      ],
+      hitDebris: "chips",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.2,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "masonry",
+        "brittle"
+      ],
+      compressive: 3e5
+    },
+    {
+      id: "plastic",
+      density: 1100,
+      hpPerKg: 60,
+      penetration: 8,
+      ductility: 0.5,
+      fracture: "snap",
+      fragmentSize: [
+        0.05,
+        0.3
+      ],
+      hitDebris: "chips",
+      breakDebris: "chips",
+      thermal: {
+        ignitionC: 400,
+        flameC: 700,
+        fuelFraction: 0.8,
+        burnRate: 0.02,
+        meltC: 200,
+        meltRate: 0.06,
+        conductivity: 0.05,
+        heatCapacity: 1,
+        smoke: "black"
+      },
+      visual: {
+        charColor: 855309
+      },
+      tags: [
+        "plastic",
+        "flammable"
+      ],
+      compressive: 4e4
+    },
+    {
+      id: "rubber",
+      density: 1100,
+      hpPerKg: 80,
+      penetration: 12,
+      ductility: 0.9,
+      fracture: "tear",
+      fragmentSize: [
+        0.05,
+        0.2
+      ],
+      hitDebris: "chips",
+      breakDebris: "fibers",
+      thermal: {
+        ignitionC: 350,
+        flameC: 750,
+        fuelFraction: 0.6,
+        burnRate: 0.015,
+        conductivity: 0.05,
+        heatCapacity: 1.2,
+        smoke: "black"
+      },
+      visual: {
+        charColor: 855309
+      },
+      tags: [
+        "rubber",
+        "flammable"
+      ],
+      compressive: 2e4
+    },
+    {
+      id: "fabric",
+      density: 400,
+      hpPerKg: 20,
+      penetration: 0.8,
+      ductility: 0.8,
+      fracture: "tear",
+      fragmentSize: [
+        0.05,
+        0.25
+      ],
+      damageScale: {
+        slash: 4,
+        ballistic: 0.5
+      },
+      hitDebris: "fibers",
+      breakDebris: "fibers",
+      thermal: {
+        ignitionC: 230,
+        flameC: 600,
+        fuelFraction: 1,
+        burnRate: 0.05,
+        conductivity: 0.03,
+        heatCapacity: 0.6,
+        smoke: "grey"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "fabric",
+        "organic",
+        "flammable"
+      ],
+      compressive: 500
+    },
+    {
+      id: "foam",
+      density: 30,
+      hpPerKg: 15,
+      penetration: 0.5,
+      ductility: 0.7,
+      fracture: "tear",
+      fragmentSize: [
+        0.03,
+        0.15
+      ],
+      damageScale: {
+        slash: 2,
+        ballistic: 0.4
+      },
+      hitDebris: "fibers",
+      breakDebris: "fibers",
+      thermal: {
+        ignitionC: 250,
+        flameC: 900,
+        fuelFraction: 0.95,
+        burnRate: 0.09,
+        conductivity: 0.02,
+        heatCapacity: 0.5,
+        smoke: "black"
+      },
+      visual: {
+        charColor: 855309
+      },
+      tags: [
+        "fabric",
+        "flammable"
+      ],
+      compressive: 100
+    },
+    {
+      id: "leather",
+      density: 900,
+      hpPerKg: 50,
+      penetration: 4,
+      ductility: 0.8,
+      fracture: "tear",
+      fragmentSize: [
+        0.05,
+        0.25
+      ],
+      damageScale: {
+        slash: 2
+      },
+      hitDebris: "fibers",
+      breakDebris: "fibers",
+      thermal: {
+        ignitionC: 320,
+        flameC: 650,
+        fuelFraction: 0.7,
+        burnRate: 0.01,
+        conductivity: 0.05,
+        heatCapacity: 1,
+        smoke: "grey"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "fabric",
+        "organic",
+        "flammable"
+      ],
+      compressive: 2e3
+    },
+    {
+      id: "paper",
+      density: 700,
+      hpPerKg: 8,
+      penetration: 0.3,
+      ductility: 0.5,
+      fracture: "tear",
+      fragmentSize: [
+        0.03,
+        0.15
+      ],
+      damageScale: {
+        slash: 3
+      },
+      hitDebris: "fibers",
+      breakDebris: "fibers",
+      thermal: {
+        ignitionC: 230,
+        flameC: 600,
+        fuelFraction: 1,
+        burnRate: 0.06,
+        conductivity: 0.03,
+        heatCapacity: 0.5,
+        smoke: "grey"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "fabric",
+        "organic",
+        "flammable"
+      ],
+      compressive: 500
+    },
+    {
+      id: "foliage",
+      density: 150,
+      hpPerKg: 20,
+      penetration: 0.5,
+      ductility: 0.6,
+      fracture: "tear",
+      fragmentSize: [
+        0.03,
+        0.1
+      ],
+      damageScale: {
+        slash: 4
+      },
+      hitDebris: "leaves",
+      breakDebris: "leaves",
+      thermal: {
+        ignitionC: 300,
+        flameC: 700,
+        fuelFraction: 0.8,
+        burnRate: 0.08,
+        conductivity: 0.03,
+        heatCapacity: 0.8,
+        smoke: "white"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "plant",
+        "organic",
+        "flammable"
+      ],
+      compressive: 500
+    },
+    {
+      id: "green_wood",
+      density: 650,
+      hpPerKg: 5,
+      penetration: 10,
+      ductility: 0.5,
+      fracture: "splinter",
+      fragmentSize: [
+        0.03,
+        0.2
+      ],
+      damageScale: {
+        slash: 1.3,
+        ballistic: 0.1
+      },
+      hitDebris: "splinters",
+      breakDebris: "leaves",
+      thermal: {
+        ignitionC: 400,
+        flameC: 700,
+        fuelFraction: 0.8,
+        burnRate: 6e-3,
+        conductivity: 0.06,
+        heatCapacity: 2,
+        smoke: "white"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "plant",
+        "wood",
+        "organic",
+        "flammable"
+      ],
+      compressive: 6e4
+    },
+    {
+      id: "cactus",
+      density: 900,
+      hpPerKg: 30,
+      penetration: 2,
+      ductility: 0.6,
+      fracture: "tear",
+      fragmentSize: [
+        0.04,
+        0.15
+      ],
+      damageScale: {
+        slash: 3
+      },
+      hitDebris: "fibers",
+      breakDebris: "fibers",
+      thermal: {
+        ignitionC: 450,
+        flameC: 650,
+        fuelFraction: 0.3,
+        burnRate: 0.01,
+        conductivity: 0.05,
+        heatCapacity: 3,
+        smoke: "white"
+      },
+      visual: {
+        charColor: 1709072
+      },
+      tags: [
+        "plant",
+        "organic",
+        "flammable"
+      ],
+      compressive: 5e3
+    },
+    {
+      id: "flesh_fruit",
+      density: 950,
+      hpPerKg: 15,
+      penetration: 1.5,
+      ductility: 0.7,
+      fracture: "tear",
+      fragmentSize: [
+        0.02,
+        0.08
+      ],
+      damageScale: {
+        slash: 2
+      },
+      hitDebris: "drips",
+      breakDebris: "drips",
+      thermal: {
+        conductivity: 0.05,
+        heatCapacity: 3
+      },
+      tags: [
+        "plant",
+        "organic"
+      ],
+      compressive: 1e3
+    },
+    {
+      id: "wax",
+      density: 900,
+      hpPerKg: 30,
+      penetration: 3,
+      ductility: 0.5,
+      fracture: "snap",
+      fragmentSize: [
+        0.05,
+        0.2
+      ],
+      hitDebris: "chips",
+      breakDebris: "chips",
+      thermal: {
+        ignitionC: 230,
+        flameC: 700,
+        fuelFraction: 0.9,
+        burnRate: 0.02,
+        meltC: 60,
+        meltRate: 0.2,
+        conductivity: 0.05,
+        heatCapacity: 0.8,
+        smoke: "grey"
+      },
+      tags: [
+        "wax",
+        "flammable"
+      ],
+      compressive: 5e3
+    },
+    {
+      id: "soil",
+      density: 1300,
+      hpPerKg: 3,
+      penetration: 5,
+      ductility: 0.3,
+      fracture: "crumble",
+      fragmentSize: [
+        0.03,
+        0.12
+      ],
+      hitDebris: "dust",
+      breakDebris: "dust",
+      thermal: {
+        conductivity: 0.1,
+        heatCapacity: 2.5
+      },
+      tags: [
+        "soil",
+        "masonry"
+      ],
+      compressive: 2e4
+    }
+  ];
+  var material_hints_default = {
+    "cast iron": "cast_iron",
+    cast_iron: "cast_iron",
+    castiron: "cast_iron",
+    metal: "steel",
+    steel: "steel",
+    iron: "steel",
+    chrome: "steel",
+    alumin: "aluminium",
+    alu_: "aluminium",
+    "alu-": "aluminium",
+    "alu ": "aluminium",
+    copper: "copper",
+    brass: "copper",
+    bronze: "copper",
+    wood: "wood_soft",
+    timber: "wood_soft",
+    plank: "wood_soft",
+    lumber: "wood_soft",
+    pine: "wood_soft",
+    hardwood: "wood_hard",
+    oak: "wood_hard",
+    plywood: "plywood",
+    mdf: "mdf",
+    chipboard: "mdf",
+    glass: "glass",
+    window: "glass",
+    mirror: "glass",
+    tempered: "tempered_glass",
+    windshield: "tempered_glass",
+    fabric: "fabric",
+    cloth: "fabric",
+    cushion: "fabric",
+    sofa: "fabric",
+    curtain: "fabric",
+    carpet: "fabric",
+    textile: "fabric",
+    canvas: "fabric",
+    foam: "foam",
+    sponge: "foam",
+    mattress: "foam",
+    leather: "leather",
+    paper: "paper",
+    cardboard: "paper",
+    leaf: "foliage",
+    leaves: "foliage",
+    foliage: "foliage",
+    bush: "foliage",
+    grass: "foliage",
+    trunk: "green_wood",
+    branch: "green_wood",
+    twig: "green_wood",
+    cactus: "cactus",
+    fruit: "flesh_fruit",
+    apple: "flesh_fruit",
+    melon: "flesh_fruit",
+    wax: "wax",
+    candle: "wax",
+    concrete: "concrete",
+    cement: "concrete",
+    brick: "brick",
+    tile: "ceramic",
+    ceramic: "ceramic",
+    porcelain: "ceramic",
+    stone: "stone",
+    rock: "stone",
+    marble: "stone",
+    plaster: "plaster",
+    drywall: "plaster",
+    gypsum: "plaster",
+    plastic: "plastic",
+    pvc: "plastic",
+    acrylic: "plastic",
+    rubber: "rubber",
+    tire: "rubber",
+    tyre: "rubber",
+    soil: "soil",
+    dirt: "soil",
+    potting: "soil",
+    mud: "soil"
+  };
+  var MATERIALS = materials_default;
+  var MATERIAL_MAP = new Map(MATERIALS.map((m) => [m.id, m]));
+  var HINTS = Object.entries(material_hints_default).sort((x, y) => y[0].length - x[0].length);
+  var assemblies_default = [
+    {
+      id: "brick_wall_plastered",
+      name: "Plastered brick wall",
+      core: { material: "brick", thickness: 0.09 },
+      layers: [{ material: "plaster", thickness: 0.02, faces: "both" }],
+      units: { size: [0.23, 0.075, 0.11], bond: "running", mortar: "plaster" },
+      breach: { area: 0.25 }
+    },
+    {
+      id: "concrete_block_wall",
+      name: "Concrete block wall",
+      core: { material: "concrete", thickness: 0.14 },
+      fill: 0.55,
+      units: { size: [0.39, 0.19, 0.14], bond: "running", mortar: "plaster" },
+      breach: { area: 0.25 }
+    },
+    {
+      id: "reinforced_concrete",
+      name: "Reinforced concrete wall",
+      core: { material: "concrete", thickness: 0.2 },
+      reinforcement: { material: "steel", spacing: 0.18, diameter: 8e-3, residualCapacity: 0.15 },
+      units: { size: [0.6, 0.42, 0.2], bond: "stack", mortar: "concrete" },
+      breach: { area: 0.25 }
+    },
+    {
+      id: "drywall",
+      name: "Drywall partition on steel studs",
+      core: { material: "plaster", thickness: 0.0125 },
+      layers: [{ material: "plaster", thickness: 0.0125, faces: "+" }],
+      depth: 0.095,
+      breach: { area: 0.25 }
+    },
+    {
+      id: "wood_frame_wall",
+      name: "Wood frame wall",
+      core: { material: "plywood", thickness: 0.012 },
+      layers: [{ material: "plaster", thickness: 0.0125, faces: "-" }],
+      depth: 0.1135,
+      breach: { area: 0.25 }
+    },
+    {
+      id: "log_wall",
+      name: "Log wall",
+      core: { material: "wood_soft", thickness: 0.2 },
+      fill: 0.785,
+      breach: { area: 0.25 }
+    },
+    {
+      id: "sheet_metal_shack",
+      name: "Corrugated sheet metal wall",
+      core: { material: "steel", thickness: 6e-4 },
+      depth: 0.02,
+      breach: { area: 0.25 }
+    },
+    {
+      id: "glass_pane",
+      name: "Glass pane",
+      core: { material: "glass", thickness: 6e-3 },
+      breach: { area: 0.1 }
+    }
+  ];
+  var ASSEMBLIES = assemblies_default;
+  var getAssembly = (id) => ASSEMBLIES.find((a) => a.id === id);
+  var faceCount = (layer) => layer.faces === "both" ? 2 : 1;
+  var assemblyDepth = (def) => def.depth ?? def.core.thickness + (def.layers ?? []).reduce((sum, l) => sum + l.thickness * faceCount(l), 0);
+  var assemblyPart = (assemblyId, options) => {
+    const def = getAssembly(assemblyId);
+    if (!def) throw new Error(`unknown assembly "${assemblyId}"`);
+    const densityOf2 = (id) => {
+      const m = options.materials?.get(id) ?? MATERIALS.find((x) => x.id === id);
+      if (!m) throw new Error(`unknown material "${id}" in assembly "${assemblyId}"`);
+      return m.density;
+    };
+    const fill = def.fill ?? 1;
+    const area = options.width * options.height;
+    const coreMass = area * def.core.thickness * fill * densityOf2(def.core.material);
+    const layerMass = (def.layers ?? []).reduce((sum, l) => sum + area * l.thickness * faceCount(l) * densityOf2(l.material), 0);
+    return {
+      id: options.id,
+      material: def.core.material,
+      shape: { kind: "box", size: [options.width, options.height, assemblyDepth(def)] },
+      position: options.position,
+      ...options.rotation ? { rotation: options.rotation } : {},
+      mass: coreMass + layerMass,
+      thickness: def.core.thickness * fill,
+      ...def.layers ? { layers: def.layers.map((l) => ({ ...l })) } : {},
+      ...def.units ? { units: { ...def.units, size: [...def.units.size] } } : {},
+      ...def.reinforcement ? { reinforcement: { ...def.reinforcement } } : {},
+      ...def.breach ? { breach: { ...def.breach } } : {},
+      ...options.structure ? { structure: options.structure } : {},
+      ...options.extra
+    };
+  };
+
+  // src/loads.ts
+  function loadsAtRest(parts, supports, without) {
+    const byId = new Map(parts.filter((part) => part.id !== without).map((part) => [part.id, part]));
+    const resting = /* @__PURE__ */ new Map();
+    const carrying = /* @__PURE__ */ new Map();
+    const push = (map, key, value) => {
+      const list = map.get(key);
+      if (list) list.push(value);
+      else map.set(key, [value]);
+    };
+    for (const support of supports) {
+      if (support.bears === false) continue;
+      if (!byId.has(support.part) || support.on !== GROUND && !byId.has(support.on)) continue;
+      push(resting, support.part, support.on);
+      push(carrying, support.on, support.part);
+    }
+    const partition = (id) => byId.get(id)?.role === "partition";
+    const structural = (id) => byId.has(id) && byId.get(id).role !== "none";
+    const distance = /* @__PURE__ */ new Map([[GROUND, 0]]);
+    const queue = [GROUND];
+    for (let head = 0; head < queue.length; head++) {
+      const current = queue[head];
+      if (current !== GROUND && partition(current)) continue;
+      for (const above of carrying.get(current) ?? []) {
+        if (distance.has(above) || !structural(above)) continue;
+        distance.set(above, distance.get(current) + 1);
+        queue.push(above);
+      }
+    }
+    const incoming = /* @__PURE__ */ new Map();
+    const loads = /* @__PURE__ */ new Map();
+    for (let head = queue.length - 1; head >= 1; head--) {
+      const id = queue[head];
+      const total = (byId.get(id).mass || 1) + (incoming.get(id) ?? 0);
+      loads.set(id, total);
+      const below = (resting.get(id) ?? []).filter((other) => distance.has(other) && distance.get(other) < distance.get(id) && !(other !== GROUND && partition(other)));
+      for (const other of below) incoming.set(other, (incoming.get(other) ?? 0) + total / below.length);
+    }
+    return loads;
+  }
+  var isBearing = (part) => part.role === "column" || part.role === "wall";
+  function sizeCapacities(parts, supports, options) {
+    const loads = loadsAtRest(parts, supports);
+    const worst = /* @__PURE__ */ new Map();
+    for (const part of parts.filter(isBearing)) {
+      for (const [id, load] of loadsAtRest(parts, supports, part.id)) {
+        const before = loads.get(id);
+        if (before && load / before > (worst.get(id) ?? 1)) worst.set(id, load / before);
+      }
+    }
+    const capacities = /* @__PURE__ */ new Map();
+    for (const part of parts) {
+      const load = loads.get(part.id);
+      if (load === void 0 || part.role === "none") continue;
+      const factor = isBearing(part) ? Math.max(1 / options.safety, (worst.get(part.id) ?? 1) / options.redundancy) : 1 / options.safetyOthers;
+      capacities.set(part.id, Math.max(1, load * factor));
+    }
+    return capacities;
+  }
+
+  // src/wall-detail/apply.ts
+  function applySplits(input, splits) {
+    if (!splits.size) return input;
+    const boxes = new Map(input.parts.map((part) => [part.id, part.aabb]));
+    const pieceBox = /* @__PURE__ */ new Map();
+    for (const split of splits.values()) for (const piece of split.pieces) pieceBox.set(piece.id, piece.aabb);
+    const parts = input.parts.flatMap((part) => splits.get(part.id)?.pieces ?? [part]);
+    const supports = [];
+    for (const support of input.supports) {
+      const own = splits.get(support.part);
+      const host = splits.get(support.on);
+      const resting = boxes.get(support.part);
+      const targets = host ? host.top.filter((id) => resting && touches(pieceBox.get(id), resting, 0.05)) : [support.on];
+      const carriers = host ? targets.length ? targets : host.top : targets;
+      for (const part of own ? own.base : [support.part]) for (const on of carriers) supports.push({ ...support, part, on });
+    }
+    for (const split of splits.values()) supports.push(...split.internal);
+    return { parts, supports };
+  }
+
+  // src/wall-detail/courses.ts
+  var MIN_UNIT = 0.02;
+  function cutAt(from, to, openings, y0, y1) {
+    let stretches = [[from, to]];
+    for (const opening2 of openings.filter((o) => o.y0 < y1 - MIN_UNIT && o.y1 > y0 + MIN_UNIT)) {
+      stretches = stretches.flatMap(([a, b]) => {
+        if (opening2.to <= a || opening2.from >= b) return [[a, b]];
+        return [[a, Math.min(b, opening2.from)], [Math.max(a, opening2.to), b]].filter(([x, y]) => y - x > MIN_UNIT);
+      });
+    }
+    return stretches;
+  }
+  function unitsOf(from, to, row, spec) {
+    const length = spec.unitLength;
+    if (!length) return [[from, to]];
+    const offset = spec.bond === "running" && row % 2 === 1 ? length / 2 : 0;
+    const cuts = [from];
+    for (let at2 = from + (offset || length); at2 < to - MIN_UNIT; at2 += length) cuts.push(at2);
+    cuts.push(to);
+    return cuts.slice(0, -1).map((start, k) => [start, cuts[k + 1]]).filter(([a, b]) => b - a > MIN_UNIT);
+  }
+  function splitIntoCourses(wall, openings, spec) {
+    const alongU = wall.aabb[2] - wall.aabb[0] >= wall.aabb[3] - wall.aabb[1];
+    const from = alongU ? wall.aabb[0] : wall.aabb[1];
+    const to = alongU ? wall.aabb[2] : wall.aabb[3];
+    const cross = alongU ? [wall.aabb[1], wall.aabb[3]] : [wall.aabb[0], wall.aabb[2]];
+    const rows = Math.max(1, Math.round((wall.y1 - wall.y0) / spec.rowHeight));
+    const rowHeight = (wall.y1 - wall.y0) / rows;
+    const cells = [];
+    for (let row = 0; row < rows; row++) {
+      const y0 = wall.y0 + row * rowHeight;
+      const y1 = wall.y0 + (row + 1) * rowHeight;
+      for (const [a, b] of cutAt(from, to, openings.filter((o) => o.wall === wall.id), y0, y1)) for (const [x0, x1] of unitsOf(a, b, row, spec)) cells.push({ from: x0, to: x1, row, y0, y1 });
+    }
+    const total = cells.reduce((sum, cell) => sum + (cell.to - cell.from) * (cell.y1 - cell.y0), 0);
+    const box = (cell) => alongU ? [cell.from, cross[0], cell.to, cross[1]] : [cross[0], cell.from, cross[1], cell.to];
+    const pieces = cells.map((cell, index) => ({
+      id: `${wall.id}_${spec.unitLength ? "u" : "log"}${cell.row}_${index}`,
+      role: wall.role,
+      material: wall.material,
+      aabb: box(cell),
+      y0: cell.y0,
+      y1: cell.y1,
+      floor: wall.floor,
+      mass: round2(Math.max(0.1, wall.mass * (cell.to - cell.from) * (cell.y1 - cell.y0) / total)),
+      host: wall.id,
+      assembly: spec.assembly,
+      unit: true
+    }));
+    const internal = [];
+    cells.forEach((cell, index) => {
+      if (cell.row === 0) return;
+      const below = cells.map((other, k) => ({ other, k })).filter(({ other }) => other.row === cell.row - 1 && Math.min(other.to, cell.to) - Math.max(other.from, cell.from) > MIN_UNIT);
+      for (const { k } of below) internal.push({ part: pieces[index].id, on: pieces[k].id, joint: spec.joint });
+    });
+    return { pieces, internal, base: pieces.filter((_, i) => cells[i].row === 0).map((p) => p.id), top: pieces.filter((_, i) => cells[i].row === rows - 1).map((p) => p.id) };
+  }
+
+  // src/wall-detail/panels.ts
+  var LINTEL_DEPTH2 = 0.2;
+  var LINTEL_BEARING2 = 0.2;
+  var MIN_PIECE = 0.05;
+  var frameOf = (wall) => {
+    const alongU = wall.aabb[2] - wall.aabb[0] >= wall.aabb[3] - wall.aabb[1];
+    return alongU ? { alongU, from: wall.aabb[0], to: wall.aabb[2], cross: [wall.aabb[1], wall.aabb[3]] } : { alongU, from: wall.aabb[1], to: wall.aabb[3], cross: [wall.aabb[0], wall.aabb[2]] };
+  };
+  var boxOf = (frame, from, to) => frame.alongU ? [from, frame.cross[0], to, frame.cross[1]] : [frame.cross[0], from, frame.cross[1], to];
+  function splitIntoPanels(wall, openings, style) {
+    const frame = frameOf(wall);
+    const own = openings.filter((o) => o.wall === wall.id && o.to > frame.from + MIN_PIECE && o.from < frame.to - MIN_PIECE).sort((a, b) => a.from - b.from);
+    if (!own.length) return { pieces: [wall], internal: [], base: [wall.id], top: [wall.id] };
+    const drafts = [];
+    const piers = [];
+    const lintels = [];
+    const spandrels = [];
+    const height = wall.y1 - wall.y0;
+    let cursor = frame.from;
+    const roleOf2 = wall.role;
+    const addPier = (to) => {
+      if (to - cursor < MIN_PIECE) return;
+      piers.push({ id: `${wall.id}_pier_${piers.length}`, role: roleOf2, material: wall.material, from: cursor, to, y0: wall.y0, y1: wall.y1, volume: (to - cursor) * height });
+    };
+    own.forEach((opening2, k) => {
+      addPier(Math.max(cursor, opening2.from));
+      const lintelTop = Math.min(wall.y1, opening2.y1 + LINTEL_DEPTH2);
+      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) });
+      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) {
+        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 total = all.reduce((sum, d) => sum + d.volume, 0);
+    const pieces = all.map((d) => ({
+      id: d.id,
+      role: d.role,
+      material: d.material,
+      aabb: boxOf(frame, d.from, d.to),
+      y0: d.y0,
+      y1: d.y1,
+      floor: wall.floor,
+      mass: round2(Math.max(0.1, wall.mass * d.volume / total)),
+      host: wall.id,
+      ...d.role === "beam" ? style.lintelAssembly ? { assembly: style.lintelAssembly } : {} : wall.assembly ? { assembly: wall.assembly } : {}
+    }));
+    const internal = [];
+    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];
+      if (spandrel) internal.push({ part: spandrel.id, on: lintel.id, joint: style.wallJoint });
+    });
+    const base = [...piers, ...drafts.filter((d) => d.id.includes("_sill_"))].map((d) => d.id);
+    const top = [...piers.map((p) => p.id), ...lintels.map((l, k) => spandrels[k]?.id ?? l.id)];
+    return { pieces, internal, base, top };
+  }
+
+  // src/wall-detail/index.ts
+  var LOG_DIAMETER = 0.26;
+  var isWall = (part) => part.id.startsWith("wall_") && part.assembly !== void 0 && (part.role === "wall" || part.role === "partition");
+  function logSpec(construction, part) {
+    const diameter = construction.walls.logDiameter ?? LOG_DIAMETER;
+    return { rowHeight: diameter, bond: "stack", joint: CONSTRUCTION_SYSTEMS.get(construction.system).joints.wall, assembly: part.assembly };
+  }
+  function panelSplits(input, structure) {
+    const { construction } = structure;
+    const system = CONSTRUCTION_SYSTEMS.get(construction.system);
+    const splits = /* @__PURE__ */ new Map();
+    for (const part of input.parts.filter(isWall)) {
+      if (construction.system === "log") {
+        splits.set(part.id, splitIntoCourses(part, structure.openings, logSpec(construction, part)));
+        continue;
+      }
+      const split = splitIntoPanels(part, structure.openings, {
+        lintelMaterial: system.timber ? construction.frame.timber : "concrete",
+        ...system.timber ? {} : { lintelAssembly: "reinforced_concrete" },
+        lintelJoint: system.joints.beam,
+        wallJoint: system.joints.wall
+      });
+      if (split.pieces.length > 1) splits.set(part.id, split);
+    }
+    return splits;
+  }
+  function applyPanels(input, structure, detail) {
+    if (detail === "coarse") return input;
+    return applySplits(input, panelSplits(input, structure));
+  }
+  function applyUnits(input, structure) {
+    const splits = /* @__PURE__ */ new Map();
+    for (const part of input.parts) {
+      if (part.unit || !part.assembly || part.role === "beam" || part.role === "none") continue;
+      const units = getAssembly(part.assembly)?.units;
+      if (!units) continue;
+      const joint = CONSTRUCTION_SYSTEMS.get(structure.construction.system).joints.wall;
+      splits.set(part.id, splitIntoCourses(part, [], { rowHeight: units.size[1], unitLength: units.size[0], bond: units.bond, joint: units.mortar === "concrete" ? "mortar" : joint, assembly: part.assembly }));
+    }
+    const next = applySplits(input, splits);
+    const capacities = new Map(input.capacities);
+    for (const [id, split] of splits) {
+      const capacity = input.capacities.get(id);
+      capacities.delete(id);
+      if (capacity === void 0) continue;
+      const along = (box) => Math.max(box[2] - box[0], box[3] - box[1]);
+      const length = along(input.parts.find((part) => part.id === id).aabb);
+      for (const piece of split.pieces) capacities.set(piece.id, Math.max(1, capacity * along(piece.aabb) / length));
+    }
+    return { ...next, capacities };
+  }
+
+  // src/to-destructible-spec.ts
+  var CONTRACT_ROLE = { column: "column", beam: "beam", slab: "slab", wall: "wall", partition: "partition", roof: "roof", stair: "stair", none: "none" };
+  var TERRAIN_MARGIN = 6;
+  var TERRAIN_THICKNESS = 0.5;
+  var boxSpec = (part, capacity) => {
+    const [u0, v0, u1, v1] = part.aabb;
+    return {
+      id: part.id,
+      material: part.material,
+      shape: { kind: "box", size: [Math.max(0.01, u1 - u0), Math.max(0.01, part.y1 - part.y0), Math.max(0.01, v1 - v0)] },
+      position: [(u0 + u1) / 2, (part.y0 + part.y1) / 2, (v0 + v1) / 2],
+      mass: Math.max(0.1, part.mass || 1),
+      structure: capacity === void 0 ? { role: CONTRACT_ROLE[part.role] } : { role: CONTRACT_ROLE[part.role], capacity }
+    };
+  };
+  var assemblySpec = (part, capacity) => {
+    const [u0, v0, u1, v1] = part.aabb;
+    const alongU = u1 - u0 >= v1 - v0;
+    const spec = assemblyPart(part.assembly, {
+      id: part.id,
+      width: alongU ? u1 - u0 : v1 - v0,
+      height: part.y1 - part.y0,
+      position: [(u0 + u1) / 2, (part.y0 + part.y1) / 2, (v0 + v1) / 2],
+      ...alongU ? {} : { rotation: [0, Math.PI / 2, 0] },
+      structure: capacity === void 0 ? { role: CONTRACT_ROLE[part.role] } : { role: CONTRACT_ROLE[part.role], capacity },
+      extra: { mass: Math.max(0.1, part.mass || 1) }
+    });
+    if (part.unit) {
+      delete spec.units;
+      delete spec.breach;
+    }
+    return spec;
+  };
+  var partSpecOf = (part, capacity, detailed) => detailed && part.assembly ? assemblySpec(part, capacity) : boxSpec(part, capacity);
+  function toDestructibleSpec(structure, options = {}) {
+    const { safety = 0.65, redundancy = 0.97, safetyOthers = 0.45 } = options;
+    const kept = structure.parts.filter((part) => !options.filter || options.filter(part));
+    const portico = options.portico ?? (options.wallDetail !== "coarse" && structure.framed);
+    const roled = portico ? kept.map((part) => part.role === "wall" ? { ...part, role: "partition" } : part) : kept;
+    const ids = new Set(roled.map((part) => part.id));
+    const filtered = structure.supports.filter((support) => !options.filter || ids.has(support.part) && (support.on === GROUND || ids.has(support.on)));
+    const detail = options.wallDetail ?? "panels";
+    const panels = applyPanels({ parts: roled, supports: filtered }, structure, detail);
+    const sizing = { safety, redundancy, safetyOthers };
+    const sized = { ...panels, capacities: options.sized === false ? /* @__PURE__ */ new Map() : sizeCapacities(panels.parts, panels.supports, sizing) };
+    const { parts, supports, capacities } = detail === "units" ? applyUnits(sized, structure) : sized;
+    const specs = parts.map((part) => partSpecOf(part, capacities.get(part.id), detail !== "coarse"));
+    const margin = options.terrainMargin ?? TERRAIN_MARGIN;
+    const x0 = Math.min(...parts.map((part) => part.aabb[0]));
+    const z0 = Math.min(...parts.map((part) => part.aabb[1]));
+    const x1 = Math.max(...parts.map((part) => part.aabb[2]));
+    const z1 = Math.max(...parts.map((part) => part.aabb[3]));
+    if (parts.length) specs.push({ id: GROUND, material: "concrete", shape: { kind: "box", size: [x1 - x0 + margin, TERRAIN_THICKNESS, z1 - z0 + margin] }, position: [(x0 + x1) / 2, -TERRAIN_THICKNESS / 2, (z0 + z1) / 2], hp: 1e12, structure: { role: "foundation" }, anchored: true, tags: ["terrain"] });
+    const present = /* @__PURE__ */ new Set([...parts.map((part) => part.id), GROUND]);
+    const joints = supports.filter((s) => present.has(s.part) && present.has(s.on)).map((s) => ({ id: `${s.part}~${s.on}`, a: s.part, b: s.on, kind: s.joint, bears: s.bears === false ? false : "a_on_b" }));
+    return { name: options.name ?? "house", parts: specs, joints, tags: ["structure", "house"] };
+  }
+
+  // src/wall-specimen.ts
+  var SYSTEM_OF_ASSEMBLY = { log_wall: "log", wood_frame_wall: "wood_frame", sheet_metal_shack: "improvised" };
+  var DOOR_WIDTH2 = 0.9;
+  var WINDOW_WIDTH = 1;
+  function openingOf(kind, height) {
+    return kind === "door" ? { id: "door", kind, wall: "wall_specimen", from: -DOOR_WIDTH2 / 2, to: DOOR_WIDTH2 / 2, y0: 0, y1: height * 0.8 } : { id: "window", kind, wall: "wall_specimen", from: -WINDOW_WIDTH / 2, to: WINDOW_WIDTH / 2, y0: height * 0.33, y1: height * 0.8 };
+  }
+  function buildWallSpecimen(options) {
+    const { assembly, w, h, opening: opening2 = null, detail = "panels" } = options;
+    const def = getAssembly(assembly);
+    if (!def) throw new Error(`unknown assembly "${assembly}"`);
+    const system = SYSTEM_OF_ASSEMBLY[assembly] ?? "masonry";
+    const depth = assemblyDepth(def);
+    const mass = assemblyPart(assembly, { id: "wall_specimen", width: w, height: h, position: [0, h / 2, 0] }).mass ?? 1;
+    const construction = constructionOfSystem(system, { facade: {}, floors: [], rooms: [], walls: [], doors: [], items: [], w, d: depth });
+    const joint = CONSTRUCTION_SYSTEMS.get(system).joints.wall;
+    const structure = {
+      parts: [{ id: "wall_specimen", role: "wall", material: def.core.material, aabb: [-w / 2, -depth / 2, w / 2, depth / 2], y0: 0, y1: h, floor: 0, mass, assembly }],
+      supports: [{ part: "wall_specimen", on: GROUND, joint }],
+      openings: opening2 ? [openingOf(opening2, h)] : [],
+      levels: [0],
+      elevation: 0,
+      construction,
+      framed: false,
+      roof: { shape: "slab", covering: "", material: "", pitch: 0, bearingFloor: 0, panes: [], trusses: 0 }
+    };
+    return toDestructibleSpec(structure, { wallDetail: detail, sized: false, terrainMargin: 0.6, name: `wall_${assembly}` });
+  }
+
+  // src/index.ts
+  var version = "0.1.0";
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map