@adatechnology/game-floorplan-structure 1.0.5 → 1.1.0

package/dist/index.js

@@ -116,14 +116,14 @@ function logCabinConstruction(options = {}) {
 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";
+  const onSoil2 = 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" },
+    floor: onSoil2 ? { 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 }
+    foundation: onSoil2 ? { type: "ground", material: "soil", elevation: 0 } : { type: "raft", material: "concrete", elevation: 0.08 }
   };
 }
 function campConstruction() {
@@ -192,6 +192,13 @@ var en_default = {
     structure_beam_concrete: "Bond beam / beam (concrete)",
     structure_beam_wood: "Plate / beam (wood)",
     structure_roof_frame: "Trusses, rafters and ridge (roof view)"
+  },
+  labels: {
+    elevator_lobby: "Elevator lobby",
+    service_shaft: "Service shaft",
+    plant_room: "Plant room",
+    mechanical_floor: "Mechanical floor",
+    typical_floor: "Typical floor"
   }
 };
 
@@ -206,6 +213,13 @@ var pt_BR_default = {
     structure_beam_concrete: "Cinta / viga (concreto)",
     structure_beam_wood: "Prato / viga (madeira)",
     structure_roof_frame: "Tesouras, caibros e cumeeira (vista do telhado)"
+  },
+  labels: {
+    elevator_lobby: "Antessala dos elevadores",
+    service_shaft: "Shaft de servi\xE7o",
+    plant_room: "Casa de m\xE1quinas",
+    mechanical_floor: "Andar t\xE9cnico",
+    typical_floor: "Andar tipo"
   }
 };
 
@@ -391,14 +405,14 @@ 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 box2 = 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 });
+    const deck = builder.add({ id: `slab_${floor}_${room.id}`, role: "slab", material: construction.frame.slabs, aabb: box2, 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 });
+    const pillar = builder.add({ id: `balcony_column_${room.id}`, role: "column", material: construction.frame.pillars, aabb: [box2[0] - 0.08, box2[1] - 0.08, box2[0] + 0.08, box2[1] + 0.08], y0: 0, y1: context.level(floor) - system.slabThickness }, { floor: 0 });
     builder.rest(pillar, GROUND, "rebar");
     builder.rest(deck, pillar, "rebar");
   }
@@ -460,17 +474,17 @@ function addWell(context) {
 // 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 { floor, box: box2, thickness, carriers, material, joint, suffix = "" } = options;
+  const length = box2[2] - box2[0];
+  const depth = box2[3] - box2[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 centre = (alongU ? box2[0] : box2[1]) + 0.05 + k * (span - 0.1) / (count - 1);
+    const aabb = alongU ? [centre - 0.025, box2[1], centre + 0.025, box2[3]] : [box2[0], centre - 0.025, box2[2], centre + 0.025];
     const 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);
@@ -482,8 +496,8 @@ function addJoists(context, options) {
   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 });
