@adatechnology/game-floorplan-structure 2.0.2 → 2.1.1

package/dist/index.d.ts

@@ -1,18 +1,8 @@
-import { FloorplanEngine, ViewerLayer, RoomDef, DoorDef, WindowDef, FloorDef, PlanAxis } from '@adatechnology/game-floorplan';
+import { PlanAxis, ResultItem, FindsQuery, FindStack, Plan, FurnitureDef, FloorplanResult, FloorplanEngine, ViewerLayer, RoomDef, DoorDef, WindowDef, FloorDef } from '@adatechnology/game-floorplan';
 export { LotPath } from '@adatechnology/game-floorplan';
 import { MaterialId, JointKind, StructureRole, SoilProfile, PileSpec, DestructibleSpec, WindExposure } from '@adatechnology/game-contracts';
 import { SoilDef, FrameOptions, WindOptions, SizeStructureOptions } from '@adatechnology/game-destruction';
 
-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';
@@ -38,8 +28,10 @@ interface StructurePart {
     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';
+    /** `plate` (timber top plate), `bond_beam` (masonry bond beam) or `ground_beam` (the masonry ground beam, viga baldrame, buried under a ground-floor wall). */
+    beamKind?: 'plate' | 'bond_beam' | 'ground_beam';
+    /** An exterior wall (it carries the bond beam and the pillars of confined masonry). */
+    exterior?: true;
     steps?: number;
     door?: string;
     /** Slab that is the roof (flat roof). */
@@ -111,6 +103,8 @@ interface Structure {
     /** A reinforced concrete frame carries the building (apartments, commercial buildings, three storeys or more); the walls are infill. */
     framed: boolean;
 }
+/** The structure as a `generate` result carries it: the roof goes out apart, in `result.roof`. */
+type PlanStructure = Omit<Structure, 'roof'>;
 interface WallMaterials {
     material: MaterialId;
     interior?: MaterialId;
@@ -329,6 +323,17 @@ interface StructureOptions {
     wallDetail?: WallDetail;
     /** `false`: no roof (a free-standing wall, a garden wall). Default `true`. */
     roof?: boolean;
+    /**
+     * Concrete pillars along the exterior masonry walls besides the corner ones (at the free ends and door jambs, beside the windows, where walls meet and at
+     * most every `spacing` metres, default `WALL_PILLAR_SPACING`). `false`: only the corner pillars. Default `true`.
+     */
+    wallPillars?: boolean | {
+        spacing?: number;
+    };
+    /** A reinforced concrete ground beam (viga baldrame) under each ground-floor wall of a masonry house on strip footings (`GROUND_BEAM_DEPTH` deep). Default `true`. */
+    groundBeams?: boolean;
+    /** The sections the Visor de casas 3D drew below the NBR 6118 minimum (16 cm balcony pillars), for the team's golden only. Default `false`. */
+    visorSections?: boolean;
 }
 /** What a construction builder and the tank get to see: the generated plan, its seed and the template. */
 interface PlanContext {
@@ -342,12 +347,362 @@ interface PlanContext {
     };
 }
 
+/** 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;
+
+type Rng$1 = () => number;
+
+/** A point in the world: `[u, v, y]` (y is the absolute height). */
+type Point3 = [number, number, number];
+/** Something fixed to the inner face of a wall of a room: a socket, a switch, the panel. */
+interface WallFixture {
+    id: string;
+    room: string;
+    floor: number;
+    u: number;
+    v: number;
+    /** Height above the storey floor. */
+    y: number;
+    /** Position along the wall. */
+    c: number;
+    axis: PlanAxis;
+    pos: number;
+    frontU: number;
+    frontV: number;
+}
+interface Outlet extends WallFixture {
+    type: string;
+    voltage: number;
+}
+interface LightSwitch extends WallFixture {
+    door: string;
+    /** On the latch side of the door. */
+    latchSide: boolean;
+    /** Lamp ids it turns on. */
+    controls: string[];
+}
+interface ElectricalPanel extends WallFixture {
+    w: number;
+    h: number;
+    breakers: number;
+}
+interface ElectricMeter {
+    id: string;
+    place: string;
+    u: number;
+    v: number;
+    y: number;
+    side: string;
+    w: number;
+    d: number;
+    h: number;
+}
+/** Pole, drop, meter, descent and the run to the panel; a tap has no meter and a bare connection instead. */
+interface ServiceEntrance {
+    pole: {
+        u: number;
+        v: number;
+        h: number;
+    };
+    drop: Point3[];
+    meter: ElectricMeter | null;
+    descent: Point3[];
+    internalRun: Point3[] | null;
+    tap?: boolean;
+    connection?: {
+        u: number;
+        v: number;
+        y: number;
+    };
+}
+interface Circuit {
+    id: string;
+    room: string;
+    floor: number;
+    outlets: string[];
+    switches: string[];
+    lamps: string[];
+    exposed: boolean;
+    gauge_mm2: number;
+}
+interface Conduit {
+    id: string;
+    circuit: string;
+    from: string;
+    to: string;
+    exposed: boolean;
+    diameter: number;
+    points: Point3[];
+}
+interface OutdoorLamp {
+    id: string;
+    u: number;
+    v: number;
+    y: number;
+    door: string;
+    switch: string | null;
+}
+interface PlumbingPoint {
+    id: string;
+    kind: string;
+    item: string;
+    room: string | null;
+    floor: number;
+    u: number;
+    v: number;
+    y: number;
+    flowLpm: number | undefined;
+    run: string | null;
+}
+interface PlumbingRun {
+    id: string;
+    from: string;
+    /** A point, a room, or `ceiling`. */
+    to: string | null;
+    points: Point3[];
+    diameter: number;
+    exposed: string;
+}
+interface Plumbing {
+    tank: 'water_tank' | null;
+    capacityL: number;
+    points: PlumbingPoint[];
+    visibleRuns: PlumbingRun[];
+}
+interface SolarPanel {
+    id: string;
+    u: number;
+    v: number;
+    w: number;
+    d: number;
+    length: number;
+}
+interface Inverter {
+    id: string;
+    u: number;
+    v: number;
+    y: number;
+    side: string;
+    w: number;
+    d: number;
+    h: number;
+    outdoor: boolean;
+    link: string;
+}
+interface Solar {
+    type: 'slab_rack' | 'roof';
+    orientation: string;
+    north: 'front' | 'back';
+    slopeSide: 'front' | 'back' | null;
+    tilt: number;
+    area: number[];
+    areaM2: number;
+    count: number;
+    floor: number;
+    y: number;
+    panels: SolarPanel[];
+    inverter: Inverter | null;
+}
+/** A door or a window in the wall of an outbuilding. */
+interface OutbuildingOpening {
+    id: string;
+    axis: PlanAxis;
+    pos: number;
+    at: number;
+    u: number;
+    v: number;
+    width: number;
+    side: string;
+    height?: number;
+    exterior?: boolean;
+    y0?: number;
+    y1?: number;
+    /** Swing area of a door. */
+    zone?: Rect;
+}
+interface OutbuildingWall {
+    axis: PlanAxis;
+    u0: number;
+    v0: number;
+    u1: number;
+    v1: number;
+    thickness: number;
+    h: number;
+    side: string;
+}
+interface OutbuildingItem {
+    type: string;
+    category: string;
+    u: number;
+    v: number;
+    w: number;
+    d: number;
+    h: number;
+    ry: number;
+    frontU: number;
+    frontV: number;
+    aabb: Rect;
+}
+interface Outbuilding {
+    id: string;
+    type: 'outbuilding';
+    use: string;
+    floor: number;
+    aabb: Rect;
+    interior: Rect[];
+    ceiling: number;
+    thickness: number;
+    front: [number, number];
+    walls: OutbuildingWall[];
+    doors: OutbuildingOpening[];
+    windows: OutbuildingOpening[];
+    items: OutbuildingItem[];
+}
+
+type EnergyMode = 'grid' | 'tap' | 'offgrid';
+/** What a template says about its energy (a shack taps the grid without a meter, a cabin may run off-grid on solar). */
+interface EnergyConfig {
+    mode: EnergyMode;
+    solar?: boolean;
+}
+interface Electrical {
+    mode: EnergyMode;
+    serviceEntrance: ServiceEntrance | null;
+    panel: ElectricalPanel | null;
+    outlets: Outlet[];
+    switches: LightSwitch[];
+    circuits: Circuit[];
+    conduits: Conduit[];
+    exposed: boolean;
+    outdoorLamps: OutdoorLamp[];
+    source?: 'solar' | 'lamp';
+}
+
+interface GasMeter {
+    id: 'gas.meter';
+    u: number;
+    v: number;
+    y: number;
+    side: string;
+    w: number;
+    d: number;
+    h: number;
+}
+interface Gas {
+    type: 'piped' | 'cylinder';
+    meter: GasMeter | null;
+}
+
+interface Utilities {
+    gas: Gas | null;
+    electrical: Electrical;
+    solar: Solar | null;
+    plumbing: Plumbing;
+}
+interface UtilitiesContext {
+    plan: Plan;
+    items: ResultItem[];
+    stateItems: ResultItem[];
+    tank: WaterTank | null;
+    energy?: EnergyConfig;
+    /** Seeded stream by name: `gas`, `electrical`, `solar`. */
+    rngFor(key: string): Rng$1;
+}
+/** Gas, electricity, solar panels and plumbing of a house, in the order that lets the later ones see the cylinders the first adds to `items`. */
+declare function planUtilities(context: UtilitiesContext): Utilities;
+interface ContentsContext {
+    items: ResultItem[];
+    state: string;
+    place: string;
+    /** Outbreak days and region of the world, passed to the finds provider. */
+    day?: number;
+    region?: string;
+    rngFor(key: string): Rng$1;
+    findsFor(query: FindsQuery): readonly FindStack[];
+}
+/** What every container holds, asked of the registered finds provider: by item id, and `<id>#overhead` for the wall cabinet over a sink. */
+declare function planContents(context: ContentsContext): Record<string, readonly FindStack[]>;
+
+interface OutbuildingContext {
+    plan: Plan;
+    items: ResultItem[];
+    catalog: Record<string, FurnitureDef>;
+    rngFor(key: string): Rng$1;
+}
+/**
+ * The outbuilding at the back of the yard is a small building of its own: walls with a gap for the door, a door of 0.85 m facing the yard, two windows and the
+ * furniture of a drawn use (guest room, office, storage, gourmet space).
+ */
+declare function planOutbuildings(context: OutbuildingContext): Outbuilding[];
+
+/**
+ * A `generate` result once the structure pack is registered: the plan of `game-floorplan` with what the pack's extensions add (the construction and its extras,
+ * the water tank, the structure and its roof, the contents of the furniture, the outbuildings and the utilities).
+ */
+type StructuredResult = FloorplanResult & {
+    construction: ConstructionBuild['construction'];
+    structureExtras: NonNullable<ConstructionBuild['extras']>;
+    waterTank: WaterTank | null;
+    structure: PlanStructure;
+    roof: Roof | null;
+    contents: ReturnType<typeof planContents>;
+    outbuildings: ReturnType<typeof planOutbuildings>;
+    utilities: ReturnType<typeof planUtilities>;
+};
+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;
+
 /**
  * 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;
 
+/** Depth of the sill beam under a window of a masonry wall, metres (a contraverga is usually 10 cm). */
+declare const SILL_BEAM_DEPTH = 0.1;
+
 interface PartsAndSupports {
     parts: StructurePart[];
     supports: Support[];
@@ -413,18 +768,18 @@ declare const beamDepthFor: (span: number, options: SlabPanelOptions, minimum?:
  * The slabs of concrete cut into panels with beams (`SlabPanelOptions`): see `T10-estrutura-real.md` §12. `input` is the structure as
  * `toDestructibleSpec` has it (walls with their roles), and the result has the panels, the beams, the pillars they need and the supports re-pointed.
  */
-declare function applySlabPanels(input: PartsAndSupports, structure: Structure, options: SlabPanelOptions): PartsAndSupports;
+declare function applySlabPanels(input: PartsAndSupports, structure: PlanStructure, options: SlabPanelOptions): PartsAndSupports;
 /**
  * The panels `toDestructibleSpec` makes of the slabs of a structure (named as it names them), for a renderer that draws the floor of each room apart:
  * `panels` (each with `slab`, the id of the slab it was cut from), `replaced` (those slabs, which the spec no longer has) and the `supports` that touch the panels.
  */
-declare function slabPanelView(structure: Structure, options: SlabPanelOptions): {
+declare function slabPanelView(structure: PlanStructure, options: SlabPanelOptions): {
     panels: StructurePart[];
     replaced: string[];
     supports: Support[];
 };
 /** The panels of `slabPanelView`, alone. */
-declare const slabPanelsOf: (structure: Structure, options: SlabPanelOptions) => StructurePart[];
+declare const slabPanelsOf: (structure: PlanStructure, options: SlabPanelOptions) => StructurePart[];
 
 interface DestructibleSpecOptions {
     /** Fraction of its capacity a pillar or bearing wall uses at rest (default 0.65). */
@@ -490,31 +845,43 @@ declare const MEMBER_CAGE: {
     diameter: number;
     unit: number;
 };
+/**
+ * What the bare cage of a concrete pillar still carries once its concrete is blown off, as the share of the pillar's `capacity` (kg) the destruction
+ * world keeps for it (`reinforcement.residualCapacity`): its perimeter bars (at most `spacing` apart, at least two a face) by the steel's crushing
+ * strength, halved for buckling between the stirrups. A pillar under a light bond beam keeps standing on its cage; a loaded one still gives way.
+ */
+declare function cageResidualCapacity(size: readonly number[], reinforcement: {
+    material: string;
+    spacing: number;
+    diameter: number;
+}, capacity: number | undefined): 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;
+declare function toDestructibleSpec(structure: PlanStructure, 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.
+ * Most a masonry wall runs between two of its concrete pillars, metres. Confined masonry (alvenaria confinada / de vedação with a concrete frame) puts a pillar
+ * every 3 to 5 m, at the corners, where walls meet and beside the openings; 4 m is the middle of that range.
  */
-declare function buildWallSpecimen(options: WallSpecimenOptions): DestructibleSpec;
+declare const WALL_PILLAR_SPACING = 4;
+/** Side of a wall pillar, metres: 0.2 x 0.2 m, as the corner pillars (NBR 6118 asks at least 19 cm for a pillar). */
+declare const WALL_PILLAR_SIDE = 0.2;
+/**
+ * Centres of the pillars of a stretch: at each end (inside the stretch, flush with it), at the walls that meet it, and in between so that no span passes
+ * `spacing`. A short pier still gets one at each end (a door jamb beside a corner keeps its own pillar; `addWallPillars` drops the one a pillar already
+ * stands near); one too short for two gets one in its middle, and one too short for a pillar none.
+ */
+declare function pillarStations(from: number, to: number, junctions: readonly number[], spacing: number): number[];
+
+/** Depth of the ground beam (viga baldrame) under a ground-floor masonry wall, metres: the usual 15 x 30 cm, as wide as the wall. */
+declare const GROUND_BEAM_DEPTH = 0.3;
 
 type Rng = () => number;
+/** Side of the concrete pillars of a raised tank slab, metres: NBR 6118 asks at least 19 cm. */
+declare const TANK_PILLAR_SIDE = 0.2;
 interface TankPlanOptions {
     /** Litres by template id or style id (default: budget 500, mid 1000, mansion 3000, any other 2000). */
     capacities?: Record<string, number>;
@@ -522,6 +889,8 @@ interface TankPlanOptions {
     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;
+    /** Side of the platform's concrete pillars (default `TANK_PILLAR_SIDE`; the Visor de casas 3D drew 0.12 m). */
+    pillarSide?: number;
 }
 /**
  * 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
@@ -529,43 +898,93 @@ interface TankPlanOptions {
  */
 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;
+/** Stable codes of what `validateStructure` and `validateSpec` find wrong in a construction. */
+declare const STRUCTURAL_VIOLATION: {
+    /** A pillar with no load path to the ground, or that starts above what it rests on. */
+    readonly PILLAR_NOT_GROUNDED: "PILLAR_NOT_GROUNDED";
+    /** A pillar of a masonry wall that stops short of the bond beam, or that the bond beam does not rest on. */
+    readonly PILLAR_DOES_NOT_REACH_BOND_BEAM: "PILLAR_DOES_NOT_REACH_BOND_BEAM";
+    /** A masonry wall that runs more than `MAX_PILLAR_SPACING` between two of its pillars. */
+    readonly WALL_SPAN_WITHOUT_PILLAR: "WALL_SPAN_WITHOUT_PILLAR";
+    /** A free end of a masonry wall (a door jamb, the end of a garden wall) with no pillar. */
+    readonly WALL_END_WITHOUT_PILLAR: "WALL_END_WITHOUT_PILLAR";
+    /** Two masonry walls meet at a corner with no pillar there. */
+    readonly CORNER_WITHOUT_PILLAR: "CORNER_WITHOUT_PILLAR";
+    /** Another wall meets a masonry wall inside its length (a T) with no pillar there. */
+    readonly WALL_JUNCTION_WITHOUT_PILLAR: "WALL_JUNCTION_WITHOUT_PILLAR";
+    /** A window or door in a masonry wall with no lintel (verga) over it. */
+    readonly OPENING_WITHOUT_LINTEL: "OPENING_WITHOUT_LINTEL";
+    /** A window in a masonry wall with no sill beam (contraverga) under it. */
+    readonly OPENING_WITHOUT_SILL: "OPENING_WITHOUT_SILL";
+    /** An exterior masonry wall with no bond beam (cinta de amarração) on top. */
+    readonly MISSING_BOND_BEAM: "MISSING_BOND_BEAM";
+    /** A ground-floor masonry wall standing on the soil with no ground beam (viga baldrame) or foundation under it. */
+    readonly MISSING_GROUND_BEAM: "MISSING_GROUND_BEAM";
+    /** A part with no load path down to the ground. */
+    readonly FLOATING_PART: "FLOATING_PART";
+    /** A concrete beam longer than a lintel that rests on masonry alone (no pillar, beam or slab carries it). */
+    readonly BEAM_ON_WEAK_MASONRY: "BEAM_ON_WEAK_MASONRY";
+    /** A concrete pillar or beam below the NBR 6118 minimum section, or a beam between point supports shallower than a tenth of its span. */
+    readonly CONCRETE_BELOW_MIN_SECTION: "CONCRETE_BELOW_MIN_SECTION";
+    /** A concrete pillar or beam with no steel (the construction has no rebar). */
+    readonly UNREINFORCED_CONCRETE: "UNREINFORCED_CONCRETE";
+    /** A brick or block wall laid in stack bond: the vertical joints line up and the wall splits along them. */
+    readonly UNBONDED_MASONRY: "UNBONDED_MASONRY";
+    /** A plastered brick wall without plaster on both faces. */
+    readonly MISSING_PLASTER: "MISSING_PLASTER";
+};
+type StructuralViolationCode = (typeof STRUCTURAL_VIOLATION)[keyof typeof STRUCTURAL_VIOLATION];
+/** One thing a construction gets wrong: the code, the part (or opening) it is about and the rule it breaks, in words. */
+interface StructuralViolation {
+    readonly code: StructuralViolationCode;
+    readonly part: string;
+    readonly message: string;
+}
+/** Most metres a masonry wall runs between two pillars (confined masonry: 3 to 4 m; `WALL_PILLAR_SPACING` is 4). */
+declare const MAX_PILLAR_SPACING = 4;
+/** NBR 6118 13.2.3: no side of a pillar under 19 cm, and at least 360 cm² of section. */
+declare const MIN_PILLAR_SIDE = 0.19;
+declare const MIN_PILLAR_AREA = 0.036;
+/** NBR 6118 13.2.2: a beam at least 12 cm wide. */
+declare const MIN_BEAM_WIDTH = 0.12;
+/** A beam between point supports is at least a tenth of its span deep (pre-sizing of reinforced concrete beams, h = L/10). */
+declare const BEAM_DEPTH_RATIO = 10;
+/** A concrete beam that only masonry carries may be a lintel up to this span; a longer one needs pillars. */
+declare const MAX_LINTEL_ON_MASONRY = 3;
+
+interface ValidateStructureOptions {
+    /** Detail the walls are built in for play (default `panels`, as the houses are): the lintels and sill beams of the windows come from it. */
+    wallDetail?: WallDetail;
+    /** The doors of the plan (`plan.doors`): each door gap in a masonry wall needs a lintel. Without them only the windows are checked. */
+    doors?: readonly SourceDoor[];
 }
-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;
+/**
+ * What a structure gets wrong as a real building: load paths (every part down to the ground, every pillar on what carries it), reinforced concrete (NBR
+ * 6118 sections, steel, beam depth) and, in masonry, confined masonry (ground beam, pillars at ends, corners, junctions and every 4 m up to the bond beam,
+ * lintels and sill beams, bonded and plastered bricks). An empty list is a structure that a structural engineer would sign.
+ */
+declare function validateStructure(structure: PlanStructure, options?: ValidateStructureOptions): StructuralViolation[];
+/** What a destructible spec built straight as one (towers, skyscrapers) gets wrong: load paths and concrete sections. */
+declare function validateSpec(spec: DestructibleSpec): StructuralViolation[];
+/** The violations counted by code (for reports and tests). */
+declare function countViolations(violations: readonly StructuralViolation[]): Partial<Record<keyof typeof STRUCTURAL_VIOLATION, number>>;
+
+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;
 
 /** 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;
@@ -1160,254 +1579,6 @@ declare const towerLocales: {
     };
 };
 
-/** A point in the world: `[u, v, y]` (y is the absolute height). */
-type Point3 = [number, number, number];
-/** Something fixed to the inner face of a wall of a room: a socket, a switch, the panel. */
-interface WallFixture {
-    id: string;
-    room: string;
-    floor: number;
-    u: number;
-    v: number;
-    /** Height above the storey floor. */
-    y: number;
-    /** Position along the wall. */
-    c: number;
-    axis: PlanAxis;
-    pos: number;
-    frontU: number;
-    frontV: number;
-}
-interface Outlet extends WallFixture {
-    type: string;
-    voltage: number;
-}
-interface LightSwitch extends WallFixture {
-    door: string;
-    /** On the latch side of the door. */
-    latchSide: boolean;
-    /** Lamp ids it turns on. */
-    controls: string[];
-}
-interface ElectricalPanel extends WallFixture {
-    w: number;
-    h: number;
-    breakers: number;
-}
-interface ElectricMeter {
-    id: string;
-    place: string;
-    u: number;
-    v: number;
-    y: number;
-    side: string;
-    w: number;
-    d: number;
-    h: number;
-}
-/** Pole, drop, meter, descent and the run to the panel; a tap has no meter and a bare connection instead. */
-interface ServiceEntrance {
-    pole: {
-        u: number;
-        v: number;
-        h: number;
-    };
-    drop: Point3[];
-    meter: ElectricMeter | null;
-    descent: Point3[];
-    internalRun: Point3[] | null;
-    tap?: boolean;
-    connection?: {
-        u: number;
-        v: number;
-        y: number;
-    };
-}
-interface Circuit {
-    id: string;
-    room: string;
-    floor: number;
-    outlets: string[];
-    switches: string[];
-    lamps: string[];
-    exposed: boolean;
-    gauge_mm2: number;
-}
-interface Conduit {
-    id: string;
-    circuit: string;
-    from: string;
-    to: string;
-    exposed: boolean;
-    diameter: number;
-    points: Point3[];
-}
-interface OutdoorLamp {
-    id: string;
-    u: number;
-    v: number;
-    y: number;
-    door: string;
-    switch: string | null;
-}
-interface PlumbingPoint {
-    id: string;
-    kind: string;
-    item: string;
-    room: string | null;
-    floor: number;
-    u: number;
-    v: number;
-    y: number;
-    flowLpm: number | undefined;
-    run: string | null;
-}
-interface PlumbingRun {
-    id: string;
-    from: string;
-    /** A point, a room, or `ceiling`. */
-    to: string | null;
-    points: Point3[];
-    diameter: number;
-    exposed: string;
-}
-interface Plumbing {
-    tank: 'water_tank' | null;
-    capacityL: number;
-    points: PlumbingPoint[];
-    visibleRuns: PlumbingRun[];
-}
-interface SolarPanel {
-    id: string;
-    u: number;
-    v: number;
-    w: number;
-    d: number;
-    length: number;
-}
-interface Inverter {
-    id: string;
-    u: number;
-    v: number;
-    y: number;
-    side: string;
-    w: number;
-    d: number;
-    h: number;
-    outdoor: boolean;
-    link: string;
-}
-interface Solar {
-    type: 'slab_rack' | 'roof';
-    orientation: string;
-    north: 'front' | 'back';
-    slopeSide: 'front' | 'back' | null;
-    tilt: number;
-    area: number[];
-    areaM2: number;
-    count: number;
-    floor: number;
-    y: number;
-    panels: SolarPanel[];
-    inverter: Inverter | null;
-}
-/** A door or a window in the wall of an outbuilding. */
-interface OutbuildingOpening {
-    id: string;
-    axis: PlanAxis;
-    pos: number;
-    at: number;
-    u: number;
-    v: number;
-    width: number;
-    side: string;
-    height?: number;
-    exterior?: boolean;
-    y0?: number;
-    y1?: number;
-    /** Swing area of a door. */
-    zone?: Rect;
-}
-interface OutbuildingWall {
-    axis: PlanAxis;
-    u0: number;
-    v0: number;
-    u1: number;
-    v1: number;
-    thickness: number;
-    h: number;
-    side: string;
-}
-interface OutbuildingItem {
-    type: string;
-    category: string;
-    u: number;
-    v: number;
-    w: number;
-    d: number;
-    h: number;
-    ry: number;
-    frontU: number;
-    frontV: number;
-    aabb: Rect;
-}
-interface Outbuilding {
-    id: string;
-    type: 'outbuilding';
-    use: string;
-    floor: number;
-    aabb: Rect;
-    interior: Rect[];
-    ceiling: number;
-    thickness: number;
-    front: [number, number];
-    walls: OutbuildingWall[];
-    doors: OutbuildingOpening[];
-    windows: OutbuildingOpening[];
-    items: OutbuildingItem[];
-}
-
-type EnergyMode = 'grid' | 'tap' | 'offgrid';
-/** What a template says about its energy (a shack taps the grid without a meter, a cabin may run off-grid on solar). */
-interface EnergyConfig {
-    mode: EnergyMode;
-    solar?: boolean;
-}
-interface Electrical {
-    mode: EnergyMode;
-    serviceEntrance: ServiceEntrance | null;
-    panel: ElectricalPanel | null;
-    outlets: Outlet[];
-    switches: LightSwitch[];
-    circuits: Circuit[];
-    conduits: Conduit[];
-    exposed: boolean;
-    outdoorLamps: OutdoorLamp[];
-    source?: 'solar' | 'lamp';
-}
-
-interface GasMeter {
-    id: 'gas.meter';
-    u: number;
-    v: number;
-    y: number;
-    side: string;
-    w: number;
-    d: number;
-    h: number;
-}
-interface Gas {
-    type: 'piped' | 'cylinder';
-    meter: GasMeter | null;
-}
-
-interface Utilities {
-    gas: Gas | null;
-    electrical: Electrical;
-    solar: Solar | null;
-    plumbing: Plumbing;
-}
-
 declare const version = "0.1.0";
 
-export { CONSTRUCTIONS, CONSTRUCTION_SYSTEMS, CORE_DEFAULTS, CURTAIN_DEFAULTS, type ChaletOptions, type Chimney, type Circuit, type Conduit, type Construction, type ConstructionBuild, type ConstructionBuilder, type ConstructionSystem, type ConstructionSystemDef, type CoreOptions, type CurtainWallOptions, DAMPER_DEFAULTS, DENSITY, type DamperOptions, type DestructibleSpecOptions, type ElectricMeter, type Electrical, type ElectricalPanel, type EnergyConfig, type EnergyMode, FLAT_ROOF_DEFAULTS, type FlatRoofOptions, type FoundationType, GROUND, type Gas, type GasMeter, type Inverter, type LightSwitch, MECHANICAL_DEFAULTS, MEMBER_CAGE, type MechanicalFloorOptions, type Opening, type Outbuilding, type OutbuildingItem, type OutbuildingOpening, type OutbuildingWall, type OutdoorLamp, type Outlet, PILE_AREA, PILE_DEFAULTS, PLATE_DEFAULTS, PUNCHED_DEFAULTS, type PartRole, type PileDesign, type PlanContext, type PlateOptions, type PlateRect, type PlateStrip, type Plumbing, type PlumbingPoint, type PlumbingRun, type Point3, type PunchedFacadeOptions, RAFT_THICKNESS, REBAR_RATIOS, ROOF_COVERINGS, type Rect, type Roof, type RoofCoveringDef, type RoofPane, type RoofShape, SKYSCRAPER_DEFAULTS, SKYSCRAPER_MAX_STOREYS, SLAB_PANEL_DEFAULTS, type ServiceEntrance, type ShackOptions, type SkyscraperLayout, type SkyscraperOptions, type SkyscraperPreset, type SlabPanelOptions, type Solar, type SolarPanel, type SourceDoor, type SourceWall, type SourceWindow, type StoreyContext, type StoreyKind, type StripFill, type StripFiller, type StripId, type Structure, type StructureExtras, type StructureOptions, type StructurePackOptions, type StructurePart, type StructureSource, type Support, TOWER_DEFAULTS, type TankPlanOptions, type TankPlatform, type Tent, type TowerGeometry, type TowerMechanicalOptions, type TowerOptions, type TowerPlanOptions, type TowerPlate, type Utilities, type WallDetail, type WallFixture, type WallMaterials, type WallSpecimenOptions, type WaterTank, type WoodFrameOptions, addCore, addCurtainWall, 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 };
+export { BEAM_DEPTH_RATIO, CONSTRUCTIONS, CONSTRUCTION_SYSTEMS, CORE_DEFAULTS, CURTAIN_DEFAULTS, type ChaletOptions, type Chimney, type Circuit, type Conduit, type Construction, type ConstructionBuild, type ConstructionBuilder, type ConstructionSystem, type ConstructionSystemDef, type CoreOptions, type CurtainWallOptions, DAMPER_DEFAULTS, DENSITY, type DamperOptions, type DestructibleSpecOptions, type ElectricMeter, type Electrical, type ElectricalPanel, type EnergyConfig, type EnergyMode, FLAT_ROOF_DEFAULTS, type FlatRoofOptions, type FoundationType, GROUND, GROUND_BEAM_DEPTH, type Gas, type GasMeter, type Inverter, type LightSwitch, MAX_LINTEL_ON_MASONRY, MAX_PILLAR_SPACING, MECHANICAL_DEFAULTS, MEMBER_CAGE, MIN_BEAM_WIDTH, MIN_PILLAR_AREA, MIN_PILLAR_SIDE, type MechanicalFloorOptions, type Opening, type Outbuilding, type OutbuildingItem, type OutbuildingOpening, type OutbuildingWall, type OutdoorLamp, type Outlet, PILE_AREA, PILE_DEFAULTS, PLATE_DEFAULTS, PUNCHED_DEFAULTS, type PartRole, type PileDesign, type PlanContext, type PlanStructure, type PlateOptions, type PlateRect, type PlateStrip, type Plumbing, type PlumbingPoint, type PlumbingRun, type Point3, type PunchedFacadeOptions, RAFT_THICKNESS, REBAR_RATIOS, ROOF_COVERINGS, type Rect, type Roof, type RoofCoveringDef, type RoofPane, type RoofShape, SILL_BEAM_DEPTH, SKYSCRAPER_DEFAULTS, SKYSCRAPER_MAX_STOREYS, SLAB_PANEL_DEFAULTS, STRUCTURAL_VIOLATION, type ServiceEntrance, type ShackOptions, type SkyscraperLayout, type SkyscraperOptions, type SkyscraperPreset, type SlabPanelOptions, type Solar, type SolarPanel, type SourceDoor, type SourceWall, type SourceWindow, type StoreyContext, type StoreyKind, type StripFill, type StripFiller, type StripId, type StructuralViolation, type StructuralViolationCode, type Structure, type StructureExtras, type StructureOptions, type StructurePackOptions, type StructurePart, type StructureSource, type StructuredResult, type Support, TANK_PILLAR_SIDE, TOWER_DEFAULTS, type TankPlanOptions, type TankPlatform, type Tent, type TowerGeometry, type TowerMechanicalOptions, type TowerOptions, type TowerPlanOptions, type TowerPlate, type Utilities, type ValidateStructureOptions, WALL_PILLAR_SIDE, WALL_PILLAR_SPACING, type WallDetail, type WallFixture, type WallMaterials, type WallSpecimenOptions, type WaterTank, type WoodFrameOptions, addCore, addCurtainWall, addFlatRoof, addMechanicalFloor, addPunchedFacade, addTunedMassDamper, applySlabPanels, beamDepthFor, beamSpan, buildSkyscraper, buildStructure, buildTower, buildWallSpecimen, cageResidualCapacity, campConstruction, chaletConstruction, constructionOfSystem, coreSize, countViolations, damperMass, exteriorWindows, logCabinConstruction, masonryConstruction, mechanicalStoreys, pilesFor, pillarStations, planToSpace, planWaterTank, register, registerConstruction, registerConstructionSystem, registerRoofCovering, resolveSlabPanels, shackConstruction, skyscraperLayout, slabPanelView, slabPanelsOf, splitStrip, storeyKinds, stripDoor, structureLayer, toDestructibleSpec, towerFloors, towerLocales, towerPlate, towerWater, validateSpec, validateStructure, version, windExposureOf, woodFrameConstruction };