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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anderson Fernandes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/MIGRATION.md

@@ -0,0 +1,94 @@
+# Migration: structure of the Visor de casas 3D (VC3) to `@adatechnology/game-floorplan-structure`
+
+What the team's `PlantasSDK.gerar` returned as `construcao`, `estrutura`, `telhado` and `caixaDagua`, and `Casa3DSDK.specDe`, now live here with English names. With `wallDetail: 'coarse'`
+the output equals the team page in 900 recorded plans (`tests/team-golden-vc3-structure.test.ts`, which translates back with the tables below).
+
+## Result
+
+| VC3 | SDK |
+|---|---|
+| `res.construcao` | `result.construction` (`system`, `walls`, `floor`, `roof`, `frame`, `foundation`) |
+| `res.estrutura` `{ pecas, apoios, niveis, elevacao }` | `result.structure` `{ parts, supports, levels, elevation, framed }` |
+| `res.telhado` | `result.roof` (`shape`, `covering`, `material`, `pitch`, `bearingFloor`, `panes`, `trusses`, `axis`, `ridge`, `eave`, `y0`, `aabb`) |
+| `res.caixaDagua` | `result.waterTank` (`place`, `floor`, `room`, `capacity`, `platform`, `stand`) |
+| extras of the template (`chamine`, `poco`, `sotao`, `tendas`) | `result.structureExtras` (`chimney`, `well`, `attic`, `tents`) |
+| `Casa3DSDK.specDe(est, { vedacao, fs, n1, fsOutros, filtro, projeto })` | `toDestructibleSpec(structure, { portico, safety, redundancy, safetyOthers, filter, sized })` |
+| `Casa3DSDK.cargasProjeto` | `loadsAtRest` (internal; `sizeStructure` of game-destruction agrees except for beams of a framed building) |
+
+## Part
+
+| VC3 | SDK |
+|---|---|
+| `id` `role` `material` `aabb` `y0` `y1` `andar` `massa` | `id` `role` `material` `aabb` `y0` `y1` `floor` `mass` |
+| `pilar`, `viga`, `laje`, `parede_portante`, `parede_vedacao`, `telhado`, `escada`, `caixa_dagua` | `column`, `beam`, `slab`, `wall`, `partition`, `roof`, `stair`, `none` (StructureRole of game-contracts) |
+| `espacamento`, `tipoViga` (`prato`, `cinta`), `degraus`, `porta`, `cobertura`, `capacidade`, `inclinacao`, `barraca`, `forma`, `montantes` | `spacing`, `beamKind` (`plate`, `bond_beam`), `steps`, `door`, `cover`, `liters`, `pitch`, `tent`, `form`, `studs` |
+| support `{ de, sobre, tipo }`, `'chao'` | `{ part, on, joint }`, `'ground'` |
+| joints `mortar`, `rebar`, `bolt`, `resting`, `nail`, `rope` | the same except `rope` is `tie` (JointKind) |
+
+## Part ids
+
+| VC3 | SDK | VC3 | SDK |
+|---|---|---|---|
+| `w<floor>_<n>` | `wall_<floor>_<n>` | `prato_<f>_<n>` | `plate_<f>_<n>` |
+| `pilar_<f>_<n>` | `column_<f>_<n>` | `pilar_predio_<n>` | `building_column_<n>` |
+| `pilar_fund_<j>_<i>` | `footing_pier_<j>_<i>` | `pilar_sacada_<room>` | `balcony_column_<room>` |
+| `viga_<f>_<n>` (barrotes) | `joist_<f>_<n>` | `viga_base_<n>` | `base_beam_<n>` |
+| `viga_teto_<n>` | `ceiling_joist_<n>` | `laje_<f>` | `slab_<f>` |
+| `laje_<f>_<room>` (sacada) | `slab_<f>_<room>` | `laje_base`, `laje_forro`, `laje_topo`, `laje_caixa`, `laje_sotao` | `slab_base`, `slab_ceiling`, `slab_top`, `tank_slab`, `attic_floor` |
+| `fund_radier` | `foundation_raft` | `porao_laje`, `porao_parede_<lado>`, `porao_pilar_<n>`, `escada_porao` | `basement_slab`, `basement_wall_<side>`, `basement_column_<n>`, `basement_stairs` |
+| `piso_varanda_<room>` | `porch_floor_<room>` | `pier_varanda_<room>_<n>`, `poste_varanda_<room>_<n>` | `porch_footing_<room>_<n>`, `porch_post_<room>_<n>` |
+| `viga_varanda_<room>[_e\|_d]` | `porch_beam_<room>[_e\|_d]` | `telhado_varanda_<room>` | `porch_roof_<room>` |
+| `escada_<porta>`, `escada_<de>_<para>` | `steps_<door>`, `stairs_<from>_<to>` | `tesoura[_<room>]_<n>` | `truss[_<room>]_<n>` (`rafter_a_<n>`, `rafter_b_<n>`, `ridge` in `panels`) |
+| `telhado[_<room>]_a\|b\|anexo` | `roof[_<room>]_a\|b\|annex` | `caixa_dagua`, `chamine`, `poco` | `water_tank`, `chimney`, `well` |
+| `pilar_caixa_<n>`, `pilar_cavalete_<n>`, `viga_cavalete_<n>` | `tank_column_<n>`, `trestle_column_<n>`, `trestle_beam_<n>` | `piso_<tenda>`, `lona_<tenda>`, `vareta_<tenda>_<n>`, `estaca_<tenda>_<n>`, `prumo_<f>_<n>_<k>` | `groundsheet_<tent>`, `canvas_<tent>`, `pole_<tent>_<n>`, `peg_<tent>_<n>`, `post_<f>_<n>_<k>` |
+| `chao` (terreno do spec) | `ground` | | |
+
+## Construction, roof and tank
+
+| VC3 | SDK |
+|---|---|
+| `sistema` `alvenaria`, `wood_frame`, `tronco`, `improvisado`, `lona` | `system` `masonry`, `wood_frame`, `log`, `improvised`, `canvas` |
+| `parede` `{ material, interna, revestimento, acabamento, espessura, materiais }` | `walls` `{ material, interior, cladding, finish, thickness, mixed }` |
+| `piso` `{ material, acabamento }` | `floor` `{ material, finish }` |
+| `telhado` `{ material, cobertura, forma, inclinacao, madeiramento, beiral, eixo, apoiaEm }` | `roof` `{ material, covering, shape, pitch, timber, eave, axis, bearingFloor }` |
+| `estrutura` `{ material, pilares, vigas, lajes, madeiramento, armadura }` | `frame` `{ material, pillars, beams, slabs, timber, rebar }` |
+| `fundacao` `{ tipo, material, elevacao, profundidade }`; `sapata_corrida`, `predio`, `radier`, `vazio_sanitario`, `pilotis`, `porao`, `terra` | `foundation` `{ type, material, elevation, depth }`; `strip_footing`, `building`, `raft`, `crawl_space`, `piles`, `basement`, `ground` |
+| coverings `colonial`, `fibrocimento`, `laje`, `asfaltica`, `zinco`, `madeira`, `lona`, `palha` | `colonial`, `fiber_cement`, `slab`, `asphalt`, `zinc`, `wood`, `canvas`, `thatch` |
+| forms `duas_aguas`, `laje`, `tenda` | `gable`, `slab`, `tent` |
+| tank `local` `laje`, `laje_caixa`, `sotao`, `cavalete`; `plataforma` `{ yBase, altura, espessura, yTopo, pilares, escada }` | `place` `slab`, `raised_slab`, `attic`, `trestle`; `platform` `{ baseY, height, thickness, topY, pillars, ladder }` |
+| `tpl.construcao(plano, sem)`, `tpl.extras`, `tpl.caixa`, `tpl.caixaLocal` | `registerConstruction(id, builder)` named by `TemplateDef.construction`, `result.structureExtras`, `TemplateDef.tank`, `TemplateDef.tankLocation` |
+| options `semente` ... | `options.wallDetail` (`coarse`, `panels` default, `units`), `options.construction` |
+
+## Installations (T2.2e)
+
+| VC3 | SDK |
+|---|---|
+| `res.gas`, `res.eletrica`, `res.paineisSolares`, `res.hidraulica` | `result.utilities.gas`, `.electrical`, `.solar`, `.plumbing` |
+| `res.edificacoes`; `res.lote.caminhos` of the outbuilding doors | `result.outbuildings`; `result.lot.paths` (`path_<door>`) |
+| `moveis[i].conteudo` and `conteudoAereo` (`CONTEUDO`, `sorteiaConteudo`) | `result.contents[itemId]` and `result.contents['<id>#overhead']` (`FindStack[]` from `engine.findsFor`; default tables in `utilities/content-tables.ts`) |
+| item `botijao_gas` (13 kg cylinder added by `montarGas`) | item `cooking_gas_cylinder` (category the same), added to `result.items`; `liga` is `link`, `local` `ao_lado`/`nicho_externo`/`sob_bancada` is `placement` `beside`/`external_niche`/`under_counter`, `mangueira` is `hose`, `capacidade_kg` is `capacityKg`, `oculto` is `hidden` |
+| gas `{ tipo: botijao\|encanado, medidor }`; stove `gas`, `botijao`, `gasMedidor` | `{ type: cylinder\|piped, meter }`; stove `gas`, `cylinder`, `gasMeter` |
+| electricity `modo` `rede`\|`gato`\|`offgrid`, `entradaEnergia` `{ poste, ramal, medidor, descida, ramalInterno, gato, ligacao }`, `quadro`, `tomadas`, `interruptores`, `circuitos`, `eletrodutos`, `exposta`, `lampadasExternas`, `fonte` | `mode` `grid`\|`tap`\|`offgrid`, `serviceEntrance` `{ pole, drop, meter, descent, internalRun, tap, connection }`, `panel`, `outlets`, `switches`, `circuits`, `conduits`, `exposed`, `outdoorLamps`, `source` (`solar`\|`lamp`) |
+| `tom<n>`, `int<n>`, `circ_<room>_<floor>`, `ed_<id>`, `ext_<door>`; item `tomada`, `chuveiro` `{ eletrico, potencia_w, tomada }` | `outlet<n>`, `switch<n>`, `circuit_<room>_<floor>`, `conduit_<id>`, `outdoor_<door>`; item `outlet`, `showerHeater` `{ electric, powerW, outlet }` |
+| `tpl.config(op).energia`, `.solar` (cabin, shack) | `TemplateDef.energy(options, w, d)` returning `{ mode, solar }` |
+| solar `{ tipo rack_laje\|telhado, norte, ladoVertente, inclinacao, areaM2, n, paineis, inversor }` | `{ type slab_rack\|roof, north, slopeSide, tilt, areaM2, count, panels, inverter }` |
+| plumbing `{ caixa, capacidade_l, pontos, trechosVisiveis }`, points `torneira`, `chuveiro`, `descarga`, `tanque`, `maquina`, `vazao_lpm`, `trecho`; runs `tr_saida`, `tr_sob_<pt>`, `tr_parede_<room>` | `{ tank, capacityL, points, visibleRuns }`, `tap`, `shower`, `flush`, `tub`, `machine`, `flowLpm`, `run`; `run_outlet`, `run_under_<pt>`, `run_wall_<room>` |
+| outbuilding `{ tipo edicula, uso, paredes, portas, janelas, itens, pe, esp, frente }`, uses `quarto_visita`, `escritorio`, `deposito`, `gourmet`; ids `<id>.p0`, `<id>.j0`, `<id>.j1` | `{ type outbuilding, use, walls, doors, windows, items, ceiling, thickness, front }`, uses `guest_room`, `office`, `storage`, `gourmet`; ids `<id>.d0`, `<id>.w0`, `<id>.w1` |
+| contents by state `protegida`, `abandonada` | `fortified`, `abandoned` rules in `CONTENT_STATES` (`registerContentState`) |
+
+The streams of the installations keep the names of the team (`gas`, `eletrica`, `solar`, `edif:quintal.edicula`), so an old seed draws the same gas, sockets, panels and outbuilding use. The golden
+(`tests/team-golden-vc3-structure.test.ts`, with the ids of the items in `tests/fixtures/team-golden/vc3-item-ids.json`) compares the seven lists in 900 plans.
+
+## New with no team original
+
+`wallDetail` `panels` and `units` and `buildWallSpecimen` (spec 001, T2.2d). Ids of the pieces of a wall: `wall_<f>_<n>_pier_<k>`, `_sill_<k>`, `_lintel_<k>`, `_spandrel_<k>`; of bricks `wall_<f>_<n>_pier_<k>_u<row>_<i>`;
+of logs `wall_<f>_<n>_log<row>_<i>`; of a door lintel `lintel_<door>`; of rafters `rafter_a_<n>`, `rafter_b_<n>` and `ridge`.
+
+## Differences on purpose
+
+- `wallDetail: 'coarse'` is the team's structure. Every other detail also: rafters of each roof side and a `ridge` beam instead of whole trusses (a roof side falls with the wall it rests on, the other stands);
+  the porch roof rests on its posts alone (the tie to the house wall carries nothing: take the posts away and only the porch roof falls); a framed building (apartment, commercial, three storeys or more) carries by
+  its pillars and beams (`portico`).
+- `door.steps` is written by the structure extension on the doors that get steps, as the team wrote `degraus` (not by `buildStructure`, which does not change its input).
+- Ids of wall hashes (`mixed` materials of the shack) use the legacy key `w<floor>_<n>` so old seeds keep their draws.
+- The terrain part of the spec is `ground` (was `chao`) with the tag `terrain`.