+  const { floor, box: box2, thickness, joint } = options;
+  const deck = context.builder.add({ id, role: "slab", material, aabb: box2, 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;
 }
@@ -496,28 +510,28 @@ var raft = (context, thickness, material) => {
   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 { builder, construction, houseBox: box2 } = context;
+  const corners = [[box2[0], box2[1]], [box2[2], box2[1]], [box2[0], box2[3]], [box2[2], box2[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 });
+  const slab = builder.add({ id: "slab_base", role: "slab", material: construction.frame.slabs, aabb: box2, y0: top, y1: context.level(0) }, { floor: 0, footprint: [box2] });
   for (const pillar of pillars) builder.rest(slab, pillar, "rebar");
   context.base0 = slab;
 }
 function addBasement(context) {
-  const { builder, houseBox: box, elevation } = context;
+  const { builder, houseBox: box2, 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 });
+  const floor = builder.add({ id: "basement_slab", role: "slab", material: "concrete", aabb: box2, 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]]]
+    ["front", [box2[0], box2[1] - 0.1, box2[2], box2[1] + 0.1]],
+    ["back", [box2[0], box2[3] - 0.1, box2[2], box2[3] + 0.1]],
+    ["left", [box2[0] - 0.1, box2[1], box2[0] + 0.1, box2[3]]],
+    ["right", [box2[2] - 0.1, box2[1], box2[2] + 0.1, box2[3]]]
   ];
   const carried = [];
   for (const [name, aabb] of sides) {
@@ -526,10 +540,10 @@ function addBasement(context) {
     builder.rest(wall, floor, "rebar");
     carried.push(wall);
   }
-  const count = Math.max(1, Math.floor((box[2] - box[0]) / 3));
+  const count = Math.max(1, Math.floor((box2[2] - box2[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 u = box2[0] + (k + 0.5) * (box2[2] - box2[0]) / count;
+    const v = (box2[1] + box2[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");
@@ -539,26 +553,26 @@ function addBasement(context) {
   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 { builder, houseBox: box2, elevation, construction } = context;
+  const columns = Math.max(2, Math.ceil((box2[2] - box2[0]) / 2) + 1);
+  const rows = Math.max(2, Math.ceil((box2[3] - box2[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 u = box2[0] + i * (box2[2] - box2[0]) / (columns - 1);
+      const v = box2[1] + j * (box2[3] - box2[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 alongU = box2[2] - box2[0] >= box2[3] - box2[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 at2 = alongU ? box2[1] + line * (box2[3] - box2[1]) / (rows - 1) : box2[0] + line * (box2[2] - box2[0]) / (columns - 1);
+    const aabb = alongU ? [box2[0], at2 - 0.07, box2[2], at2 + 0.07] : [at2 - 0.07, box2[1], at2 + 0.07, box2[3]];
     const beam = builder.add({ id: `base_beam_${line}`, role: "beam", material: construction.frame.timber, aabb, y0: height, y1: elevation - context.system.slabThickness }, { floor: 0 });
     const centre = (q) => alongU ? (q.aabb[1] + q.aabb[3]) / 2 : (q.aabb[0] + q.aabb[2]) / 2;
     for (const pier of piers.filter((q) => Math.abs(centre(q) - at2) < 0.05)) builder.rest(beam, pier, "bolt");
@@ -567,12 +581,12 @@ function addPiers(context) {
   return beams;
 }
 function addRaisedFloor(context) {
-  const { construction, system, houseBox: box } = context;
+  const { construction, system, houseBox: box2 } = 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 joists = addJoists(context, { floor: 0, box: box2, 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);
+  context.base0 = addDeck(context, "slab_0", deckMaterial, { floor: 0, box: box2, thickness, joint: "nail" }, joists);
 }
 function addFoundation(context) {
   const { type, material } = context.construction.foundation;
@@ -666,9 +680,9 @@ 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 box2 = [u - 0.1, v - 0.1, u + 0.1, v + 0.1];
+    const top = Math.max(topOfFloor, ...plates.filter((plate) => touches(plate.aabb, box2, 0.05)).map((plate) => plate.y0));
+    const pillar = builder.add({ id: `column_${floor}_${k}`, role: "column", material: context.construction.frame.pillars, aabb: box2, 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");
@@ -793,20 +807,20 @@ 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 });
+  const slab = builder.add({ id: `slab_top${unit.suffix}`, role: "slab", material: construction.frame.slabs, aabb: [u0 - 0.15, v0 - 0.15, u1 + 0.15, v1 + 0.15], y0: top, y1: top + 0.12 }, { floor: unit.floor, cover: true, footprint: [unit.box] });
   for (const carrier of carriers.length ? carriers : context.plates.get(unit.floor) ?? []) builder.rest(slab, carrier, system.joints.slab);
   if (unit.suffix === "") context.topSlab = slab;
   return { id: slab.id, aabb: slab.aabb, y0: slab.y0, y1: slab.y1, flat: true };
 }
 function addTrusses(context, unit, carriers, geometry) {
   const { builder, construction, system } = context;
-  const { box } = unit;
+  const { box: box2 } = 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 at2 = (axis === "u" ? box2[0] : box2[1]) + k * length / (count - 1);
+    const aabb = axis === "u" ? [at2 - 0.04, box2[1] - eave * 0.5, at2 + 0.04, box2[3] + eave * 0.5] : [box2[0] - eave * 0.5, at2 - 0.04, box2[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);
@@ -816,11 +830,11 @@ function addTrusses(context, unit, carriers, geometry) {
   return trusses;
 }
 function geometryOf(context, unit) {
-  const { box } = unit;
+  const { box: box2 } = 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 width = box2[2] - box2[0];
+  const depth = box2[3] - box2[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;
@@ -829,14 +843,14 @@ function geometryOf(context, unit) {
 }
 function addRafters(context, unit, carriers, geometry) {
   const { builder, construction, system } = context;
-  const { box } = unit;
+  const { box: box2 } = 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 middle = axis === "u" ? (box2[1] + box2[3]) / 2 : (box2[0] + box2[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]]];
+    const at2 = (axis === "u" ? box2[0] : box2[1]) + k * length / (count - 1);
+    const halves = axis === "u" ? [["a", [at2 - 0.04, box2[1] - eave * 0.5, at2 + 0.04, middle]], ["b", [at2 - 0.04, middle, at2 + 0.04, box2[3] + eave * 0.5]]] : [["a", [box2[0] - eave * 0.5, at2 - 0.04, middle, at2 + 0.04]], ["b", [middle, at2 - 0.04, box2[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");
@@ -848,7 +862,7 @@ function addRafters(context, unit, carriers, geometry) {
     }
   }
   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 ridgeBox = axis === "u" ? [box2[0] - eave, middle - 0.05, box2[2] + eave, middle + 0.05] : [middle - 0.05, box2[1] - eave, middle + 0.05, box2[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);
   }
@@ -895,10 +909,10 @@ 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 box2 = 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 length = box2[2] - box2[0];
+  const depth = box2[3] - box2[1];
   const alongU = length >= depth;
   const span = alongU ? length : depth;
   const count = Math.max(2, Math.round(span / 0.6) + 1);
@@ -906,8 +920,8 @@ function addCeilingJoists(context) {
   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 at2 = (alongU ? box2[0] : box2[1]) + 0.05 + k * (span - 0.1) / (count - 1);
+    const aabb = alongU ? [at2 - 0.025, box2[1], at2 + 0.025, box2[3]] : [box2[0], at2 - 0.025, box2[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");
@@ -996,11 +1010,11 @@ function addDoorLintels(context) {
     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 box2 = door.axis === "u" ? [lo, cross - half, hi, cross + half] : [cross - half, lo, cross + half, hi];
     const y0 = context.level(door.floor) + DOOR_HEIGHT;
-    const lintel = builder.add({ id: `lintel_${door.id}`, role: "beam", material: system.timber ? construction.frame.timber : "concrete", aabb: box, y0, y1: y0 + LINTEL_DEPTH }, { floor: door.floor, ...system.timber ? {} : { assembly: "reinforced_concrete" } });
+    const lintel = builder.add({ id: `lintel_${door.id}`, role: "beam", material: system.timber ? construction.frame.timber : "concrete", aabb: box2, y0, y1: y0 + LINTEL_DEPTH }, { floor: door.floor, ...system.timber ? {} : { assembly: "reinforced_concrete" } });
     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);
+    for (const plate of context.plates.get(door.floor) ?? []) if (overlapsInPlan(plate.aabb, box2)) 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];
@@ -1057,11 +1071,11 @@ function ensureCeilingSlab(context, y) {
   const existing = builder.find("slab_ceiling");
   if (existing) return existing;
   const top = context.floorCount - 1;
-  const box = context.topBox;
+  const box2 = 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)
+    (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(box2, 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 });
+  const slab = builder.add({ id: "slab_ceiling", role: "slab", material: construction.frame.slabs, aabb: box2, y0: y - 0.12, y1: y }, { floor: top, footprint: [box2] });
   for (const carrier of carriers) builder.rest(slab, carrier, system.joints.slab);
   return slab;
 }
@@ -1137,16 +1151,16 @@ 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 box2 = 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);
+    const joists = addJoists(context, { floor: next, box: box2, thickness, carriers, material: construction.frame.timber, joint: system.joints.beam });
+    addDeck(context, `slab_${next}`, construction.frame.slabs, { floor: next, box: box2, 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 slab = builder.add({ id: `slab_${next}`, role: "slab", material: construction.frame.slabs, aabb: box2, y0: context.level(next) - thickness, y1: context.level(next) }, { floor: next, footprint: rects.length ? rects : [context.houseBox] });
   const below = carriers.filter((carrier) => carrier.y0 <= slab.y0 + 0.05);
   const touching = below.filter((carrier) => touches(slab.aabb, carrier.aabb, 0.2));
   for (const carrier of touching.length ? touching : below) builder.rest(slab, carrier, system.joints.slab);
@@ -1704,19 +1718,19 @@ function inNiche(context, stove, room, doorZones) {
   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 distance2 = (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));
+  ).sort((a, b) => (a.category === "kitchen_cabinet" ? 0 : 1) - (b.category === "kitchen_cabinet" ? 0 : 1) || distance2(a) - distance2(b));
   for (const cabinet of cabinets) {
-    if (distance(cabinet) > 3) continue;
-    const box = cabinet.aabb;
+    if (distance2(cabinet) > 3) continue;
+    const box2 = 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 cx = clamp(stove.x, box2[0] + hw + 0.01, box2[2] - hw - 0.01);
+    const cz = clamp(stove.z, box2[1] + hd + 0.01, box2[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;
+    if (rect[0] < box2[0] || rect[2] > box2[2] || rect[1] < box2[1] || rect[3] > box2[3] || overlaps(rect, stove.aabb, 0.011)) continue;
     return { mode: "under", x: cx, z: cz, rect, cabinet: cabinet.id };
   }
   return void 0;
@@ -1873,16 +1887,16 @@ function planSolar(context) {
   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 box2 = [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 uStart = box2[0] + margin;
+  const uEnd = box2[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 vMiddle = (box2[1] + box2[3]) / 2;
+  const vArea = flat ? [box2[1] + margin, box2[3] - margin] : north === "front" ? [box2[1] + 0.4, vMiddle - 0.2] : [vMiddle + 0.2, box2[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));
@@ -1954,13 +1968,13 @@ function opening(frame, id, a, b, vector, width, extra) {
   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) {
+function wallsOf(box2, 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" }
+    { axis: "u", pos: box2[1], i0: box2[0], i1: box2[2], side: "front" },
+    { axis: "u", pos: box2[3], i0: box2[0], i1: box2[2], side: "back" },
+    { axis: "v", pos: box2[0], i0: box2[1], i1: box2[3], side: "left" },
+    { axis: "v", pos: box2[2], i0: box2[1], i1: box2[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;
@@ -1981,9 +1995,9 @@ function furnish(context, frame, use, interior, insideDoor) {
     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 });
+    const box2 = [u - eu / 2, v - ev / 2, u + eu / 2, v + ev / 2].map(round22);
+    if (box2[0] < interior[0] - 0.011 || box2[2] > interior[2] + 0.011 || box2[1] < interior[1] - 0.011 || box2[3] > interior[3] + 0.011 || overlaps(box2, insideDoor) || placed.some((o) => overlaps(box2, 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: box2 });
   });
   return placed;
 }
@@ -2050,8 +2064,8 @@ function addOutbuildingPaths(lot, outbuildings, items) {
           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;
+            const distance2 = 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 + distance2;
             if (!best || value < best.v) best = { v: value, k, from: c.from };
           }
         }
@@ -2279,7 +2293,7 @@ function register(engine, options = {}) {
 }
 
 // src/to-destructible-spec.ts
-import { assemblyPart } from "@adatechnology/game-destruction";
+import { GRAVITY, MATERIALS, SOILS, assemblyPart, partMass, pileLength, profileOf, sizeRebar } from "@adatechnology/game-destruction";
 
 // src/loads.ts
 function loadsAtRest(parts, supports, without) {
@@ -2299,14 +2313,14 @@ function loadsAtRest(parts, supports, without) {
   }
   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 distance2 = /* @__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);
+      if (distance2.has(above) || !structural(above)) continue;
+      distance2.set(above, distance2.get(current) + 1);
       queue.push(above);
     }
   }
@@ -2316,7 +2330,7 @@ function loadsAtRest(parts, supports, without) {
     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)));
+    const below = (resting.get(id) ?? []).filter((other) => distance2.has(other) && distance2.get(other) < distance2.get(id) && !(other !== GROUND && partition(other)));
     for (const other of below) incoming.set(other, (incoming.get(other) ?? 0) + total / below.length);
   }
   return loads;
@@ -2341,6 +2355,533 @@ function sizeCapacities(parts, supports, options) {
   return capacities;
 }
 
+// src/slab-panels/layout.ts
+var EPS = 1e-6;
+function linesOf(boxes) {
+  return boxes.map(([u0, v0, u1, v1]) => u1 - u0 >= v1 - v0 ? { dir: "u", at: (v0 + v1) / 2, from: u0, to: u1 } : { dir: "v", at: (u0 + u1) / 2, from: v0, to: v1 });
+}
+function coverage(lines, dir, at2, from, to, options) {
+  const spans = lines.filter((line) => line.dir === dir && Math.abs(line.at - at2) <= options.lineTolerance).map((line) => [Math.max(from, line.from), Math.min(to, line.to)]).filter(([a, b]) => b > a).sort((x, y) => x[0] - y[0]);
+  let covered = 0;
+  let end = from;
+  let start = NaN;
+  for (const [a, b] of spans) {
+    if (Number.isNaN(start)) {
+      start = a;
+      end = b;
+    } else if (a - end <= options.doorGap) end = Math.max(end, b);
+    else {
+      covered += end - start;
+      start = a;
+      end = b;
+    }
+  }
+  if (!Number.isNaN(start)) covered += end - start;
+  return to > from ? covered / (to - from) : 0;
+}
+function positions(lines, dir, tolerance) {
+  const sorted = lines.filter((line) => line.dir === dir).map((line) => line.at).sort((a, b) => a - b);
+  const out = [];
+  let group = [];
+  for (const at2 of sorted) {
+    if (group.length && at2 - group[group.length - 1] > tolerance) {
+      out.push(group.reduce((s, x) => s + x, 0) / group.length);
+      group = [];
+    }
+    group.push(at2);
+  }
+  if (group.length) out.push(group.reduce((s, x) => s + x, 0) / group.length);
+  return out;
+}
+var round = (x) => Math.round(x * 100) / 100;
+function choose(rect, lines, options) {
+  const [u0, v0, u1, v1] = rect;
+  const width = u1 - u0;
+  const depth = v1 - v0;
+  const tooWide = width > options.maxSpan + EPS;
+  const tooDeep = depth > options.maxSpan + EPS;
+  const candidates = [];
+  for (const at2 of positions(lines, "v", options.lineTolerance)) {
+    if (at2 < u0 + options.minPanel - EPS || at2 > u1 - options.minPanel + EPS) continue;
+    candidates.push({ dir: "v", at: at2, coverage: coverage(lines, "v", at2, v0, v1, options), skew: Math.abs(at2 - (u0 + u1) / 2) / (width / 2) });
+  }
+  for (const at2 of positions(lines, "u", options.lineTolerance)) {
+    if (at2 < v0 + options.minPanel - EPS || at2 > v1 - options.minPanel + EPS) continue;
+    candidates.push({ dir: "u", at: at2, coverage: coverage(lines, "u", at2, u0, u1, options), skew: Math.abs(at2 - (v0 + v1) / 2) / (depth / 2) });
+  }
+  const boundary = candidates.filter((c) => c.coverage >= options.lineCoverage);
+  if (tooWide || tooDeep) {
+    const across = tooWide && (!tooDeep || width >= depth) ? "v" : "u";
+    const pool = boundary.filter((c) => c.dir === across);
+    if (pool.length) {
+      const best2 = pool.reduce((a, b) => b.skew - 0.25 * b.coverage < a.skew - 0.25 * a.coverage ? b : a);
+      return { dir: best2.dir, at: round(best2.at) };
+    }
+    const length = across === "v" ? width : depth;
+    const origin = across === "v" ? u0 : v0;
+    return { dir: across, at: round(origin + length / Math.ceil(length / options.maxSpan - EPS)) };
+  }
+  if (!boundary.length) return null;
+  const best = boundary.reduce((a, b) => b.coverage - 0.25 * b.skew > a.coverage - 0.25 * a.skew ? b : a);
+  return { dir: best.dir, at: round(best.at) };
+}
+function layoutPanels(rect, lines, options) {
+  const leaves = [];
+  const cuts = [];
+  const walk = (r, depth) => {
+    const cut = depth < 16 ? choose(r, lines, options) : null;
+    if (!cut) {
+      leaves.push(r);
+      return;
+    }
+    if (cut.dir === "v") {
+      cuts.push({ dir: "v", at: cut.at, from: r[1], to: r[3] });
+      walk([r[0], r[1], cut.at, r[3]], depth + 1);
+      walk([cut.at, r[1], r[2], r[3]], depth + 1);
+    } else {
+      cuts.push({ dir: "u", at: cut.at, from: r[0], to: r[2] });
+      walk([r[0], r[1], r[2], cut.at], depth + 1);
+      walk([r[0], cut.at, r[2], r[3]], depth + 1);
+    }
+  };
+  walk(rect, 0);
+  return { leaves, cuts };
+}
+var areaOf = (rect) => Math.max(0, rect[2] - rect[0]) * Math.max(0, rect[3] - rect[1]);
+function overlapArea(a, b) {
+  return Math.max(0, Math.min(a[2], b[2]) - Math.max(a[0], b[0])) * Math.max(0, Math.min(a[3], b[3]) - Math.max(a[1], b[1]));
+}
+function shareInside(rect, footprint) {
+  const area = areaOf(rect);
+  return area > 0 ? Math.min(1, footprint.reduce((sum, other) => sum + overlapArea(rect, other), 0) / area) : 0;
+}
+function runsOf2(cut, panels, tolerance = 0.02) {
+  const spans = [];
+  for (const [u0, v0, u1, v1] of panels) {
+    if (cut.dir === "v") {
+      if (Math.abs(u0 - cut.at) < tolerance || Math.abs(u1 - cut.at) < tolerance) spans.push([Math.max(v0, cut.from), Math.min(v1, cut.to)]);
+    } else if (Math.abs(v0 - cut.at) < tolerance || Math.abs(v1 - cut.at) < tolerance) spans.push([Math.max(u0, cut.from), Math.min(u1, cut.to)]);
+  }
+  const sorted = spans.filter(([a, b]) => b - a > tolerance).sort((x, y) => x[0] - y[0]);
+  const runs = [];
+  for (const [a, b] of sorted) {
+    const last = runs[runs.length - 1];
+    if (last && a <= last[1] + tolerance) last[1] = Math.max(last[1], b);
+    else runs.push([a, b]);
+  }
+  return runs;
+}
+
+// src/slab-panels/apply.ts
+var SLAB_ID = /^slab_(\d+|top.*|ceiling|base)$/;
+var PLAN_TOLERANCE = 0.05;
+var BELOW = 0.35;
+var UP = 0.15;
+var END_REACH = 0.35;
+var EPS2 = 1e-6;
+var ceilTo = (value, step) => Math.ceil(value / step - 1e-9) * step;
+var isConcreteSlab = (part, material) => part.role === "slab" && part.material === material && SLAB_ID.test(part.id);
+var isBondBeam = (part, material) => part.role === "beam" && part.beamKind === "bond_beam" && part.material === material;
+function merged(intervals) {
+  const out = [];
+  for (const [a, b] of intervals.slice().sort((x, y) => x[0] - y[0])) {
+    const last = out[out.length - 1];
+    if (last && a <= last[1] + EPS2) last[1] = Math.max(last[1], b);
+    else out.push([a, b]);
+  }
+  return out;
+}
+function beamSpan(length, supports) {
+  const held = merged(supports.map(([a, b]) => [Math.max(0, a), Math.min(length, b)]).filter(([a, b]) => b > a));
+  if (!held.length) return { span: Infinity, at: length / 2, lo: 0, hi: length };
+  let span = 0;
+  let at2 = length / 2;
+  let lo = 0;
+  let hi = length;
+  const lead = held[0][0];
+  if (2 * lead > span) {
+    span = 2 * lead;
+    at2 = 0;
+    lo = 0;
+    hi = lead;
+  }
+  const trail = length - held[held.length - 1][1];
+  if (2 * trail > span) {
+    span = 2 * trail;
+    at2 = length;
+    lo = length - trail;
+    hi = length;
+  }
+  for (let k = 1; k < held.length; k++) {
+    const gap = held[k][0] - held[k - 1][1];
+    if (gap > span) {
+      span = gap;
+      at2 = (held[k][0] + held[k - 1][1]) / 2;
+      lo = held[k - 1][1];
+      hi = held[k][0];
+    }
+  }
+  return { span, at: at2, lo, hi };
+}
+var lineOf = (aabb, dir) => dir === "u" ? { dir, at: (aabb[1] + aabb[3]) / 2, from: aabb[0], to: aabb[2] } : { dir, at: (aabb[0] + aabb[2]) / 2, from: aabb[1], to: aabb[3] };
+var pointOf = (line, s) => line.dir === "u" ? [line.from + s, line.at] : [line.at, line.from + s];
+function holds(line, width, box2) {
+  const [across0, across1, along0, along1] = line.dir === "u" ? [box2[1], box2[3], box2[0], box2[2]] : [box2[0], box2[2], box2[1], box2[3]];
+  if (across0 >= line.at + width / 2 + PLAN_TOLERANCE || across1 <= line.at - width / 2 - PLAN_TOLERANCE) return void 0;
+  const a = Math.max(along0 - PLAN_TOLERANCE, line.from);
+  const b = Math.min(along1 + PLAN_TOLERANCE, line.to);
+  return b > a ? [a - line.from, b - line.from] : void 0;
+}
+var boxOfSpot = (spot, side) => [spot.u - side / 2, spot.v - side / 2, spot.u + side / 2, spot.v + side / 2];
+function distancesOf(context) {
+  const cache = context.distCache;
+  if (cache && cache.parts === context.parts.length && cache.supports === context.supports.length) return cache.map;
+  const map = distances(context.parts, context.supports);
+  context.distCache = { parts: context.parts.length, supports: context.supports.length, map };
+  return map;
+}
+function distances(parts, supports) {
+  const byId = new Map(parts.map((p) => [p.id, p]));
+  const carrying = /* @__PURE__ */ new Map();
+  for (const s of supports) {
+    if (s.bears === false || !byId.has(s.part) || s.on !== GROUND && !byId.has(s.on)) continue;
+    const list = carrying.get(s.on);
+    if (list) list.push(s.part);
+    else carrying.set(s.on, [s.part]);
+  }
+  const dist = /* @__PURE__ */ new Map([[GROUND, 0]]);
+  const queue = [GROUND];
+  for (let head = 0; head < queue.length; head++) {
+    const current = queue[head];
+    if (current !== GROUND && byId.get(current)?.role === "partition") continue;
+    for (const above of carrying.get(current) ?? []) {
+      if (dist.has(above) || byId.get(above)?.role === "none") continue;
+      dist.set(above, dist.get(current) + 1);
+      queue.push(above);
+    }
+  }
+  return dist;
+}
+function propsUnder(context, dist, y0, y1, floor) {
+  return context.parts.filter((q) => (q.role === "column" || q.role === "wall") && q.floor === floor && dist.has(q.id) && q.y0 < y0 - PLAN_TOLERANCE && q.y1 >= y0 - BELOW && q.y1 <= y1 + UP).map((q) => ({ box: q.aabb, dist: dist.get(q.id), part: q }));
+}
+function heldBy(line, width, props) {
+  const touching = props.map((prop) => ({ prop, interval: holds(line, width, prop.box) })).filter((x) => x.interval !== void 0);
+  if (!touching.length) return { intervals: [], used: [] };
+  const nearest = Math.min(...touching.map((x) => x.prop.dist));
+  const used = touching.filter((x) => x.prop.dist === nearest);
+  return { intervals: used.map((x) => x.interval), used: used.map((x) => x.prop) };
+}
+function pillarsFor(line, width, props, spots, dist, options, ends, ground = []) {
+  const length = line.to - line.from;
+  const side = options.columnSide;
+  const all = () => [...props, ...spots.map((spot) => ({ box: boxOfSpot(spot, side), dist: spot.dist }))];
+  const allowed = merged(ground.map((box2) => holds(line, 0.02, box2)).filter((x) => x !== void 0));
+  const place = (at2, lo, hi) => {
+    if (!allowed.length) return at2;
+    let best;
+    let gap = Infinity;
+    for (const [a, b] of allowed) {
+      const from = Math.max(a + side / 2, lo + 0.2);
+      const to = Math.min(b - side / 2, hi - 0.2);
+      if (to < from) continue;
+      const clamped = Math.min(to, Math.max(from, at2));
+      if (Math.abs(clamped - at2) < gap) {
+        gap = Math.abs(clamped - at2);
+        best = clamped;
+      }
+    }
+    return best ?? at2;
+  };
+  let held = heldBy(line, width, all()).intervals;
+  for (let guard = 0; guard < 64; guard++) {
+    let at2;
+    let lo = 0;
+    let hi = length;
+    if (ends && !held.some(([a]) => a <= END_REACH)) at2 = 0;
+    else if (ends && !held.some(([, b]) => b >= length - END_REACH)) at2 = length;
+    else {
+      const found = beamSpan(length, held);
+      if (found.span <= options.maxSpan + 1e-3) break;
+      at2 = found.at;
+      lo = found.lo;
+      hi = found.hi;
+    }
+    const [u, v] = pointOf(line, at2 === 0 || at2 === length ? at2 : place(at2, lo, hi));
+    const spot = { u: round2(u), v: round2(v), dist };
+    if (spots.some((other) => Math.hypot(other.u - spot.u, other.v - spot.v) < 0.15)) break;
+    spots.push(spot);
+    held = heldBy(line, width, all()).intervals;
+  }
+  return held;
+}
+var make = (draft) => {
+  const [u0, v0, u1, v1] = draft.aabb;
+  const volume = Math.max(0, (u1 - u0) * (v1 - v0) * (draft.y1 - draft.y0));
+  return { ...draft, aabb: draft.aabb.map(round2), y0: round2(draft.y0), y1: round2(draft.y1), mass: Math.max(1, Math.round(volume * densityOf(draft.material))) };
+};
+var rest = (context, on, below, joint = context.joint) => {
+  context.supports.push({ part: below.id, on: typeof on === "string" ? on : on.id, joint });
+};
+var distance = (a, b) => 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 panelsUnder(context, slab, box2) {
+  const panels = context.panelsOf.get(slab) ?? [];
+  const touching = panels.filter((panel) => touches(panel.aabb, box2, PLAN_TOLERANCE));
+  return touching.length ? touching : panels.slice().sort((a, b) => distance(a.aabb, box2) - distance(b.aabb, box2)).slice(0, 1);
+}
+function addPillar(context, spot, bottom, top, floor, below, slab) {
+  const pillar = make({
+    id: `pillar_${floor}_${context.pillars++}`,
+    role: "column",
+    material: context.pillarMaterial,
+    floor,
+    slab,
+    aabb: boxOfSpot(spot, context.options.columnSide),
+    y0: bottom,
+    y1: top
+  });
+  context.parts.push(pillar);
+  if (below && context.panelsOf.has(below)) for (const panel of panelsUnder(context, below, pillar.aabb)) rest(context, panel, pillar, "rebar");
+  else rest(context, context.groundBase, pillar, "rebar");
+  return pillar;
+}
+function storeyUnder(context, slab) {
+  const levels = context.structure.levels;
+  const match = /^slab_(\d+)$/.exec(slab.id);
+  const floor = match && Number(match[1]) >= 1 ? Number(match[1]) - 1 : slab.id === "slab_base" ? 0 : slab.floor;
+  return { floor, below: slab.id === "slab_base" || floor < 1 ? void 0 : `slab_${floor}`, bottom: slab.id === "slab_base" ? 0 : levels[floor] ?? 0 };
+}
+function pillarDist(context, dist, storey) {
+  if (storey.below && context.panelsOf.has(storey.below)) return Math.min(...context.panelsOf.get(storey.below).map((p) => dist.get(p.id) ?? 99)) + 1;
+  return (dist.get(context.groundBase) ?? 0) + 1;
+}
+function groundOf(context, below) {
+  const panels = context.panelsOf.get(below) ?? [];
+  const level = panels[0]?.y1;
+  if (level === void 0) return [];
+  return context.parts.filter((q) => q.role === "beam" && (q.slab === below || q.beamKind === "bond_beam" && Math.abs(q.y1 - level) < 0.4)).map((q) => q.aabb);
+}
+function thicknessOf(leaves, roof, options) {
+  const shortest = Math.max(...leaves.map((leaf) => Math.min(leaf[2] - leaf[0], leaf[3] - leaf[1])));
+  return Math.max(roof ? options.roofMinThickness : options.floorMinThickness, ceilTo(shortest / options.thicknessRatio, 0.01));
+}
+var restThickness = (slab, thickness, roof) => {
+  if (roof) slab.y1 = round2(slab.y0 + thickness);
+  else slab.y0 = round2(slab.y1 - thickness);
+  slab.mass = Math.max(1, Math.round((slab.aabb[2] - slab.aabb[0]) * (slab.aabb[3] - slab.aabb[1]) * (slab.y1 - slab.y0) * densityOf(slab.material)));
+};
+function cutSlab(context, slab, wallBoxes) {
+  const { options } = context;
+  const roof = slab.cover === true;
+  const layout = layoutPanels(slab.aabb, linesOf(wallBoxes), options);
+  const footprint = slab.footprint ?? [slab.aabb];
+  const kept = layout.leaves.filter((leaf) => shareInside(leaf, footprint) >= options.footprintShare);
+  const leaves = kept.length ? kept : [slab.aabb];
+  const thickness = thicknessOf(leaves, roof, options);
+  if (leaves.length === 1 && layout.cuts.length === 0) {
+    restThickness(slab, thickness, roof);
+    context.panelsOf.set(slab.id, [slab]);
+    return;
+  }
+  const own = context.supports.filter((s) => s.part === slab.id && s.bears !== false);
+  const resting = context.supports.filter((s) => s.on === slab.id);
+  context.supports = context.supports.filter((s) => s.part !== slab.id && s.on !== slab.id);
+  const [y0, y1] = roof ? [slab.y0, slab.y0 + thickness] : [slab.y1 - thickness, slab.y1];
+  const panels = leaves.map(
+    (leaf, k) => make({
+      id: `${slab.id}_p${k}`,
+      role: "slab",
+      material: slab.material,
+      aabb: leaf,
+      y0,
+      y1,
+      floor: slab.floor,
+      ...slab.cover ? { cover: true } : {},
+      slab: slab.id,
+      ...slab.footprint ? { footprint: slab.footprint } : {}
+    })
+  );
+  context.parts.splice(context.parts.indexOf(slab), 1, ...panels);
+  context.panelsOf.set(slab.id, panels);
+  const top = roof ? slab.y0 : y0;
+  const dist = distancesOf(context);
+  const storey = storeyUnder(context, slab);
+  const props = propsUnder(context, dist, top, slab.y1, storey.floor);
+  const near = props.length ? Math.min(...props.map((p) => p.dist)) : pillarDist(context, dist, storey);
+  const spots = [];
+  const bonds = context.parts.filter((q) => q.role === "beam" && q.beamKind === "bond_beam" && q.y1 >= top - BELOW && q.y0 < slab.y1);
+  const ground = storey.below ? groundOf(context, storey.below) : [];
+  const covered = (line) => {
+    const width = context.wallThickness;
+    const spans = merged(bonds.map((bond) => holds(line, width + 0.5, bond.aabb)).filter((x) => x !== void 0));
+    return spans.reduce((sum, [a, b]) => sum + Math.max(0, Math.min(b, line.to - line.from) - Math.max(a, 0)), 0) >= (line.to - line.from) * 0.9;
+  };
+  const [su0, sv0, su1, sv1] = slab.aabb;
+  const borders = [
+    { dir: "u", at: sv0, from: su0, to: su1 },
+    { dir: "u", at: sv1, from: su0, to: su1 },
+    { dir: "v", at: su0, from: sv0, to: sv1 },
+    { dir: "v", at: su1, from: sv0, to: sv1 }
+  ];
+  const beams = [];
+  let count = 0;
+  for (const cut of [...layout.cuts, ...borders]) {
+    for (const [from, to] of runsOf2(cut, leaves)) {
+      const line = { dir: cut.dir === "v" ? "v" : "u", at: cut.at, from, to };
+      if (covered(line)) continue;
+      const held = pillarsFor(line, context.wallThickness, props, spots, near, options, true, ground);
+      const span = Math.min(beamSpan(to - from, held).span, options.maxSpan);
+      const depth = beamDepthFor(span, options);
+      const width = Math.max(context.wallThickness, round2(depth / options.beamWidthRatio));
+      const aabb = line.dir === "u" ? [from, cut.at - width / 2, to, cut.at + width / 2] : [cut.at - width / 2, from, cut.at + width / 2, to];
+      beams.push({ part: make({ id: `${slab.id}_b${count++}`, role: "beam", material: context.beamMaterial, aabb, y0: top - depth, y1: top, floor: slab.floor, slab: slab.id }), line, width });
+    }
+  }
+  const pillars = spots.map((spot) => addPillar(context, spot, storey.bottom, top, storey.floor, storey.below, slab.id));
+  context.parts.splice(context.parts.indexOf(panels[panels.length - 1]) + 1, 0, ...beams.map((b) => b.part));
+  const all = [...props, ...pillars.map((p, k) => ({ box: p.aabb, dist: spots[k].dist, part: p }))];
+  for (const { part: beam, line, width } of beams) for (const used of heldBy(line, width, all).used) rest(context, used.part, beam);
+  for (const panel of panels) {
+    for (const { part: beam } of beams) if (touches(panel.aabb, beam.aabb, PLAN_TOLERANCE)) rest(context, beam, panel);
+    for (const bond of bonds) if (touches(panel.aabb, bond.aabb, PLAN_TOLERANCE)) rest(context, bond, panel, own.find((s) => s.on === bond.id)?.joint ?? context.joint);
+  }
+  for (const panel of panels.filter((p) => !context.supports.some((s) => s.part === p.id))) {
+    const nearest = [...beams.map((b) => b.part), ...bonds].sort((a, b) => distance(a.aabb, panel.aabb) - distance(b.aabb, panel.aabb))[0];
+    if (nearest) rest(context, nearest, panel);
+  }
+  for (const support of resting) {
+    const upper = context.parts.find((q) => q.id === support.part);
+    if (!upper) continue;
+    for (const panel of panelsUnder(context, slab.id, upper.aabb)) context.supports.push({ ...support, on: panel.id });
+  }
+}
+var beamDepthFor = (span, options, minimum = options.beamMinDepth) => Math.max(minimum, ceilTo(span / options.beamDepthRatio, options.beamStep));
+function deepenBondBeams(input, structure, options) {
+  const frame = structure.construction.frame;
+  if (!frame.rebar) return input;
+  const dist = distances(input.parts, input.supports);
+  const context = { parts: input.parts };
+  let changed = false;
+  const parts = input.parts.map((part) => {
+    if (!isBondBeam(part, frame.beams) || !dist.has(part.id)) return part;
+    const dir = part.aabb[2] - part.aabb[0] >= part.aabb[3] - part.aabb[1] ? "u" : "v";
+    const line = lineOf(part.aabb, dir);
+    const width = dir === "u" ? part.aabb[3] - part.aabb[1] : part.aabb[2] - part.aabb[0];
+    const span = beamSpan(line.to - line.from, heldBy(line, width, propsUnder(context, dist, part.y0, part.y1, part.floor)).intervals).span;
+    if (!(span > 1.5) || !Number.isFinite(span)) return part;
+    const depth = Math.max(part.y1 - part.y0, beamDepthFor(span, options));
+    const wide = Math.max(width, round2(depth / options.beamWidthRatio));
+    const grow = (wide - width) / 2;
+    changed = true;
+    const aabb = dir === "u" ? [part.aabb[0], part.aabb[1] - grow, part.aabb[2], part.aabb[3] + grow] : [part.aabb[0] - grow, part.aabb[1], part.aabb[2] + grow, part.aabb[3]];
+    return make({ ...part, aabb, y0: part.y1 - depth });
+  });
+  return changed ? { parts, supports: input.supports } : input;
+}
+function supportBondBeam(context, plate) {
+  const { options } = context;
+  const dir = plate.aabb[2] - plate.aabb[0] >= plate.aabb[3] - plate.aabb[1] ? "u" : "v";
+  const line = lineOf(plate.aabb, dir);
+  const width = dir === "u" ? plate.aabb[3] - plate.aabb[1] : plate.aabb[2] - plate.aabb[0];
+  const dist = distancesOf(context);
+  const floor = plate.floor;
+  const props = propsUnder(context, dist, plate.y0, plate.y1, floor);
+  const storey = { floor, below: floor >= 1 ? `slab_${floor}` : void 0, bottom: context.structure.levels[floor] ?? 0 };
+  const spots = [];
+  const near = props.length ? Math.min(...props.map((p) => p.dist)) : pillarDist(context, dist, storey);
+  const held = pillarsFor(line, width, props, spots, near, options, false);
+  const span = beamSpan(line.to - line.from, held).span;
+  if (span > 1.5) {
+    const depth = Math.max(plate.y1 - plate.y0, beamDepthFor(Math.min(span, options.maxSpan), options));
+    plate.y0 = round2(plate.y1 - depth);
+    plate.mass = Math.max(1, Math.round((plate.aabb[2] - plate.aabb[0]) * (plate.aabb[3] - plate.aabb[1]) * depth * densityOf(plate.material)));
+  }
+  for (const spot of spots) {
+    const pillar = addPillar(context, spot, storey.bottom, plate.y0 + PLAN_TOLERANCE, floor, storey.below, plate.id);
+    rest(context, pillar, plate, "rebar");
+  }
+}
+function applySlabPanels(input, structure, options) {
+  const frame = structure.construction.frame;
+  const system = CONSTRUCTION_SYSTEMS.get(structure.construction.system);
+  if (!frame.rebar || !system || system.timber || structure.levels.length > options.maxStoreys) return input;
+  const parts = input.parts.map((p) => ({ ...p }));
+  const slabs = parts.filter((p) => isConcreteSlab(p, frame.slabs));
+  const bonds = parts.filter((p) => isBondBeam(p, frame.beams));
+  if (!slabs.length && !bonds.length) return input;
+  const firstColumn = input.supports.find((s) => /^(column_0_|building_column_)/.test(s.part) && !/^(column_0_|building_column_)/.test(s.on));
+  const context = {
+    structure,
+    options,
+    beamMaterial: frame.beams,
+    pillarMaterial: frame.pillars,
+    joint: system.joints.slab,
+    wallThickness: structure.construction.walls.thickness ?? 0.15,
+    parts,
+    supports: input.supports.slice(),
+    panelsOf: /* @__PURE__ */ new Map(),
+    pillars: 0,
+    groundBase: firstColumn?.on ?? GROUND
+  };
+  const walls = parts.filter((p) => /^wall_/.test(p.id) && (p.role === "wall" || p.role === "partition"));
+  const jobs = [...bonds.map((part) => ({ part, bond: true })), ...slabs.map((part) => ({ part, bond: false }))].sort((a, b) => a.part.y0 - b.part.y0 || Number(b.bond) - Number(a.bond));
+  for (const job of jobs) {
+    if (job.bond) {
+      supportBondBeam(context, job.part);
+      continue;
+    }
+    const slab = job.part;
+    const boxes = walls.filter((w) => w.y0 >= slab.y1 - 0.1 && w.y0 <= slab.y1 + 0.4 || w.y1 >= slab.y0 - 0.4 && w.y1 <= slab.y0 + 0.1 && w.y0 < slab.y0).map((w) => w.aabb);
+    cutSlab(context, slab, boxes);
+  }
+  if (structure.construction.foundation.type === "building") anchorBalconies(context);
+  return { parts: context.parts, supports: context.supports };
+}
+function anchorBalconies(context) {
+  const base = context.panelsOf.get("slab_base");
+  if (!base) return;
+  const decks = context.parts.filter((p) => p.role === "slab" && /^slab_\d+_/.test(p.id) && context.supports.some((s) => s.part === p.id && /^balcony_column_/.test(s.on)));
+  for (const deck of decks) {
+    const pillars = new Set(context.supports.filter((s) => s.part === deck.id && /^balcony_column_/.test(s.on)).map((s) => s.on));
+    context.supports = context.supports.filter((s) => s.part !== deck.id && !pillars.has(s.part) && !pillars.has(s.on));
+    context.parts = context.parts.filter((p) => !pillars.has(p.id));
+    for (const panel of panelsUnder(context, "slab_base", deck.aabb)) rest(context, panel, deck);
+  }
+}
+function slabPanelView(structure, options) {
+  const out = applySlabPanels({ parts: structure.parts, supports: structure.supports }, structure, options);
+  const panels = out.parts.filter((p) => p.slab !== void 0 && p.role === "slab");
+  const ids = new Set(panels.map((p) => p.id));
+  return { panels, replaced: [...new Set(panels.map((p) => p.slab))], supports: out.supports.filter((s) => ids.has(s.part) || ids.has(s.on)) };
+}
+var slabPanelsOf = (structure, options) => slabPanelView(structure, options).panels;
+
+// src/slab-panels/options.ts
+var SLAB_PANEL_DEFAULTS = {
+  maxSpan: 5,
+  minPanel: 1.5,
+  lineCoverage: 0.6,
+  doorGap: 1.3,
+  lineTolerance: 0.2,
+  footprintShare: 0.5,
+  thicknessRatio: 40,
+  floorMinThickness: 0.1,
+  roofMinThickness: 0.08,
+  beamDepthRatio: 10,
+  beamMinDepth: 0.25,
+  beamStep: 0.05,
+  beamWidthRatio: 3,
+  columnSide: 0.2,
+  maxStoreys: 8
+};
+var resolveSlabPanels = (options) => {
+  if (options === false) return void 0;
+  const given = options === true || options === void 0 ? {} : options;
+  const out = { ...SLAB_PANEL_DEFAULTS };
+  for (const key of Object.keys(given)) if (given[key] !== void 0) out[key] = given[key];
+  return out;
+};
+
 // src/wall-detail/index.ts
 import { getAssembly } from "@adatechnology/game-destruction";
 
@@ -2399,12 +2940,12 @@ function splitIntoCourses(wall, openings, spec) {
     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 box2 = (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),
+    aabb: box2(cell),
     y0: cell.y0,
     y1: cell.y1,
     floor: wall.floor,
@@ -2448,7 +2989,7 @@ function splitIntoPanels(wall, openings, style) {
   };
   own.forEach((opening2, k) => {
     addPier(Math.max(cursor, opening2.from));
-    const lintelTop = Math.min(wall.y1, opening2.y1 + LINTEL_DEPTH2);
+    const lintelTop = Math.min(wall.y1, opening2.y1 + Math.max(LINTEL_DEPTH2, style.lintelDepth?.(opening2.to - opening2.from) ?? 0));
     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;
@@ -2496,7 +3037,7 @@ 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) {
+function panelSplits(input, structure, lintelDepth) {
   const { construction } = structure;
   const system = CONSTRUCTION_SYSTEMS.get(construction.system);
   const splits = /* @__PURE__ */ new Map();
@@ -2509,15 +3050,16 @@ function panelSplits(input, structure) {
       lintelMaterial: system.timber ? construction.frame.timber : "concrete",
       ...system.timber ? {} : { lintelAssembly: "reinforced_concrete" },
       lintelJoint: system.joints.beam,
-      wallJoint: system.joints.wall
+      wallJoint: system.joints.wall,
+      ...lintelDepth && !system.timber ? { lintelDepth } : {}
     });
     if (split.pieces.length > 1) splits.set(part.id, split);
   }
   return splits;
 }
-function applyPanels(input, structure, detail) {
+function applyPanels(input, structure, detail, lintelDepth) {
   if (detail === "coarse") return input;
-  return applySplits(input, panelSplits(input, structure));
+  return applySplits(input, panelSplits(input, structure, lintelDepth));
 }
 function applyUnits(input, structure) {
   const splits = /* @__PURE__ */ new Map();
@@ -2534,7 +3076,7 @@ function applyUnits(input, structure) {
     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 along = (box2) => Math.max(box2[2] - box2[0], box2[3] - box2[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));
   }
@@ -2542,6 +3084,11 @@ function applyUnits(input, structure) {
 }
 
 // src/to-destructible-spec.ts
+var RAFT_THICKNESS = 0.25;
+var PILE_AREA = 9;
+var RAFT_MARGIN = 0.15;
+var RAFT_FOUNDATIONS = /* @__PURE__ */ new Set(["raft", "basement", "building"]);
+var REBAR_RATIOS = { beam: 8e-3, slab: 25e-4, roof: 25e-4, stair: 4e-3 };
 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;
@@ -2583,7 +3130,11 @@ function toDestructibleSpec(structure, options = {}) {
   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 resolved = resolveSlabPanels(options.slabPanels ?? true);
+  const slabOptions = resolved && structure.levels.length <= resolved.maxStoreys ? resolved : void 0;
+  const slabbed = slabOptions ? applySlabPanels({ parts: roled, supports: filtered }, structure, slabOptions) : { parts: roled, supports: filtered };
+  const walled = applyPanels(slabbed, structure, detail, slabOptions && structure.construction.frame.rebar ? (span) => beamDepthFor(span, slabOptions) : void 0);
+  const panels = slabOptions && detail !== "coarse" ? deepenBondBeams(walled, structure, slabOptions) : walled;
   const sizing = { safety, redundancy, safetyOthers };
   const sized = { ...panels, capacities: options.sized === false ? /* @__PURE__ */ new Map() : sizeCapacities(panels.parts, panels.supports, sizing) };
   const { parts, supports, capacities } = detail === "units" ? applyUnits(sized, structure) : sized;
@@ -2595,8 +3146,60 @@ function toDestructibleSpec(structure, options = {}) {
   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"] };
+  const infill = new Set(portico && slabOptions ? kept.filter((part) => part.role === "wall").map((part) => part.id) : []);
+  const beams = new Set(parts.filter((part) => part.role === "beam" && (part.beamKind === "bond_beam" || part.slab !== void 0)).map((part) => part.id));
+  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 || beams.has(s.part) && infill.has(s.on) ? false : "a_on_b" }));
+  const spec = { name: options.name ?? "house", parts: specs, joints, tags: ["structure", "house"] };
+  return onSoil(withRebar(spec, structure, options, portico, slabOptions !== void 0), structure, options);
+}
+function withRebar(spec, structure, options, portico, panelled) {
+  const { redundancy = 0.97, safetyOthers = 0.45 } = options;
+  const rebar = options.rebar ?? panelled;
+  if (!rebar || !structure.construction.frame.rebar) return spec;
+  const ratios = { ...REBAR_RATIOS, ...rebar === true ? {} : rebar };
+  for (const part of spec.parts) {
+    const role = part.structure?.role;
+    if (!role || !(role in ratios) || part.structure.rebar || !MATERIALS.find((m) => m.id === part.material)?.strength?.tensileMPa) continue;
+    part.structure = { ...part.structure, rebar: { ratio: ratios[role] } };
+  }
+  if (options.sized === false) return spec;
+  return sizeRebar(spec, { safety: safetyOthers, redundancy, redundancyRoles: portico ? ["column"] : ["column", "wall"] });
+}
+function onSoil(spec, structure, options) {
+  if (options.soil === void 0) return spec;
+  const out = { ...spec, soil: options.soil };
+  const type = options.foundation ?? structure.construction.foundation.type;
+  const ground = out.parts.findIndex((p) => p.id === GROUND);
+  if (ground < 0 || !RAFT_FOUNDATIONS.has(type) && !options.piles) return out;
+  const house = out.parts.filter((p) => p.id !== GROUND);
+  const onGround = new Set((out.joints ?? []).filter((j) => j.b === GROUND).map((j) => j.a));
+  const footprint = house.filter((p) => onGround.has(p.id));
+  const half = (p, k) => p.shape.kind === "box" ? p.shape.size[k] / 2 : p.shape.kind === "cylinder" ? k === 1 ? p.shape.height / 2 : p.shape.radius : p.shape.radius;
+  const under = footprint.length ? footprint : house;
+  const x0 = Math.min(...under.map((p) => p.position[0] - half(p, 0))) - RAFT_MARGIN, x1 = Math.max(...under.map((p) => p.position[0] + half(p, 0))) + RAFT_MARGIN;
+  const z0 = Math.min(...under.map((p) => p.position[2] - half(p, 2))) - RAFT_MARGIN, z1 = Math.max(...under.map((p) => p.position[2] + half(p, 2))) + RAFT_MARGIN;
+  const raft2 = {
+    id: GROUND,
+    material: "concrete",
+    shape: { kind: "box", size: [x1 - x0, RAFT_THICKNESS, z1 - z0] },
+    position: [(x0 + x1) / 2, -RAFT_THICKNESS / 2, (z0 + z1) / 2],
+    structure: { role: "foundation" },
+    tags: ["raft"]
+  };
+  if (options.piles) {
+    const given = options.piles === true ? {} : options.piles;
+    const count = given.count ?? Math.max(4, Math.ceil((x1 - x0) * (z1 - z0) / PILE_AREA));
+    const diameter = given.diameter ?? 0.4;
+    const method = given.method ?? "bored";
+    const materials = new Map(MATERIALS.map((m) => [m.id, m]));
+    const mass = [...house, raft2].reduce((sum, p) => sum + (p.mass ?? partMass(p, materials.get(p.material))), 0);
+    const soils = new Map(SOILS.map((d) => [d.id, d]));
+    for (const d of options.soils ?? []) soils.set(d.id, d);
+    const length = given.length ?? pileLength(profileOf(options.soil), { load: mass * GRAVITY / count, diameter, top: RAFT_THICKNESS, method, soils });
+    raft2.structure = { role: "foundation", pile: { length, diameter, count, method } };
+  }
+  out.parts = out.parts.map((p, i) => i === ground ? raft2 : p);
+  return out;
 }
 
 // src/wall-specimen.ts
@@ -2629,30 +3232,767 @@ function buildWallSpecimen(options) {
   return toDestructibleSpec(structure, { wallDetail: detail, sized: false, terrainMargin: 0.6, name: `wall_${assembly}` });
 }
 
+// src/tower.ts
+import { MATERIALS as MATERIALS2, buildFrame, partMass as partMass2, sizeStructure } from "@adatechnology/game-destruction";
+var slabId = (g, f) => f === g.floors - 1 && g.roof ? "roof" : `slab_${f}`;
+var storeyBase = (g, f) => f * (g.height + g.slab);
+var slabHalf = (g) => [(g.spanX + g.columnSize + 0.2) / 2, (g.spanZ + g.columnSize + 0.2) / 2];
+var box = (size) => ({ kind: "box", size });
+var rests = (joints, a, b, kind, bears = "a_on_b") => joints.push({ id: `${a}~${b}`, a, b, kind, bears });
+var CORE_DEFAULTS = {
+  wallThickness: 0.35,
+  innerThickness: 0.2,
+  elevators: 2,
+  shaft: 2.2,
+  shaftDepth: 2.4,
+  stairWidth: 2.6,
+  stairLength: 4.8,
+  material: "concrete",
+  rebar: { spacing: 0.15, diameter: 0.0125 },
+  matThickness: 1.2
+};
+var coreSize = (o = {}) => {
+  const c = { ...CORE_DEFAULTS, ...o };
+  const shafts = c.elevators * c.shaft + Math.max(0, c.elevators - 1) * c.innerThickness;
+  return [2 * c.wallThickness + c.stairWidth + c.innerThickness + c.shaftDepth, 2 * c.wallThickness + Math.max(c.stairLength, shafts)];
+};
+function addCore(spec, g, options = {}) {
+  const c = { ...CORE_DEFAULTS, ...options, rebar: { ...CORE_DEFAULTS.rebar, ...options.rebar } };
+  const [cx, cz] = options.center ?? [0, 0];
+  const [W, L] = coreSize(options);
+  const t = c.wallThickness, ti = c.innerThickness;
+  const x0 = cx - W / 2, z0 = cz - L / 2;
+  const parts = [...spec.parts];
+  const joints = [...spec.joints ?? []];
+  const reinforcement = { material: "steel", spacing: c.rebar.spacing, diameter: c.rebar.diameter };
+  const raft2 = parts.find((p) => p.id === "raft");
+  let base = raft2?.id;
+  if (!base) {
+    base = "core_mat";
+    parts.push({ id: base, material: c.material, shape: box([W + 1, c.matThickness, L + 1]), position: [cx, -c.matThickness / 2, cz], structure: { role: "foundation" }, anchored: true });
+  }
+  const innerX = x0 + t + c.stairWidth + ti / 2;
+  for (let f = 0; f < g.floors; f++) {
+    const yb = storeyBase(g, f), H = g.height;
+    const wall = (name, size, pos) => {
+      const id = `core_${f}_${name}`;
+      parts.push({ id, material: c.material, shape: box(size), position: [pos[0], yb + H / 2, pos[1]], structure: { role: "wall" }, reinforcement, tags: ["core"] });
+      rests(joints, id, f === 0 ? base : `core_${f - 1}_${name}`, "rebar");
+      return id;
+    };
+    const tube = [
+      wall("w", [t, H, L], [x0 + t / 2, cz]),
+      wall("e", [t, H, L], [x0 + W - t / 2, cz]),
+      wall("n", [W - 2 * t, H, t], [cx, z0 + L - t / 2]),
+      wall("s", [W - 2 * t, H, t], [cx, z0 + t / 2])
+    ];
+    wall("stair", [ti, H, L - 2 * t], [innerX, cz]);
+    for (let k = 1; k < c.elevators; k++) {
+      wall(`shaft_${k}`, [c.shaftDepth, H, ti], [innerX + ti / 2 + c.shaftDepth / 2, z0 + t + k * c.shaft + (k - 1) * ti + ti / 2]);
+    }
+    for (const w of tube) rests(joints, slabId(g, f), w, "rebar");
+    const rise = (H + g.slab) / 2;
+    const flightWidth = (c.stairWidth - 0.2) / 2;
+    const landing = 1.2;
+    const run = c.stairLength - 2 * landing;
+    const angle = Math.atan2(rise, run);
+    const length = Math.hypot(rise, run);
+    const sx = x0 + t;
+    const landingId = `landing_${f}`;
+    parts.push({ id: landingId, material: c.material, shape: box([c.stairWidth, 0.15, landing]), position: [sx + c.stairWidth / 2, yb + rise - 0.075, z0 + t + c.stairLength - landing / 2], structure: { role: "stair" }, tags: ["stair"] });
+    rests(joints, landingId, `core_${f}_w`, "rebar");
+    rests(joints, landingId, `core_${f}_stair`, "rebar");
+    const zMid = z0 + t + landing + run / 2;
+    for (const [k, side] of [["a", 0], ["b", 1]]) {
+      const id = `stair_${f}_${k}`;
+      const up = side === 0 ? 1 : -1;
+      parts.push({
+        id,
+        material: c.material,
+        shape: box([flightWidth, 0.15, length]),
+        position: [sx + flightWidth / 2 + side * (flightWidth + 0.2), yb + rise / 2 + side * rise, zMid],
+        rotation: [up * angle * -1, 0, 0],
+        structure: { role: "stair" },
+        tags: ["stair"]
+      });
+      rests(joints, id, landingId, "rebar");
+      rests(joints, id, side === 0 ? `core_${f}_w` : `core_${f}_stair`, "rebar");
+    }
+  }
+  for (let k = 0; k < c.elevators; k++) {
+    const id = `elevator_${k}`;
+    parts.push({
+      id,
+      material: "steel",
+      shape: box([c.shaftDepth - 0.6, 2.3, c.shaft - 0.6]),
+      position: [innerX + ti / 2 + c.shaftDepth / 2, 1.15 + 0.05, z0 + t + k * (c.shaft + ti) + c.shaft / 2],
+      fill: 0.03,
+      mass: 1500,
+      tags: ["elevator_car"]
+    });
+    rests(joints, id, base, "resting", false);
+  }
+  return { ...spec, parts, joints };
+}
+var CURTAIN_DEFAULTS = { panel: 1.5, material: "glass", thickness: 0.012, frameKgM2: 10, shard: 0.6, offset: 0.1 };
+function addCurtainWall(spec, g, options = {}) {
+  const c = { ...CURTAIN_DEFAULTS, ...options };
+  const parts = [...spec.parts];
+  const joints = [...spec.joints ?? []];
+  const [hx, hz] = slabHalf(g);
+  const h = g.height + g.slab;
+  const sides = [
+    { name: "n", along: 0, length: 2 * hx, fixed: hz + c.offset, axis: 2 },
+    { name: "s", along: 0, length: 2 * hx, fixed: -hz - c.offset, axis: 2 },
+    { name: "e", along: 2, length: 2 * hz, fixed: hx + c.offset, axis: 0 },
+    { name: "w", along: 2, length: 2 * hz, fixed: -hx - c.offset, axis: 0 }
+  ];
+  for (let f = 0; f < g.floors; f++) {
+    if (c.skip?.(f)) continue;
+    const yb = storeyBase(g, f);
+    for (const s of sides) {
+      const n = Math.max(1, Math.round(s.length / c.panel));
+      const w = s.length / n;
+      for (let k = 0; k < n; k++) {
+        const id = `glass_${f}_${s.name}_${k}`;
+        const at2 = -s.length / 2 + (k + 0.5) * w;
+        const size = s.axis === 2 ? [w - 0.01, h - 0.01, c.thickness] : [c.thickness, h - 0.01, w - 0.01];
+        const position = s.axis === 2 ? [at2, yb + h / 2, s.fixed] : [s.fixed, yb + h / 2, at2];
+        parts.push({
+          id,
+          material: c.material,
+          shape: box(size),
+          position,
+          mass: (2500 * c.thickness + c.frameKgM2) * w * h,
+          thickness: c.thickness,
+          units: { size: [c.shard, c.shard, c.thickness], bond: "stack", mortar: "plastic" },
+          tags: ["curtain_wall", "glass"]
+        });
+        rests(joints, id, slabId(g, f), "bolt", false);
+      }
+    }
+  }
+  return { ...spec, parts, joints };
+}
+var PUNCHED_DEFAULTS = { material: "brick", thickness: 0.2, window: 0.6, sill: 0.9, head: 2.4, glass: "glass", glassThickness: 0.012 };
+function addPunchedFacade(spec, g, options = {}) {
+  const c = { ...PUNCHED_DEFAULTS, ...options };
+  const parts = [...spec.parts];
+  const joints = [...spec.joints ?? []];
+  const nx = Math.max(2, g.columnsX ?? 3), nz = Math.max(2, g.columnsZ ?? 4);
+  const xs = Array.from({ length: nx }, (_, i) => -g.spanX / 2 + i * g.spanX / (nx - 1));
+  const zs = Array.from({ length: nz }, (_, j) => -g.spanZ / 2 + j * g.spanZ / (nz - 1));
+  const beamUnder = g.beamHeight ?? TOWER_DEFAULTS.beamHeight;
+  for (let f = 0; f < g.floors; f++) {
+    if (c.skip?.(f)) continue;
+    const yb = storeyBase(g, f);
+    const room = g.height - beamUnder;
+    const head = Math.min(c.head, room - 0.3), sill = Math.min(c.sill, head - 0.6);
+    const wall = (id, size, position, on) => {
+      parts.push({ id, material: c.material, shape: box(size), position, structure: { role: "partition" }, tags: ["infill"] });
+      for (const o of on) rests(joints, id, o, "mortar");
+    };
+    const bay = (side, k, along, centre, fixed, length, c1, c2) => {
+      const clear = length - g.columnSize;
+      const win = clear * c.window;
+      const pier = (clear - win) / 2;
+      const at2 = (u) => along === 0 ? [u, 0, fixed] : [fixed, 0, u];
+      const size = (u, h) => along === 0 ? [u, h, c.thickness] : [c.thickness, h, u];
+      const put = (name, u, h, y, centreU, on) => {
+        const p = at2(centreU);
+        wall(`infill_${f}_${side}_${k}_${name}`, size(u, h), [p[0], y, p[2]], on);
+      };
+      const id = (name) => `infill_${f}_${side}_${k}_${name}`;
+      put("sill", clear, sill, yb + sill / 2, centre, [c1, c2]);
+      put("pl", pier, head - sill, yb + sill + (head - sill) / 2, centre - clear / 2 + pier / 2, [c1, id("sill")]);
+      put("pr", pier, head - sill, yb + sill + (head - sill) / 2, centre + clear / 2 - pier / 2, [c2, id("sill")]);
+      put("head", clear, room - head, yb + head + (room - head) / 2, centre, [c1, c2]);
+      const gp = at2(centre);
+      const gid = `glass_${f}_${side}_${k}`;
+      parts.push({
+        id: gid,
+        material: c.glass,
+        shape: box(size(win - 0.01, head - sill)),
+        position: [gp[0], yb + sill + (head - sill) / 2, gp[2]],
+        thickness: c.glassThickness,
+        units: { size: [0.6, 0.6, c.glassThickness], bond: "stack", mortar: "plastic" },
+        tags: ["window", "glass"]
+      });
+      rests(joints, gid, id("sill"), "glue", false);
+    };
+    for (const [side, j] of [["s", 0], ["n", nz - 1]]) {
+      for (let i = 0; i < nx - 1; i++) bay(side, i, 0, (xs[i] + xs[i + 1]) / 2, zs[j], xs[i + 1] - xs[i], `column_${f}_${i}_${j}`, `column_${f}_${i + 1}_${j}`);
+    }
+    for (const [side, i] of [["w", 0], ["e", nx - 1]]) {
+      for (let j = 0; j < nz - 1; j++) bay(side, j, 2, (zs[j] + zs[j + 1]) / 2, xs[i], zs[j + 1] - zs[j], `column_${f}_${i}_${j}`, `column_${f}_${i}_${j + 1}`);
+    }
+  }
+  return { ...spec, parts, joints };
+}
+var FLAT_ROOF_DEFAULTS = { slope: 0.01, screedMin: 0.02, screedDensity: 2e3, membrane: "rubber", membraneThickness: 15e-4, water: 5e-3, areaPerDrain: 150 };
+function addFlatRoof2(spec, g, options = {}) {
+  const c = { ...FLAT_ROOF_DEFAULTS, ...options };
+  const parts = [...spec.parts];
+  const joints = [...spec.joints ?? []];
+  const top = slabId(g, g.floors - 1);
+  const slab = parts.find((p) => p.id === top);
+  if (!slab || slab.shape.kind !== "box") return spec;
+  const [sx, sy, sz] = slab.shape.size;
+  const area = sx * sz;
+  const longX = sx >= sz;
+  const count = c.drains ?? Math.max(2, Math.ceil(area / c.areaPerDrain));
+  const long = longX ? sx : sz;
+  const spacing = long / count;
+  const run = Math.hypot(spacing / 2, (longX ? sz : sx) / 2);
+  const screed = c.screedMin + c.slope * run / 2;
+  const y = slab.position[1] + sy / 2;
+  parts.push({
+    id: "roof_screed",
+    material: "concrete",
+    shape: box([sx, screed, sz]),
+    position: [slab.position[0], y + screed / 2, slab.position[2]],
+    mass: c.screedDensity * screed * area,
+    structure: { role: "partition" },
+    tags: ["roof_screed"]
+  });
+  rests(joints, "roof_screed", top, "mortar");
+  const my = y + screed + c.membraneThickness / 2;
+  parts.push({
+    id: "roof_membrane",
+    material: c.membrane,
+    shape: box([sx, c.membraneThickness, sz]),
+    position: [slab.position[0], my, slab.position[2]],
+    thickness: c.membraneThickness,
+    structure: { role: "partition" },
+    contains: { fluid: "water", liters: c.water * area * 1e3, outflow: [0, -1, 0] },
+    tags: ["roof_membrane", "waterproofing"]
+  });
+  rests(joints, "roof_membrane", top, "glue");
+  for (let k = 0; k < count; k++) {
+    const at2 = -long / 2 + (k + 0.5) * spacing;
+    const id = `roof_drain_${k}`;
+    parts.push({
+      id,
+      material: "plastic",
+      shape: { kind: "cylinder", radius: 0.05, height: 0.1 },
+      position: longX ? [slab.position[0] + at2, my, slab.position[2]] : [slab.position[0], my, slab.position[2] + at2],
+      fill: 0.2,
+      tags: ["drain"]
+    });
+    rests(joints, id, top, "glue", false);
+  }
+  return { ...spec, parts, joints };
+}
+var MECHANICAL_DEFAULTS = { tankMaterial: "plastic", tankWall: 0.01, machineMass: 2500, suspendedMass: 4500, occupants: 16, litersPerPerson: 200, storedFraction: 0.4, fireReserve: 6e3, chillers: 2, chillerMass: 3500 };
+var towerWater = (storeys, o = {}) => Math.round((o.occupants ?? MECHANICAL_DEFAULTS.occupants) * MECHANICAL_DEFAULTS.litersPerPerson * MECHANICAL_DEFAULTS.storedFraction * storeys + (o.fireReserve ?? MECHANICAL_DEFAULTS.fireReserve));
+function addMechanicalFloor(spec, g, options = {}) {
+  const c = { ...MECHANICAL_DEFAULTS, ...options };
+  if (g.floors < 2) return spec;
+  const level = options.floor ?? g.floors - 1;
+  if (level < 1 || level > g.floors - 1) return spec;
+  const sfx = level === g.floors - 1 ? "" : `_${level}`;
+  const parts = [...spec.parts];
+  const joints = [...spec.joints ?? []];
+  const floor = `slab_${level - 1}`;
+  const y = storeyBase(g, level);
+  const shafts = options.shafts ?? [];
+  const put = (id, material, size, at2, mass, extra = {}) => {
+    parts.push({ id: id + sfx, material, shape: box(size), position: [at2[0], y + size[1] / 2, at2[1]], mass, fill: 0.2, structure: { role: "partition" }, tags: ["mechanical"], ...extra });
+    rests(joints, id + sfx, floor, "bolt");
+  };
+  shafts.forEach((at2, k) => put(`machine_${k}`, "steel", [1.2, 1, 0.8], at2, c.machineMass + c.suspendedMass, { tags: ["mechanical", "elevator_machine"] }));
+  const liters = options.waterLiters ?? towerWater(level, options);
+  const depth = 2;
+  const side = Math.sqrt(liters / 1e3 / depth);
+  const [hx] = slabHalf(g);
+  const tankAt = options.tankAt ?? [-hx / 2, 0];
+  const shell = 4 * side * depth + 2 * side * side;
+  put("water_tank", c.tankMaterial, [side, depth, side], tankAt, liters + 1100 * c.tankWall * shell, {
+    fill: shell * c.tankWall / (side * side * depth),
+    thickness: c.tankWall,
+    contains: { fluid: "water", liters },
+    tags: ["mechanical", "water_tank"]
+  });
+  for (let k = 0; k < c.chillers; k++) put(`chiller_${k}`, "steel", [3, 2, 1.5], [-hx + 2 + k * 3.5, -(slabHalf(g)[1] - 2)], c.chillerMass, { tags: ["mechanical", "chiller"] });
+  return { ...spec, parts, joints };
+}
+var DAMPER_DEFAULTS = { ratio: 0.01, modalShare: 0.25, material: "steel", maxHeight: 2.5 };
+var damperMass = (spec, o = {}) => {
+  const byId = new Map(MATERIALS2.map((m) => [m.id, m]));
+  let total = 0;
+  for (const p of spec.parts) {
+    const m = byId.get(p.material);
+    if (!m || p.structure?.role === "foundation" || p.damper) continue;
+    total += partMass2(p, m);
+  }
+  return total * (o.modalShare ?? DAMPER_DEFAULTS.modalShare) * (o.ratio ?? DAMPER_DEFAULTS.ratio);
+};
+function addTunedMassDamper(spec, g, options = {}) {
+  const c = { ...DAMPER_DEFAULTS, ...options };
+  if (g.floors < 2) return spec;
+  const mat = MATERIALS2.find((m) => m.id === c.material);
+  if (!mat) throw new Error(`unknown material "${c.material}" for the damper`);
+  const mass = options.mass ?? damperMass(spec, c);
+  const volume = mass / mat.density;
+  const height = Math.min(c.maxHeight, Math.cbrt(volume));
+  const side = Math.sqrt(volume / height);
+  const column = (span, n, want) => {
+    const k = Math.max(2, n ?? 0) - 1;
+    return n === void 0 ? want : Math.round((want + span / 2) / (span / k)) * (span / k) - span / 2;
+  };
+  const colZ = column(g.spanZ, g.columnsZ, g.spanZ * 0.35);
+  const at2 = options.at ?? [column(g.spanX, g.columnsX, 0), colZ - Math.sign(colZ || 1) * (g.columnSize / 2 + 0.1)];
+  const y = storeyBase(g, g.floors - 1);
+  const floor = `slab_${g.floors - 2}`;
+  const part = {
+    id: "damper",
+    material: c.material,
+    shape: box([side, height, side]),
+    position: [at2[0], y + height / 2, at2[1]],
+    mass,
+    structure: { role: "partition" },
+    tags: ["mechanical", "tuned_mass_damper"],
+    damper: { ...c.frequency !== void 0 ? { frequency: c.frequency } : {}, ...c.damping !== void 0 ? { damping: c.damping } : {} }
+  };
+  const joints = [...spec.joints ?? []];
+  rests(joints, part.id, floor, "bolt");
+  return { ...spec, parts: [...spec.parts, part], joints };
+}
+var mechanicalStoreys = (floors, every) => {
+  if (!every || every < 2) return [];
+  const out = [];
+  for (let k = every; k < floors - 1; k += every) if (floors - 1 - k >= every / 2) out.push(k);
+  return out;
+};
+var windExposureOf = (w) => {
+  const out = {};
+  if (w.terrain !== void 0) out.terrain = w.terrain;
+  if (w.class !== void 0) out.class = w.class;
+  if (w.topography !== void 0) out.topography = w.topography;
+  if (w.statistical !== void 0) out.statistical = w.statistical;
+  if (w.drag !== void 0) out.drag = w.drag;
+  if (w.damping !== void 0) out.damping = w.damping;
+  return out;
+};
+var TOWER_DEFAULTS = {
+  spanX: 16,
+  spanZ: 24,
+  columnsX: 3,
+  columnsZ: 4,
+  floors: 12,
+  height: 3,
+  columnSize: 0.6,
+  beamHeight: 0.6,
+  slabThickness: 0.2,
+  columnCage: { material: "steel", spacing: 0.15, diameter: 0.02 }
+};
+function buildTower(options = {}) {
+  const { core, facade, punched, flatRoof, mechanical, damper, wind, sizing, ...frame } = options;
+  const f = { ...TOWER_DEFAULTS, ...frame, columnCage: { ...TOWER_DEFAULTS.columnCage, ...frame.columnCage } };
+  const g = { floors: f.floors, height: f.height, slab: f.slabThickness, spanX: f.spanX, spanZ: f.spanZ, columnSize: f.columnSize, columnsX: f.columnsX, columnsZ: f.columnsZ, beamHeight: f.beamHeight, roof: true };
+  const { every, ...mech } = mechanical || {};
+  const relays = mechanical === false ? [] : mechanicalStoreys(f.floors, every);
+  const noGlass = (fl) => mechanical !== false && (fl === g.floors - 1 || relays.includes(fl));
+  let spec = buildFrame({ roofThickness: f.slabThickness, ...f, roof: true, continuousColumns: true });
+  spec = { ...spec, name: "tower", tags: ["structure", "tower"] };
+  let shafts = [];
+  if (core !== false) {
+    const bayX = f.spanX / (Math.max(2, f.columnsX) - 1);
+    const center = core?.center ?? [bayX / 2, 0];
+    spec = addCore(spec, g, { ...core, center });
+    const c = { ...CORE_DEFAULTS, ...core };
+    const [W, L] = coreSize(core || {});
+    const sx = center[0] - W / 2 + c.wallThickness + c.stairWidth + c.innerThickness + c.shaftDepth / 2;
+    shafts = Array.from({ length: c.elevators }, (_, k) => [sx, center[1] - L / 2 + c.wallThickness + k * (c.shaft + c.innerThickness) + c.shaft / 2]);
+  }
+  if (facade !== false && !punched) spec = addCurtainWall(spec, g, { skip: noGlass, ...facade });
+  if (punched) spec = addPunchedFacade(spec, g, { skip: noGlass, ...punched });
+  if (flatRoof !== false) spec = addFlatRoof2(spec, g, flatRoof || {});
+  if (mechanical !== false) {
+    spec = addMechanicalFloor(spec, g, { shafts, ...mech });
+    for (const floor of relays) spec = addMechanicalFloor(spec, g, { ...mech, shafts: [], floor, waterLiters: mech.waterLiters ?? towerWater(every ?? floor, mech) });
+  }
+  if (damper) spec = addTunedMassDamper(spec, g, damper);
+  if (wind) {
+    const exposure = windExposureOf(wind);
+    if (Object.keys(exposure).length) spec = { ...spec, wind: exposure };
+  }
+  if (sizing === false) return spec;
+  return sizeStructure(spec, wind && sizing?.wind === void 0 ? { ...sizing, wind } : sizing ?? {});
+}
+
+// src/skyscraper.ts
+import { GRAVITY as GRAVITY2, MATERIALS as MATERIALS3, SOILS as SOILS2, createDestruction, partMass as partMass3, pileLength as pileLength2, profileOf as profileOf2 } from "@adatechnology/game-destruction";
+var PILE_DEFAULTS = { diameter: 1.2, pitch: 3.5, method: "bored", maxLength: 60 };
+var SKYSCRAPER_MAX_STOREYS = 60;
+var SKYSCRAPER_DEFAULTS = {
+  storeys: 40,
+  range: [20, SKYSCRAPER_MAX_STOREYS],
+  height: 3.6,
+  bay: [12, 12],
+  bays: [3, 3],
+  slenderness: 9,
+  coreRatio: 0.08,
+  facade: "curtain",
+  mechanicalEvery: 20,
+  damperAbove: 150,
+  wind: { speed: 40, terrain: "IV" },
+  soil: { layers: [{ soil: "clay_soft", thickness: 10 }, { soil: "sand_dense" }] },
+  piles: {},
+  superimposed: 450
+};
+var ceilTo2 = (v, step) => Math.ceil(v / step - 1e-9) * step;
+var round23 = (v) => Math.round(v * 100) / 100;
+var COLUMN_KG_M2 = 0.85 * 25e6 / GRAVITY2 * 0.65;
+var COLUMN_SHARE = 0.5;
+var CORE_CLEARANCE = 0.4;
+var WALL_SLENDER = 200;
+var WIND_SIZING_DEFAULTS = { above: 180, maxBay: 20 };
+var sizedCache = /* @__PURE__ */ new Map();
+var driftOf = (layout, wind) => {
+  const w = createDestruction({ wind });
+  return w.state(w.add(buildTower(layout.tower)))?.wind?.drift ?? 0;
+};
+function skyscraperLayout(options = {}, preset = SKYSCRAPER_DEFAULTS) {
+  const raw = rawLayout(options, preset);
+  const o = { ...preset, ...Object.fromEntries(Object.entries(options).filter(([, v]) => v !== void 0)) };
+  const cfg = { ...WIND_SIZING_DEFAULTS, ...typeof o.sizeForWind === "object" ? o.sizeForWind : {} };
+  if (o.sizeForWind === false || !o.wind || o.core === false || raw.total < cfg.above) return raw;
+  const key = JSON.stringify([options, preset]);
+  const hit = sizedCache.get(key);
+  if (hit) return hit;
+  const limit = o.wind.driftLimit ?? 1 / 500;
+  let layout = raw;
+  for (let i = 0; i < 6; i++) {
+    const drift = driftOf(layout, o.wind);
+    const widest = Math.max(...layout.bay);
+    if (drift <= limit || widest >= cfg.maxBay) break;
+    const k = Math.max(1.02, Math.pow(drift / limit, 1 / 3) * 1.02);
+    const bay = layout.bay.map((b) => Math.min(cfg.maxBay, round23(ceilTo2(b * k, 0.5))));
+    layout = rawLayout({ ...options, bay }, preset);
+  }
+  sizedCache.set(key, layout);
+  return layout;
+}
+function rawLayout(options, preset) {
+  const o = { ...preset, ...Object.fromEntries(Object.entries(options).filter(([, v]) => v !== void 0)) };
+  const range = o.range;
+  const storeys = Math.max(range[0], Math.min(range[1], Math.round(o.storeys)));
+  const given = typeof o.bay === "number" ? [o.bay, o.bay] : [o.bay[0], o.bay[1]];
+  const oddZ = (n) => Math.round(n) % 2 === 1 ? Math.round(n) : Math.round(n) + 1;
+  const bays = [Math.max(1, Math.round(o.bays[0])), oddZ(Math.max(1, o.bays[1]))];
+  const slabOf = (b) => Math.max(TOWER_DEFAULTS.slabThickness, round23(ceilTo2(b / 32, 0.05)));
+  let bay = given;
+  for (let i = 0; i < 4 && o.slenderness !== false; i++) {
+    const total2 = storeys * (o.height + (o.slabThickness ?? slabOf(Math.max(...bay))));
+    const narrow = Math.min(bays[0] * bay[0], bays[1] * bay[1]);
+    if (narrow >= total2 / o.slenderness) break;
+    const k = total2 / o.slenderness / narrow;
+    bay = [round23(ceilTo2(bay[0] * k, 0.5)), round23(ceilTo2(bay[1] * k, 0.5))];
+  }
+  const span = [bays[0] * bay[0], bays[1] * bay[1]];
+  const slab = o.slabThickness ?? slabOf(Math.max(...bay));
+  const beamHeight = o.beamHeight ?? Math.max(TOWER_DEFAULTS.beamHeight, round23(ceilTo2(Math.max(...bay) / 14, 0.1)));
+  const pitch = o.height + slab;
+  const total = storeys * pitch;
+  const tributary = bay[0] * bay[1];
+  const load = COLUMN_SHARE * tributary * storeys * (o.superimposed + slab * 2500);
+  const columnSize = o.columnSize ?? Math.max(TOWER_DEFAULTS.columnSize, round23(ceilTo2(Math.sqrt(load / COLUMN_KG_M2), 0.1)));
+  const plate = [round23(span[0] + columnSize + 0.2), round23(span[1] + columnSize + 0.2)];
+  const mech = o.mechanicalEvery === false ? void 0 : o.mechanicalEvery;
+  const relays = o.mechanical === false ? [] : mechanicalStoreys(storeys, o.mechanical === void 0 ? mech : o.mechanical.every ?? mech);
+  const mechanical = o.mechanical === false ? [] : [...relays, storeys - 1];
+  let coreLayout = null;
+  let coreOptions = false;
+  if (o.core !== false) {
+    const given2 = o.core ?? {};
+    const maxWall = Math.floor((o.height / 3 - 0.05) * 20) / 20;
+    const wallThickness = given2.wallThickness ?? Math.max(CORE_DEFAULTS.wallThickness, Math.min(maxWall, round23(ceilTo2(total / WALL_SLENDER, 0.05))));
+    const ti = given2.innerThickness ?? CORE_DEFAULTS.innerThickness;
+    const shaft = given2.shaft ?? CORE_DEFAULTS.shaft;
+    const fit = Math.max(1, Math.floor((bay[1] - 2 * CORE_CLEARANCE - 0.2 - 2 * wallThickness + ti) / (shaft + ti)));
+    const probe = coreSize({ ...given2, wallThickness, elevators: 2 });
+    const wanted = given2.elevators ?? Math.max(2, Math.ceil((o.coreRatio * plate[0] * plate[1] / probe[0] - 2 * wallThickness + ti) / (shaft + ti)));
+    const elevators = Math.max(1, Math.min(wanted, fit));
+    const narrow = coreSize({ ...given2, wallThickness, elevators });
+    const room = bay[0] - columnSize - 2 * CORE_CLEARANCE - narrow[0];
+    const extra = given2.shaftDepth !== void 0 ? 0 : Math.max(0, Math.min(room, o.coreRatio * plate[0] * plate[1] / narrow[1] - narrow[0]));
+    const xs = Array.from({ length: bays[0] + 1 }, (_, i) => -span[0] / 2 + i * bay[0]);
+    const middle = Math.floor(bays[0] / 2);
+    const center = given2.center ?? [bays[0] % 2 === 1 ? (xs[middle] + xs[middle + 1]) / 2 : xs[middle] + bay[0] / 2, 0];
+    const rebar = { spacing: storeys > 50 ? 0.075 : 0.1, ...given2.rebar };
+    coreOptions = { ...given2, wallThickness, elevators, center, rebar, shaftDepth: (given2.shaftDepth ?? CORE_DEFAULTS.shaftDepth) + round23(extra) };
+    const size = coreSize(coreOptions);
+    coreLayout = { center, size, wallThickness, elevators, stairWidth: given2.stairWidth ?? CORE_DEFAULTS.stairWidth, shaftDepth: coreOptions.shaftDepth };
+  }
+  const damperOn = o.damperAbove !== false && total >= o.damperAbove && o.mechanical !== false;
+  const tower = {
+    floors: storeys,
+    height: o.height,
+    spanX: span[0],
+    spanZ: span[1],
+    columnsX: bays[0] + 1,
+    columnsZ: bays[1] + 1,
+    columnSize,
+    beamHeight,
+    slabThickness: slab,
+    roofThickness: round23(slab + 0.1),
+    columnCage: { ...TOWER_DEFAULTS.columnCage },
+    core: coreOptions,
+    facade: o.facade === "curtain" ? o.curtain ?? {} : false,
+    punched: o.facade === "punched" ? o.punchedFacade ?? {} : false,
+    flatRoof: o.flatRoof ?? {},
+    mechanical: o.mechanical === false ? false : { every: o.mechanicalEvery === false ? void 0 : mech, ...o.mechanical },
+    damper: damperOn ? o.damper ?? {} : false,
+    wind: o.wind === false ? false : o.wind,
+    sizing: o.sizing ?? {},
+    raft: true
+  };
+  return {
+    storeys,
+    height: o.height,
+    slab,
+    pitch,
+    total,
+    bay,
+    span,
+    columnsX: bays[0] + 1,
+    columnsZ: bays[1] + 1,
+    columnSize,
+    beamHeight,
+    plate,
+    core: coreLayout,
+    coreRatio: coreLayout ? coreLayout.size[0] * coreLayout.size[1] / (plate[0] * plate[1]) : 0,
+    facade: o.facade,
+    mechanical,
+    damper: damperOn,
+    tower
+  };
+}
+var totalMass = (spec) => {
+  const byId = new Map(MATERIALS3.map((m) => [m.id, m]));
+  return spec.parts.reduce((sum, part) => sum + (part.mass ?? partMass3(part, byId.get(part.material))), 0);
+};
+function pilesFor(spec, soil, design = {}) {
+  const raft2 = spec.parts.find((p) => p.id === "raft");
+  if (!raft2 || raft2.shape.kind !== "box") throw new Error("Piles go under a raft: the spec has none");
+  const d = { ...PILE_DEFAULTS, ...design };
+  const [sx, sy, sz] = raft2.shape.size;
+  const profile = profileOf2(soil);
+  const soils = new Map(SOILS2.map((s) => [s.id, s]));
+  const weight = totalMass(spec) * GRAVITY2;
+  if (design.length !== void 0 || design.count !== void 0) {
+    const count = design.count ?? Math.max(4, Math.ceil(sx * sz / (d.pitch * d.diameter) ** 2));
+    const length = design.length ?? pileLength2(profile, { load: weight / count, diameter: d.diameter, top: sy, method: d.method, maxLength: d.maxLength, soils });
+    return { length, diameter: d.diameter, count, method: d.method };
+  }
+  let pitch = d.pitch;
+  for (; ; ) {
+    const count = Math.max(4, Math.ceil(sx / (pitch * d.diameter)) * Math.ceil(sz / (pitch * d.diameter)));
+    const length = pileLength2(profile, { load: weight / count, diameter: d.diameter, top: sy, method: d.method, maxLength: d.maxLength, soils });
+    if (length < d.maxLength || pitch <= 2.5) return { length, diameter: d.diameter, count, method: d.method };
+    pitch = Math.max(2.5, pitch - 0.25);
+  }
+}
+function buildSkyscraper(options = {}, preset = SKYSCRAPER_DEFAULTS) {
+  const layout = skyscraperLayout(options, preset);
+  const o = { ...SKYSCRAPER_DEFAULTS, ...preset, ...Object.fromEntries(Object.entries(options).filter(([, v]) => v !== void 0)) };
+  const built = buildTower(layout.tower);
+  const spec = { ...built, name: "skyscraper", tags: [...built.tags ?? [], "skyscraper"] };
+  if (o.soil === false) return spec;
+  const parts = spec.parts.map((part) => {
+    if (part.id !== "raft") return part;
+    return o.piles === false ? { ...part, structure: { ...part.structure, role: "foundation" } } : { ...part, structure: { ...part.structure, role: "foundation", pile: pilesFor(spec, o.soil, o.piles) } };
+  });
+  return { ...spec, parts, soil: o.soil };
+}
+
+// src/skyscraper-plan.ts
+var PLATE_DEFAULTS = { corridor: 1.8, lobby: 3, stairWidth: 3.4 };
+var r2 = (v) => Math.round(v * 100) / 100;
+function towerPlate(layout, options = {}) {
+  const o = { ...PLATE_DEFAULTS, ...options };
+  const [w, d] = layout.plate;
+  const core = layout.core;
+  if (!core) throw new Error("A tower plan needs a core (turn the core on)");
+  const t = core.wallThickness;
+  const [W, L] = core.size;
+  const u = w / 2 + core.center[0], v = d / 2 + core.center[1];
+  const rect = [r2(u - W / 2), r2(v - L / 2), r2(u + W / 2), r2(v + L / 2)];
+  const [x0, z0, x1, z1] = rect;
+  const split = r2(Math.min(x1 - 1.8, x0 + Math.max(o.stairWidth, t + core.stairWidth + 0.1)));
+  const stairEnd = r2(z0 + Math.min(L, Math.max(5.4, 2 * t + 4.8)));
+  const merged2 = z1 - stairEnd < 1.6;
+  const stairs = [x0, z0, split, merged2 ? z1 : stairEnd];
+  const service = merged2 ? null : [x0, stairEnd, split, z1];
+  const n = core.elevators;
+  const shafts = Array.from({ length: n }, (_, k) => [split, r2(z0 + k * L / n), x1, r2(z0 + (k + 1) * L / n)]);
+  const lobby = [x1, z0, r2(x1 + o.lobby), z1];
+  const west = [r2(x0 - o.corridor), z0, x0, z1];
+  const south = [0, r2(z0 - o.corridor), w, z0];
+  const north = [0, z1, w, r2(z1 + o.corridor)];
+  const strip = (id, side, r, alongU, circulation) => ({
+    id,
+    side,
+    rect: r,
+    alongU,
+    length: r2(alongU ? r[2] - r[0] : r[3] - r[1]),
+    depth: r2(alongU ? r[3] - r[1] : r[2] - r[0]),
+    circulation
+  });
+  return {
+    w,
+    d,
+    core: rect,
+    stairs,
+    service,
+    shafts,
+    lobby,
+    corridors: { s: south, n: north, w: west },
+    strips: [
+      strip("south", "front", [0, 0, w, south[1]], true, "corridor_s"),
+      strip("north", "back", [0, north[3], w, d], true, "corridor_n"),
+      strip("west", "left", [0, z0, west[0], z1], false, "corridor_w"),
+      strip("east", "right", [lobby[2], z0, w, z1], false, "lobby")
+    ]
+  };
+}
+var planToSpace = (layout, [u, v]) => [r2(u - layout.plate[0] / 2), r2(v - layout.plate[1] / 2)];
+var storeyKinds = (layout) => Array.from({ length: layout.storeys }, (_, f) => f === 0 ? "ground" : layout.mechanical.includes(f) ? "mechanical" : "typical");
+var splitStrip = (strip, count) => {
+  const [u0, v0, u1, v1] = strip.rect;
+  return Array.from({ length: Math.max(1, count) }, (_, k) => {
+    const a = k / Math.max(1, count), b = (k + 1) / Math.max(1, count);
+    return strip.alongU ? [r2(u0 + (u1 - u0) * a), v0, r2(u0 + (u1 - u0) * b), v1] : [u0, r2(v0 + (v1 - v0) * a), u1, r2(v0 + (v1 - v0) * b)];
+  });
+};
+var EDGE = 1e-6;
+function exteriorWindows(id, rect, plate, ceiling, o = {}) {
+  const [u0, v0, u1, v1] = rect;
+  const spacing = o.spacing ?? 3;
+  const out = [];
+  const add = (side, length) => {
+    const n = Math.max(1, Math.round(length / spacing));
+    out.push({ room: id, side, n, width: Math.min(o.width ?? 2.4, length / n * 0.8), y0: o.y0 ?? 0.3, y1: o.y1 ?? r2(ceiling - 0.5) });
+  };
+  if (Math.abs(v0) < EDGE) add("front", u1 - u0);
+  if (Math.abs(v1 - plate.d) < EDGE) add("back", u1 - u0);
+  if (Math.abs(u0) < EDGE) add("left", v1 - v0);
+  if (Math.abs(u1 - plate.w) < EDGE) add("right", v1 - v0);
+  return out;
+}
+var stripDoor = (id, strip, floor, width = 1) => ({ a: id, b: `${strip.circulation}_${floor}`, width, opensTo: id });
+var plantRooms = (strip, { floor }) => {
+  const id = `plant_${floor}_${strip.id}`;
+  return { rooms: [{ id, type: "storage", label: "plant_room", rect: [...strip.rect] }], doors: [stripDoor(id, strip, floor, 1.2)], windows: [] };
+};
+function coreRooms(plate, floor, storeys) {
+  const id = (name) => `${name}_${floor}`;
+  const link = floor < storeys - 1 ? [floor, floor + 1] : [floor - 1, floor];
+  const rooms = [
+    { id: id("stairs"), type: "stairs", label: "stairs", rect: [...plate.stairs], link },
+    ...plate.service ? [{ id: id("service"), type: "storage", label: "service_shaft", rect: [...plate.service] }] : [],
+    ...plate.shafts.map((rect, k) => ({ id: id(`elevator_${k}`), type: "elevator", label: "elevator", rect: [...rect] })),
+    { id: id("lobby"), type: "hall", label: "elevator_lobby", rect: [...plate.lobby] },
+    { id: id("corridor_w"), type: "corridor", label: "corridor", rect: [...plate.corridors.w] },
+    { id: id("corridor_s"), type: "corridor", label: "corridor", rect: [...plate.corridors.s] },
+    { id: id("corridor_n"), type: "corridor", label: "corridor", rect: [...plate.corridors.n] }
+  ];
+  const doors = [
+    { a: id("stairs"), b: id("corridor_w"), width: 1, opensTo: id("corridor_w") },
+    ...plate.service ? [{ a: id("service"), b: id("corridor_w"), width: 0.8, opensTo: id("service") }] : [],
+    ...plate.shafts.map((_, k) => ({ a: id(`elevator_${k}`), b: id("lobby"), width: 1.2, opensTo: id("lobby") }))
+  ];
+  const openPairs = [[id("lobby"), id("corridor_s")], [id("lobby"), id("corridor_n")], [id("corridor_w"), id("corridor_s")], [id("corridor_w"), id("corridor_n")]];
+  return { rooms, doors, openPairs };
+}
+function towerFloors(layout, plan) {
+  const plate = towerPlate(layout, plan);
+  const fillers = { ground: plan.ground ?? plan.typical, typical: plan.typical, mechanical: plan.mechanical ?? plantRooms };
+  return storeyKinds(layout).map((kind, floor) => {
+    const context = { floor, kind, layout, plate, ceiling: layout.pitch };
+    const fills = plate.strips.map((strip) => fillers[kind](strip, context));
+    const core = coreRooms(plate, floor, layout.storeys);
+    return {
+      label: kind === "ground" ? "ground_floor" : kind === "mechanical" ? "mechanical_floor" : "typical_floor",
+      ceiling: layout.pitch,
+      openPairs: core.openPairs,
+      rooms: () => [...core.rooms, ...fills.flatMap((f) => f.rooms)],
+      doors: () => [...core.doors, ...fills.flatMap((f) => f.doors)],
+      windows: () => fills.flatMap((f) => f.windows)
+    };
+  });
+}
+var towerLocales = { en: { labels: en_default.labels }, "pt-BR": { labels: pt_BR_default.labels } };
+
 // src/index.ts
 var version = "0.1.0";
 export {
   CONSTRUCTIONS,
   CONSTRUCTION_SYSTEMS,
+  CORE_DEFAULTS,
+  CURTAIN_DEFAULTS,
+  DAMPER_DEFAULTS,
   DENSITY,
+  FLAT_ROOF_DEFAULTS,
   GROUND,
+  MECHANICAL_DEFAULTS,
+  PILE_AREA,
+  PILE_DEFAULTS,
+  PLATE_DEFAULTS,
+  PUNCHED_DEFAULTS,
+  RAFT_THICKNESS,
+  REBAR_RATIOS,
   ROOF_COVERINGS,
+  SKYSCRAPER_DEFAULTS,
+  SKYSCRAPER_MAX_STOREYS,
+  SLAB_PANEL_DEFAULTS,
+  TOWER_DEFAULTS,
+  addCore,
+  addCurtainWall,
+  addFlatRoof2 as addFlatRoof,
+  addMechanicalFloor,
+  addPunchedFacade,
+  addTunedMassDamper,
+  applySlabPanels,
+  beamDepthFor,
+  beamSpan,
+  buildSkyscraper,
   buildStructure,
+  buildTower,
   buildWallSpecimen,
   campConstruction,
   chaletConstruction,
   constructionOfSystem,
+  coreSize,
+  damperMass,
+  exteriorWindows,
   logCabinConstruction,
   masonryConstruction,
+  mechanicalStoreys,
+  pilesFor,
+  planToSpace,
   planWaterTank,
   register,
   registerConstruction,
   registerConstructionSystem,
   registerRoofCovering,
+  resolveSlabPanels,
   shackConstruction,
+  skyscraperLayout,
+  slabPanelView,
+  slabPanelsOf,
+  splitStrip,
+  storeyKinds,
+  stripDoor,
   structureLayer,
   toDestructibleSpec,
+  towerFloors,
+  towerLocales,
+  towerPlate,
+  towerWater,
   version,
+  windExposureOf,
   woodFrameConstruction
 };
 //# sourceMappingURL=index.js.map