package/README.md

@@ -1,3 +1,15 @@
-# Temporary Holding Version
+# @adatechnology/game-floorplan-structure
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Structure pack for `@adatechnology/game-floorplan`: construction systems, the load path of every plan and its `DestructibleSpec`.
+
+```ts
+import { engine } from '@adatechnology/game-floorplan'
+import { register } from '@adatechnology/game-floorplan-structure'
+
+register(engine)
+const plan = engine.generate('townhouse', { seed: 7 })
+plan.structure.parts // the parts that carry load, each with role, material, box, mass
+plan.structure.supports // what each part rests on, down to 'ground'
+```
+
+See `.claude/skills/game-floorplan-structure/SKILL.md` for the API and `MIGRATION.md` for the names the Visor de casas 3D used.

package/dist/index.d.ts

@@ -0,0 +1,480 @@
+import { FloorplanEngine, ViewerLayer } from '@adatechnology/game-floorplan';
+import { MaterialId, JointKind, StructureRole, DestructibleSpec } from '@adatechnology/game-contracts';
+
+interface StructurePackOptions {
+    /** Litres of the tank by template id or style id. */
+    tankCapacities?: Record<string, number>;
+}
+/**
+ * Registers the structure into the engine: `result.construction`, `result.structureExtras`, `result.waterTank`, `result.structure` and `result.roof` of every plan,
+ * and the structure layer of the 2D viewer. Register the content packs first.
+ */
+declare function register(engine: FloorplanEngine, options?: StructurePackOptions): void;
+
+/** Axis-aligned rectangle `[u0, v0, u1, v1]` in the plan (metres). */
+type Rect = [number, number, number, number];
+type ConstructionSystem = 'masonry' | 'wood_frame' | 'log' | 'improvised' | 'canvas';
+type WallDetail = 'coarse' | 'panels' | 'units';
+/** What a structural part is called in a plan: a column is a pillar, `wall` is a bearing wall, `partition` a wall that only closes. */
+type PartRole = Exclude<StructureRole, 'foundation'>;
+declare const GROUND = "ground";
+/** A piece of the structure with its box in the plan, its height range and the mass it weighs. `y` is absolute: the ground floor sits at `foundation.elevation`. */
+interface StructurePart {
+    id: string;
+    role: PartRole;
+    material: MaterialId;
+    aabb: Rect;
+    y0: number;
+    y1: number;
+    floor: number;
+    mass: number;
+    /** Part this one is cut out of (a pier of a wall in `panels` detail). */
+    host?: string;
+    /** Wall assembly of `game-destruction` the part is built from in the destructible spec (layers, units, rebar, breach). */
+    assembly?: string;
+    /** A brick, block or log: the unit of a wall (`units` detail, log courses), not a piece of it. */
+    unit?: true;
+    /** Distance between repeated members (joists, ceiling joists). */
+    spacing?: number;
+    /** `plate` (timber top plate) or `bond_beam` (masonry bond beam). */
+    beamKind?: 'plate' | 'bond_beam';
+    steps?: number;
+    door?: string;
+    /** Slab that is the roof (flat roof). */
+    cover?: boolean;
+    /** Litres a tank holds. */
+    liters?: number;
+    studs?: {
+        spacing: number;
+        section: string;
+    };
+    pitch?: number;
+    tent?: string;
+    form?: string;
+}
+/** `part` rests on `on` (`GROUND` or another part) through `joint`. `bears: false` ties the two without carrying load. */
+interface Support {
+    part: string;
+    on: string;
+    joint: JointKind;
+    bears?: false;
+}
+interface RoofPane {
+    id: string;
+    aabb: Rect;
+    y0: number;
+    y1: number;
+    flat?: true;
+}
+type RoofShape = 'gable' | 'slab' | 'tent';
+interface Roof {
+    shape: RoofShape;
+    covering: string;
+    material: MaterialId;
+    pitch: number;
+    /** Floor the roof rests on. */
+    bearingFloor: number;
+    panes: (RoofPane | string)[];
+    trusses: number;
+    axis?: 'u' | 'v';
+    ridge?: number;
+    eave?: number;
+    y0?: number;
+    aabb?: Rect;
+}
+/** A window in a wall (the doors are gaps between walls: a lintel part bridges them). Heights are absolute. */
+interface Opening {
+    id: string;
+    kind: 'window' | 'door';
+    wall: string;
+    /** Along the wall (u for a wall along u, v for one along v). */
+    from: number;
+    to: number;
+    y0: number;
+    y1: number;
+}
+interface Structure {
+    parts: StructurePart[];
+    supports: Support[];
+    openings: Opening[];
+    /** Absolute height of the floor level of each storey. */
+    levels: number[];
+    elevation: number;
+    roof: Roof;
+    construction: Construction;
+    /** A reinforced concrete frame carries the building (apartments, commercial buildings, three storeys or more); the walls are infill. */
+    framed: boolean;
+}
+interface WallMaterials {
+    material: MaterialId;
+    interior?: MaterialId;
+    cladding?: MaterialId | null;
+    finish?: string;
+    /** Wall assembly of `game-destruction` (default by system, and by finish in masonry). */
+    assembly?: string;
+    thickness: number;
+    studs?: string;
+    /** Materials drawn per wall by a hash of its legacy key (the improvised shack). */
+    mixed?: MaterialId[];
+    [extra: string]: unknown;
+}
+interface Construction {
+    system: ConstructionSystem;
+    walls: WallMaterials;
+    floor: {
+        material: MaterialId;
+        finish: string;
+    };
+    roof: {
+        material: MaterialId;
+        covering: string;
+        shape: RoofShape;
+        pitch: number;
+        timber: MaterialId;
+        eave?: number;
+        axis?: 'u' | 'v';
+        bearingFloor?: number;
+        profile?: string;
+        gables?: string[];
+        fastening?: string;
+    };
+    frame: {
+        material: MaterialId;
+        pillars: MaterialId;
+        beams: MaterialId;
+        slabs: MaterialId;
+        timber: MaterialId;
+        rebar: MaterialId | null;
+    };
+    foundation: {
+        type: FoundationType;
+        material: MaterialId;
+        elevation: number;
+        depth?: number;
+    };
+    guard?: MaterialId;
+    stairs?: MaterialId;
+}
+type FoundationType = 'strip_footing' | 'building' | 'raft' | 'crawl_space' | 'piles' | 'basement' | 'ground';
+interface Chimney {
+    kind: 'fireplace' | 'flue';
+    material: MaterialId;
+    aabb: Rect;
+    flue?: boolean;
+    top?: number;
+    height?: number;
+}
+interface Tent {
+    id: string;
+    kind: string;
+    height: number;
+    aabb: Rect;
+}
+/** What a construction needs besides walls and roof, from the template: a chimney, a well, an attic floor, tents. */
+interface StructureExtras {
+    chimney?: Chimney;
+    well?: {
+        aabb: Rect;
+        height?: number;
+    };
+    attic?: boolean;
+    tents?: Tent[];
+    [extra: string]: unknown;
+}
+interface TankPlatform {
+    aabb: Rect;
+    baseY: number;
+    height: number;
+    thickness: number;
+    topY: number;
+    pillars: {
+        u: number;
+        v: number;
+        side: number;
+    }[];
+    ladder: boolean;
+}
+interface WaterTank {
+    id: 'water_tank';
+    kind: 'water_tank';
+    itemType: string;
+    place: 'slab' | 'attic' | 'raised_slab' | 'trestle' | string;
+    floor: number;
+    room: string;
+    u: number;
+    v: number;
+    y: number;
+    w: number;
+    d: number;
+    h: number;
+    capacity: number;
+    material?: MaterialId;
+    aabb: Rect;
+    platform?: TankPlatform;
+    /** Trestle tank (a stand of its own: rural water). */
+    stand?: {
+        pillars: {
+            u: number;
+            v: number;
+            side: number;
+        }[];
+        material: MaterialId;
+        height: number;
+        baseJoint?: JointKind;
+        joint?: JointKind;
+        tie?: JointKind;
+        braces?: boolean;
+    };
+}
+/** The fields of a generated plan the structure reads. */
+interface StructureSource {
+    floors: {
+        y0: number;
+        ceiling: number;
+    }[];
+    rooms: {
+        id: string;
+        type: string;
+        floor: number;
+        parts: Rect[];
+        ceiling?: number | null;
+    }[];
+    walls: SourceWall[];
+    doors: SourceDoor[];
+    windows?: SourceWindow[];
+    items: {
+        id?: string;
+        type: string;
+        category?: string;
+        floor: number;
+        aabb?: Rect;
+        link?: {
+            from: number;
+            to: number;
+        } | null;
+    }[];
+    facade: {
+        roof?: string;
+        finish?: string;
+        [extra: string]: unknown;
+    };
+    style?: string;
+    template?: string;
+    lot?: unknown;
+    w: number;
+    d: number;
+    floorNumber?: number;
+    waterTank?: WaterTank | null;
+    construction?: Construction;
+    structureExtras?: StructureExtras;
+    [extra: string]: unknown;
+}
+interface SourceWall {
+    floor: number;
+    axis: 'u' | 'v';
+    u0: number;
+    v0: number;
+    u1: number;
+    v1: number;
+    thickness?: number;
+    sides: string[];
+    exterior: boolean;
+    type: string;
+    h?: number;
+    /** Gable wall: the plate does not sit on top of it. */
+    gable?: boolean;
+    structureHeight?: number;
+}
+interface SourceWindow {
+    id: string;
+    floor: number;
+    axis: 'u' | 'v';
+    /** Coordinate of the wall line across its axis. */
+    pos: number;
+    /** Centre along the wall. */
+    at: number;
+    width: number;
+    y0: number;
+    y1: number;
+}
+interface SourceDoor {
+    id: string;
+    floor: number;
+    a: string;
+    b: string;
+    exterior?: boolean;
+    model?: string;
+    type?: string;
+    u: number;
+    v: number;
+    width: number;
+    side?: string;
+    axis: 'u' | 'v';
+    steps?: number;
+}
+interface StructureOptions {
+    construction?: Construction;
+    extras?: StructureExtras;
+    tank?: WaterTank | null;
+    /** The porch roof is carried by its posts alone (the tie to the house wall carries nothing). Default: when the detail is not `coarse`. */
+    porchRoofOnPostsOnly?: boolean;
+    /** Gable roofs as rafters of each side and a ridge beam (a side falls with the wall it rests on) instead of whole trusses. Default: when the detail is not `coarse`. */
+    rafterRoof?: boolean;
+    wallDetail?: WallDetail;
+}
+/** What a construction builder and the tank get to see: the generated plan, its seed and the template. */
+interface PlanContext {
+    result: StructureSource;
+    seed: number | string;
+    /** The template definition (`TemplateDef`) when known: it may carry `tank` and `tankLocation` hooks. */
+    template?: Record<string, unknown>;
+    options?: {
+        floors?: number;
+        [extra: string]: unknown;
+    };
+}
+
+/**
+ * The structure of a generated plan: every part that carries load (foundation, floors, walls, plates and bond beams, pillars, porch posts, trusses,
+ * roof, stairs, tank) with what each rests on. The plan itself is not modified.
+ */
+declare function buildStructure(source: StructureSource, options?: StructureOptions): Structure;
+
+interface DestructibleSpecOptions {
+    /** Fraction of its capacity a pillar or bearing wall uses at rest (default 0.65). */
+    safety?: number;
+    /** After losing any other pillar or bearing wall, the most of its capacity one of them uses (default 0.97: the house holds one loss and falls with two). */
+    redundancy?: number;
+    /** Fraction of capacity beams, slabs, roofs, stairs and partitions use at rest (default 0.45). */
+    safetyOthers?: number;
+    /** Bearing walls close but do not carry: a frame of pillars and beams carries the building. Default: for a framed building unless the detail is `coarse`. */
+    portico?: boolean;
+    /** How finely the walls are split (default `panels`; `coarse` is one part per wall as the Visor de casas 3D builds it). */
+    wallDetail?: WallDetail;
+    /** Name of the spec (default `house`). */
+    name?: string;
+    /** Leaves parts out (and what rests on them is dropped from the joints). */
+    filter?: (part: StructurePart) => boolean;
+    /** `false` keeps the capacity of the material instead of sizing it from the load. */
+    sized?: boolean;
+    /** Metres the anchored terrain slab reaches beyond the parts (default 6). */
+    terrainMargin?: number;
+}
+/**
+ * The structure as a `DestructibleSpec` in the space of the house (x = u, y = height, z = v; the ground is y = 0), one box per part and a terrain slab
+ * that anchors it. Capacities are sized from the loads at rest, as a designer would: a house stands whole, holds the loss of one pillar or bearing wall
+ * and falls with two.
+ */
+declare function toDestructibleSpec(structure: Structure, options?: DestructibleSpecOptions): DestructibleSpec;
+
+interface WallSpecimenOptions {
+    /** Wall assembly of `game-destruction` (`brick_wall_plastered`, `concrete_block_wall`, `reinforced_concrete`, `drywall`, `wood_frame_wall`, `log_wall`, `sheet_metal_shack`...). */
+    assembly: string;
+    /** Width and height in metres (the test area uses 2.4 x 2.1). */
+    w: number;
+    h: number;
+    opening?: 'door' | 'window' | null;
+    /** Default `panels`: piers, lintel with its 0.2 m bearing, sill, plaster and rebar; `units` also lays the bricks, blocks or concrete panels one by one. */
+    detail?: WallDetail;
+}
+/**
+ * A test wall as its assembly builds it, standing on a plinth: in `panels` the piers beside the opening, the lintel over it (reinforced concrete bearing 0.2 m on
+ * the piers; a header in timber walls), the sill under a window and the wall above; with the plaster coat and the rebar of the assembly. The mass is the
+ * assembly's for the whole w x h, whatever the detail.
+ */
+declare function buildWallSpecimen(options: WallSpecimenOptions): DestructibleSpec;
+
+type Rng = () => number;
+interface TankPlanOptions {
+    /** Litres by template id or style id (default: budget 500, mid 1000, mansion 3000, any other 2000). */
+    capacities?: Record<string, number>;
+    /** Where the tank goes; default: on the slab of a flat roof, else on a raised platform (the attic one time in eight). */
+    location?: (source: StructureSource, rng: Rng) => WaterTank['place'];
+    /** A template with its own tank (a trestle for the rural water) answers here instead. */
+    custom?: (source: StructureSource, rng: Rng) => WaterTank | null;
+}
+/**
+ * The water tank of a house: on the roof slab, in the attic, or on a platform that rises out of the roof, never in the yard. Null for a plan without
+ * a lot (an apartment) or a commercial building, and when no room has space.
+ */
+declare function planWaterTank(source: StructureSource, rng: Rng, options?: TankPlanOptions): WaterTank | null;
+
+/** What a wall system is made of and how its parts are tied. Timber systems sit on joists, carry the roof on timber plates and have wooden porch posts. */
+interface ConstructionSystemDef {
+    /** Wall assembly of `game-destruction` (`registerAssembly`) the detailed wall is built from. Empty: no walls (a tent). */
+    walls: string;
+    joints: Record<'wall' | 'slab' | 'beam' | 'column' | 'truss', JointKind>;
+    /** Thickness of the structural floor under each storey (m). */
+    slabThickness: number;
+    /** Height of the top plate or bond beam (m). */
+    plateThickness: number;
+    timber: boolean;
+    /** `rules`: bearing when external, under another wall or beside a porch; `bearing`: every wall (logs); `partition`: none (posts carry the roof). */
+    wallRole: 'rules' | 'bearing' | 'partition';
+    /** Solid fraction of a bearing wall in the structure weight (studs and air). */
+    wallFill: number;
+    studs?: {
+        spacing: number;
+        section: string;
+    };
+}
+declare const CONSTRUCTION_SYSTEMS: Map<string, ConstructionSystemDef>;
+/** Adds or replaces a construction system (`id` is a `ConstructionSystem` or any name a construction refers to). */
+declare function registerConstructionSystem(id: ConstructionSystem | string, def: ConstructionSystemDef): void;
+interface RoofCoveringDef {
+    material: string;
+    /** How the covering is fixed to the trusses. */
+    joint: JointKind;
+}
+declare const ROOF_COVERINGS: Map<string, RoofCoveringDef>;
+declare function registerRoofCovering(id: string, def: RoofCoveringDef): void;
+interface ConstructionBuild {
+    construction: Construction;
+    extras?: StructureExtras;
+}
+type ConstructionBuilder = (context: PlanContext) => ConstructionBuild;
+declare const CONSTRUCTIONS: Map<string, ConstructionBuilder>;
+/** Registers how a template's building is made: `TemplateDef.construction` names it. A template without one gets the masonry default. */
+declare function registerConstruction(id: string, builder: ConstructionBuilder): void;
+
+/** Masonry house of the engine's own templates: brick with plaster, concrete frame, tiles by facade; a unit in a building gets a flat slab roof. */
+declare function masonryConstruction(source: StructureSource): Construction;
+interface WoodFrameOptions {
+    foundation?: 'basement' | 'crawl_space' | 'raft';
+    covering?: string;
+    finish?: string;
+    /** Cladding of the outer face (default soft wood). */
+    cladding?: string;
+}
+/** American wood frame house: 38x89 studs every 40 cm, plaster inside, wood outside, asphalt shingles. */
+declare function woodFrameConstruction(options?: WoodFrameOptions): Construction;
+interface ChaletOptions {
+    covering?: string;
+    finish?: string;
+    piles?: boolean;
+}
+/** Mountain chalet: A-frame roof at 52 degrees with gables front and back, 38x140 studs. */
+declare function chaletConstruction(options?: ChaletOptions): Construction;
+/** Log cabin: every wall is a stack of 26 cm logs, notched at the corners, on stone piles. */
+declare function logCabinConstruction(options?: {
+    covering?: string;
+}): Construction;
+interface ShackOptions {
+    material?: 'wood' | 'zinc' | 'mixed';
+    floor?: 'soil' | 'concrete';
+}
+/** Shack of scrap boards and zinc sheets: timber posts carry the roof, the walls only close. */
+declare function shackConstruction(options?: ShackOptions): Construction;
+/** Camping: canvas over aluminium poles on the ground; there are no walls. */
+declare function campConstruction(): Construction;
+/** The construction a system gets on any plan when the options force it (`options.construction`). */
+declare function constructionOfSystem(system: string, source: StructureSource): Construction | undefined;
+
+declare const structureLayer: ViewerLayer;
+
+/** kg/m3 the plan structure weighs its parts with (the table of the Visor de casas 3D; a material outside it weighs like soft wood). */
+declare const DENSITY: Readonly<Record<string, number>>;
+
+declare const version = "0.1.0";
+
+export { CONSTRUCTIONS, CONSTRUCTION_SYSTEMS, type ChaletOptions, type Chimney, type Construction, type ConstructionBuild, type ConstructionBuilder, type ConstructionSystem, type ConstructionSystemDef, DENSITY, type DestructibleSpecOptions, type FoundationType, GROUND, type Opening, type PartRole, type PlanContext, ROOF_COVERINGS, type Rect, type Roof, type RoofCoveringDef, type RoofPane, type RoofShape, type ShackOptions, type SourceDoor, type SourceWall, type SourceWindow, type Structure, type StructureExtras, type StructureOptions, type StructurePackOptions, type StructurePart, type StructureSource, type Support, type TankPlanOptions, type TankPlatform, type Tent, type WallDetail, type WallMaterials, type WallSpecimenOptions, type WaterTank, type WoodFrameOptions, buildStructure, buildWallSpecimen, campConstruction, chaletConstruction, constructionOfSystem, logCabinConstruction, masonryConstruction, planWaterTank, register, registerConstruction, registerConstructionSystem, registerRoofCovering, shackConstruction, structureLayer, toDestructibleSpec, version, woodFrameConstruction };