@adatechnology/game-floorplan-three 0.9.3 → 0.10.1

package/dist/testing-BK7QmoUq.d.ts

@@ -0,0 +1,1611 @@
+import { DeferredQueue, ModuleScenario, TestableModule, DestructibleSpec } from '@adatechnology/game-contracts';
+import { DestructionWorld, DestructionEvent } from '@adatechnology/game-destruction';
+import { DestructionRenderer } from '@adatechnology/game-destruction-three';
+import { FloorplanResult, ResultGate, FloorplanResultFields, ResultRoom, PlanWall, PlanDoor, PlanWindow, Rect } from '@adatechnology/game-floorplan';
+import * as THREE_NS from 'three';
+import { LightBudget, LightHandle } from '@adatechnology/game-render-three';
+import { DocumentLike, Props3dOptions, Props3d } from '@adatechnology/game-props3d';
+import { catenary } from '@adatechnology/game-shapes-three';
+import * as Vegetation from '@adatechnology/game-vegetation';
+import { PlantSpec } from '@adatechnology/game-vegetation';
+import * as Interactables from '@adatechnology/game-interactables';
+import { ObjectSpec, World } from '@adatechnology/game-interactables';
+import { FloorplanAdapter, HouseholdKit, AdapterOptions, PlanEntry, AdapterPlan, WaterNetwork, AddResult, BlockedFn } from '@adatechnology/game-floorplan-interactables';
+import { StructurePart, Support, Outbuilding, Utilities, WaterTank, Construction, Structure, PlumbingPoint, PlumbingRun } from '@adatechnology/game-floorplan-structure';
+import * as VegetationThree from '@adatechnology/game-vegetation/three';
+
+/** Texts the house shows to the player (interaction prompts, messages, outbuilding labels), by locale. */
+type Messages = Record<string, string>;
+declare const en: Messages;
+declare const ptBR: Messages;
+declare const locales: Record<string, Messages>;
+type Translate = (key: string, params?: Record<string, string | number>) => string;
+/**
+ * Translator for a locale id ('en', 'pt-BR'), or for a partial table that overrides the English one.
+ * A missing key falls back to English and then to the key itself.
+ */
+declare function createTranslator(locale?: string | Partial<Messages>): Translate;
+
+/**
+ * What the house reads of the adapters the game hands it, by shape: one domain adapter does not import another (layer rule
+ * `no-domain-adapter-to-adapter`), nor a content pack (`adapter-not-content`). The game passes `game-interactables-three`'s
+ * `createThreeAdapter`, `game-destruction-three`'s renderer and `game-vegetation-species` by option; these types hold only what
+ * the house calls, so the real modules fit them.
+ */
+
+/** A TV screen of the interactables adapter (`createScreen`): a canvas material that turns on and changes channel. */
+interface InteractablesScreen {
+    material: THREE_NS.MeshStandardMaterial;
+    readonly on: boolean;
+    readonly channel: number;
+    setOn(on: boolean): void;
+    setChannel(channel: number): void;
+    update(dt: number): void;
+    dispose(): void;
+}
+/** The particle effects of the interactables adapter (`createEffects`): water, steam, sparks and flames of the objects. */
+interface InteractablesEffects {
+    update(dt: number, emitters: readonly unknown[], camera?: unknown): void;
+    stats(): {
+        alive: number;
+    };
+    dispose(): void;
+}
+/** What `finish` of a mesh api gives back: the object's groups, its moving parts and the lights its builders asked for. */
+interface InteractablesMeshResult {
+    group: THREE_NS.Group;
+    parts: Record<string, THREE_NS.Group>;
+    lights: THREE_NS.Light[];
+}
+/** The interactables adapter bound to the house's three.js (`createThreeAdapter(THREE, options)` of game-interactables-three). */
+interface InteractablesGfx {
+    createMeshApi(options?: {
+        quality?: string;
+        materials?: Record<string, THREE_NS.Material | undefined>;
+        shadows?: boolean;
+        mergeParts?: boolean;
+        swayAmplitude?: number;
+    }): {
+        api: Parameters<FloorplanAdapter['household']['build']>[2];
+        finish(spec?: ObjectSpec): InteractablesMeshResult;
+    };
+    syncObject(world: World, objectId: string, parts: Record<string, THREE_NS.Object3D>, options?: {
+        time?: number;
+    }): void;
+    createEffects(scene: THREE_NS.Object3D, options?: Record<string, unknown>): InteractablesEffects;
+    createScreen(options?: {
+        w?: number;
+        h?: number;
+        seed?: number;
+    }): InteractablesScreen;
+    createCord(points: readonly Vec3$1[], radius: number, material: THREE_NS.Material): THREE_NS.Mesh;
+    catenary: typeof catenary;
+}
+/** What draws a part of a bound object: a mesh or group, or a vertex range `[v0, v1)` of a mesh. */
+type BoundMeshes = THREE_NS.Object3D | {
+    mesh: THREE_NS.Mesh;
+    range: [number, number];
+};
+/** The destruction renderer the game hands the house (`createDestructionRenderer(THREE, { scene, world })` of game-destruction-three). */
+interface HouseDestructionRenderer {
+    bind(objectId: string, root: THREE_NS.Object3D, options?: {
+        parts?: Record<string, BoundMeshes | BoundMeshes[]>;
+        onFrame?: (dt: number) => void;
+    }): void;
+    unbind(objectId: string): void;
+    restore(objectId: string): void;
+}
+/** The species pack the game hands the house's vegetation (`game-vegetation-species`): a plant spec by species id. */
+interface SpeciesLibrary {
+    toSpec(species: string): PlantSpec;
+}
+
+/** A part of the house a hit can damage (door, window, glass, tank...): the game reads `hp`. */
+interface Damageable {
+    type: string;
+    hp: number;
+    hpMax: number;
+}
+/** A damageable box of a fleet car, in the car's frame (`game-vehicles` gives them). */
+interface HouseFleetDamageable {
+    box: THREE_NS.Box3;
+    zone: string;
+    part?: string;
+    side?: string;
+    type?: string;
+}
+/** A car the fleet built: its group (+z in front), its damageable boxes, and how to give its resources back. */
+interface HouseFleetCar {
+    group: THREE_NS.Object3D;
+    damageables?: HouseFleetDamageable[];
+    release?(): void;
+}
+/** The interactables kit a game injects (`interactives`): its modules, and optionally its own adapter of the plan. */
+interface HouseInteractivesOptions {
+    GameInteractables?: InteractablesRefs['GI'];
+    GameInteractablesHousehold?: HouseholdKit;
+    GameInteractablesThree?: InteractablesRefs['GT'];
+    /** An adapter, or a factory with `create(options)`; the default is `@adatechnology/game-floorplan-interactables`. */
+    adapter?: FloorplanAdapter | {
+        create(options: AdapterOptions): FloorplanAdapter;
+    };
+    /** Passed to the factory's `create()`. */
+    adapterOptions?: AdapterOptions;
+    locale?: AdapterOptions['locale'];
+    region?: AdapterOptions['region'];
+    /** `false`: the kit does not draw the items of the plan. */
+    items?: boolean;
+    /** `false`: no particle effects. */
+    effects?: boolean;
+    /** () => the host's `EffectSink`: smoke, steam, fire and sparks go through its world. */
+    effectSink?: unknown;
+    camera?: unknown;
+    onEvent?: InteractablesRefs['onEvent'];
+    onSeat?: InteractablesRefs['onSeat'];
+}
+/** The vegetation packages a game injects (`vegetation`): `{ GameVegetation, GameVegetationSpecies }`, or one object with both sides. */
+type HouseVegetationOptions = {
+    GameVegetation?: VegetationLibs['G'];
+    GameVegetationSpecies?: VegetationLibs['S'];
+} & Partial<VegetationLibs['G'] & VegetationLibs['S']>;
+/** What `onInteract` gets: the id, type and label of what the player acts on, and the house's or the kit's own reference to it. */
+interface HouseInteractTarget {
+    id: string;
+    type: string;
+    label: string;
+    ref: unknown;
+}
+/** What `onDamage` gets for a wall. */
+interface HouseWallDamage {
+    type: 'wall';
+    damageable: Damageable;
+    collider: {
+        damageable?: Damageable;
+        piece?: string;
+    };
+}
+/** What `create(THREE, options)` reads. Everything is optional; the three.js namespace is the first argument. */
+interface HouseRendererOptions {
+    /** Document used to draw the procedural textures on a canvas (default: the page's). */
+    document?: DocumentLike;
+    /** `'game'` merges more and draws less than `'high'`. */
+    quality?: 'high' | 'game';
+    /** Locale of the texts the house shows (`en`, `pt-BR`) or a table of messages. */
+    locale?: string | Partial<Messages>;
+    /** `@adatechnology/game-props3d` (default: the package's own dependency). */
+    props?: {
+        create(THREE: Three, options?: Props3dOptions): Props3d;
+    };
+    /** `THREE.Reflector` (three/examples/jsm/objects/Reflector.js); without it the mirrors use only the environment map. */
+    reflector?: ReflectorClass;
+    /** Cars of the lot and garage: `build(kind, { quality, seed })` -> `{ group, damageable, release() }`. Without it there are no cars. */
+    fleet?: {
+        build(kind: string, options: {
+            quality: string;
+            seed: number;
+        }): HouseFleetCar;
+    } | null;
+    /** Car kinds (fleet ids) per lot style (`budget`, `mid`, `high`); replaces the list of a style. */
+    carKinds?: Record<string, string[]>;
+    /** Hit points per damage class (glass, wood, water, metal, masonry, rubber, fuel, gas). */
+    hp?: Record<string, number>;
+    /** Textures from the app that replace the procedural ones. */
+    textures?: Partial<Record<'roughcast' | 'block' | 'tile' | 'dirt' | 'grass' | 'asphalt' | 'sidewalk' | 'fiber_cement', THREE_NS.Texture>>;
+    /** Atlas textures from the app: framed pictures, floor kinds, water. */
+    atlas?: {
+        picture?: THREE_NS.Texture;
+        floorKind?: THREE_NS.Texture;
+        water?: THREE_NS.Texture;
+    };
+    /** Materials the game swaps (a material or a function of the default one). */
+    materials?: Record<string, THREE_NS.Material | ((material: THREE_NS.Material, key: string) => THREE_NS.Material | null | undefined | void)>;
+    /** The world of `@adatechnology/game-destruction`; the house registers itself in it on first need. */
+    destruction?: DestructionWorld;
+    /** `createDestructionRenderer(THREE, { scene, world })` of `@adatechnology/game-destruction-three`: draws fracture, collapse, fragments, spalls and the rebar cage on the house's meshes. */
+    destructionRenderer?: HouseDestructionRenderer;
+    /** The lights of effects (a blast, a fire, a flare) light the room where their point is, and the rooms either side of an open door or window next to it (see `effectLights` and `lighting`). Default true; false keeps them off every house surface. */
+    effectLightsIndoors?: boolean;
+    /** Milliseconds per frame the house may spend repainting damaged walls (chipped plaster, holes); events of one frame are painted together. Default `Infinity` (all of them at the frame's flush); a game loop sets a few ms. */
+    breachPaintBudgetMs?: number;
+    /** The interactables kit, injected: `{ GameInteractables, GameInteractablesHousehold, GameInteractablesThree, adapter (optional), adapterOptions, locale, region, items, effects, effectSink, camera, onEvent, onSeat }`. */
+    interactives?: HouseInteractivesOptions;
+    /** The vegetation packages, injected: `{ GameVegetation, GameVegetationSpecies }`. */
+    vegetation?: HouseVegetationOptions;
+    /** Maps an id of the plan to the key its seeded random draws use, to reproduce a scene drawn with other ids (golden tests). */
+    seedKey?: (id: string) => string | null | undefined;
+    /** Distance (m) beyond which the interior (`interior`) and the house (`hide`) are drawn no more, or `false` to switch distance LOD off. */
+    lod?: false | {
+        interior?: number;
+        hide?: number;
+    };
+    drawCallBudget?: number;
+    onChange?: (change: {
+        shadow: boolean;
+    }) => void;
+    /** A collider opened or closed (a door, a gate, a piece of furniture moved). */
+    onCollider?: (collider: HouseBoxCollider | HouseFurnitureCollider) => void;
+    /** A part took damage (`house.damage`, a hit of the destruction world): the part, or for a wall `{ type: 'wall', damageable, collider }`. */
+    onDamage?: (part: HousePart | HouseWallDamage, point: HousePoint | null | undefined, type: string) => void;
+    /** Every event of the destruction world about this house, with the house's inner group. */
+    onWreck?: (event: DestructionEvent, house: THREE_NS.Group) => void;
+    /** The player acts on something; returning `false` cancels it. */
+    onInteract?: (target: HouseInteractTarget, action?: InteractionTarget | KitInteractionTarget) => boolean | void;
+    /** A room's light turned on or off (`on` is what it shows now). */
+    onLight?: (roomId: string, on: boolean) => void;
+    onMessage?: (text: string) => void;
+}
+interface BuildOptions {
+    /** `'high'` (default) or `'game'`. */
+    quality?: 'high' | 'game';
+    /** Night: lit windows and room lamps. */
+    night?: boolean;
+    /** Roof cut off and floors above hidden, to look into the plan. */
+    cut?: boolean;
+    /** A state returned by `newState()`: pass the same one to rebuild without closing every door. */
+    state?: SavedHouseState;
+    /** `false`: the app already has ground, street and lawn. */
+    terrain?: boolean;
+    /** `true`: no lot wall, fence or gates (the game has its own). */
+    noPerimeter?: boolean;
+    /** `'meshes'`: one mesh per structural piece instead of one per group and material. */
+    pieces?: 'meshes';
+    /**
+     * The concrete pillars that stand in the masonry walls (`wall_column_*`, `column_*` at the corners and `jamb_column_*` of the structure). `'shown'` (default): drawn as what they are, plastered and painted
+     * a shade off the wall and standing 2.5 cm out of each face (a 20 cm pillar in a 15 cm wall), so the frame reads from the ends of each wall, its corners
+     * and its openings, and a shot or a blow that takes their plaster off shows their concrete and bars. `'hidden'`: inside the wall, seen only where it is
+     * damaged, as the Visor de casas 3D drew the houses.
+     */
+    pillars?: 'shown' | 'hidden';
+    drawCallBudget?: number;
+    building?: {
+        floors?: number;
+        floor?: number;
+        unit?: number;
+        showBuilding?: boolean;
+    };
+}
+/** Something the player can use, as the house publishes it: where it is, how far it reaches, its prompt and how to use it. */
+interface HouseInteractable {
+    id: string;
+    type: string;
+    floor: number;
+    pos: number[];
+    radius: number;
+    angle?: number;
+    readonly label: string;
+    ref: unknown;
+    _action: () => unknown;
+    act?: () => boolean;
+}
+/** A part of the house that moves or takes damage (`house.parts[id]`): its group, its damage and how to open it. */
+interface HousePart {
+    id: string;
+    type: string;
+    group: THREE_NS.Object3D | null;
+    damageable: Damageable | null;
+    opens(t: number): void;
+    readonly t: number;
+    floor?: number;
+    /** Box of a virtual part (window, mirror, car zone): `[x0, y0, z0, x1, y1, z1]`. */
+    aabb?: number[];
+    virtual?: boolean;
+    [extra: string]: unknown;
+}
+/** What `HouseRenderer.build` takes: a plan of `game-floorplan` (`generate`), or a house record made from one. */
+type HousePlan = FloorplanResult | HouseRecord;
+/** A point in world coordinates. */
+interface HousePoint {
+    x: number;
+    y: number;
+    z: number;
+}
+/** A box collider of `house.colliders`: a wall, door, lot wall or gate on floor `f`, `[x0, z0]`-`[x1, z1]`. */
+type HouseBoxCollider = BoxCollider;
+/** A furniture collider of `house.colliders`: the oriented box of a piece on its floor. */
+interface HouseFurnitureCollider {
+    type: 'furniture';
+    f: number;
+    obb: {
+        cx: number;
+        cz: number;
+        hw: number;
+        hd: number;
+        c: number;
+        s: number;
+    };
+    item: string;
+    off: boolean;
+}
+/** Options of `house.target` and `house.interact`: the ray test the game uses for the meshes, and the options of the interactables kit's targeting. */
+interface HouseTargetOptions {
+    strike?: (meshes: THREE_NS.Mesh[]) => THREE_NS.Intersection | null | undefined;
+    interactives?: KitTargetOptions;
+}
+/** The house the renderer built. The three.js groups are ready to add to a scene. */
+interface House {
+    version: string;
+    /** The plan it was built from. */
+    r: HouseRecord;
+    name: string;
+    quality: 'high' | 'game';
+    group: THREE_NS.Group;
+    house: THREE_NS.Group;
+    groups: Record<string, THREE_NS.Group>;
+    floors: THREE_NS.Group[];
+    ceilings: (THREE_NS.Group | null)[];
+    roof: THREE_NS.Group | null;
+    lot: THREE_NS.Group | null;
+    ground: THREE_NS.Group | null;
+    building: THREE_NS.Group | null;
+    /** The water tank of the plan: its part, its group, where it stands and the plan's tank. */
+    waterTank: {
+        part: HousePart | null;
+        group: THREE_NS.Object3D | null;
+        pos: {
+            x: number;
+            z: number;
+            y: number;
+            group: string;
+        } | null;
+        plant: NonNullable<HouseRecord['waterTank']>;
+    } | null;
+    /** Public colliders: walls, doors, lot walls and gates (aabb) and furniture (obb). */
+    colliders: (HouseBoxCollider | HouseFurnitureCollider)[];
+    /** Parts that move or take damage: id -> `{ group, type, opens(t), damageable }`. */
+    parts: Record<string, HousePart>;
+    /** The lot and garage cars: fleet kind, seed, place and the ids of their virtual parts. */
+    cars: {
+        i: number;
+        k: string;
+        seed: number;
+        pos: number[];
+        ry: number;
+        scale: number;
+        parts: string[];
+    }[];
+    interactables: HouseInteractable[];
+    doors: DoorLeaf[];
+    stairs: StairRecord[];
+    labels: HouseLabel[];
+    /** Item types of the plan the props kit has no model for, with their count. */
+    noModel: Map<string, number>;
+    /** The real lights the builders asked for (at night) in `list`, and the same grouped by room id in `byRoom`. */
+    lights: {
+        list: LightRequest[];
+        byRoom: Record<string, LightRequest[]>;
+    };
+    limits: {
+        x0: number;
+        z0: number;
+        x1: number;
+        z1: number;
+    };
+    apartment: boolean;
+    showBuilding: boolean;
+    buildingConfig: {
+        floors: number;
+        floor: number;
+        unit: number;
+    };
+    unitRy: number;
+    night: boolean;
+    cut: boolean;
+    /** What the interactables kit published for the house (with `interactives`). */
+    interactives: HouseInteractives | null;
+    /** The doors and pieces state to pass to a rebuild (`build(plan, { state })`). */
+    state: SavedHouseState;
+    stats: {
+        quality: 'high' | 'game';
+        drawCalls: number;
+        drawCallsLOD1: number;
+        triangles: number;
+        trianglesLod1: number;
+        budget: number | null;
+        overBudget: boolean;
+        tBuild: number;
+    };
+    vegetation: VegetationInfo | null;
+    solar: SolarInfo | null;
+    water: WaterApi;
+    electrical: ElectricalInfo | null;
+    gutters: GutterInfo | null;
+    /** The structure of the house (`game-floorplan-structure`): its parts and `spec()`, the destructible spec. */
+    structure: any;
+    /** The adapter to the destruction world (`destruction` option). */
+    destruction: any;
+    update(dt: number, time?: number, focus?: HousePoint): void;
+    show(options?: {
+        floor?: number;
+        cut?: boolean;
+        lot?: boolean;
+    }): void;
+    target(eye: Eye, options?: HouseTargetOptions): InteractionTarget | null;
+    interact(eye: Eye, options?: HouseTargetOptions): boolean;
+    /** The message the house shows now (a locked door...), or null. */
+    message(): string | null;
+    toggleDoor(door: DoorLeaf | string): void;
+    toggleLight(room: string): void;
+    lightOn(room: string): boolean;
+    collide(x: number, z: number, floor: number, options?: {
+        radius?: number;
+        from?: readonly number[];
+    }): boolean;
+    roomAt(floor: number, x: number, z: number): HouseRoom | null;
+    /** Height of the floor `f`. */
+    y0(floor: number): number;
+    chooseMirror(camera: THREE_NS.Camera): void;
+    setLod(level: number): void;
+    readonly lod: number;
+    /** World centre of the house, and its distance to a point (the shared draw budget sorts by it). */
+    center(): THREE_NS.Vector3;
+    distance(focus: THREE_NS.Vector3 | HousePoint): number;
+    damage(id: string, point?: HousePoint | null, type?: string, amount?: number): {
+        part: HousePart;
+        hp: number;
+        destroyed: boolean;
+    } | null;
+    colliderDamage(collider: {
+        damageable?: Damageable;
+        piece?: string;
+    } | null | undefined, point?: HousePoint | null, type?: string, amount?: number): {
+        hp: number;
+        destroyed: boolean;
+    } | null;
+    /** The part (door, window, furniture piece...) an object belongs to, found by going up its parents. */
+    partOf(object: THREE_NS.Object3D | null | undefined): HousePart | null;
+    /** The first part whose box holds the point (with a tolerance, default 5 cm). */
+    partAt(point: HousePoint, tolerance?: number): HousePart | null;
+    dispose(): void;
+    /** The builder's own state, for the recorders and the tests: not a stable api. */
+    internal: {
+        h: HouseInstance;
+        ctx: BuildContext;
+        inter: InteractiveState;
+        partState: Map<string, number | boolean>;
+        doorState: Map<string, boolean>;
+        mirrors: MirrorState;
+    };
+}
+/** What `HouseRenderer.lighting` reads. */
+interface LightingOptions {
+    scene?: THREE_NS.Object3D;
+    /** Room lights, 1 to 12 (6). */
+    n?: number;
+    /** How many of them cast shadows (2). */
+    shadows?: number;
+    shadowSize?: number;
+    /** Outside lamps that may take a light (2). */
+    external?: number;
+    /**
+     * The host's LightBudget: the house leases `n` point slots (`shadows` with shadow) for good instead of creating lights, and the room masks are written at the slot of each light (what the shader
+     * indexes by). Without it the lights are created here, which changes every lit material's program key (deprecated, removed in the next major).
+     */
+    budget?: LightBudget;
+}
+/** The renderer `create(THREE, options)` returns. */
+interface HouseRenderer {
+    version: string;
+    /** Builds the house of a plan (the result of `game-floorplan`, or a house record such as `wallPlan`'s). */
+    build(plan: HousePlan, options?: BuildOptions): House;
+    newState(): SavedHouseState;
+    /** Damage class and props kit type of each item type. */
+    types: TypeTable;
+    /** The props kit (`game-props3d`) the renderer draws with. */
+    mv: Props3d;
+    applyPart(group: THREE_NS.Object3D, t: number): void;
+    materials: MaterialTable;
+    /** Lets a material take the room light mask of `lighting()` (returns it). */
+    roomLightMask<M extends THREE_NS.Material | null | undefined>(material: M): M;
+    lighting(options?: LightingOptions): RoomLighting;
+    /**
+     * Lets the lights of effects (a blast, a fire, a flare) that hold slots of `budget` light the room their point is in, and the rooms either side of an open door or window next to it.
+     * Call `update(houses)` every frame after the budget's `present`. Works without `lighting()`. Off for every house with `effectLightsIndoors: false`.
+     */
+    effectLights?(options?: {
+        budget?: LightBudget;
+        ours?: readonly number[];
+    }): EffectLighting;
+    setNight(night: boolean): void;
+    /** The painting of the damaged walls of every house as a `DeferredQueue` for a shared frame budget; `budget.register` attaches it and `flush()` stops painting from `onFrame`. */
+    deferredQueue?(): DeferredQueue;
+    cars: {
+        model(kind: string, seed?: number): CarModel | null;
+        group(kind: string, w: number, d: number, seed?: number): THREE_NS.Group | null;
+        info(kind: string, seed?: number): {
+            parts: number;
+            tris: number;
+            L: number;
+            W: number;
+            H: number;
+        } | null;
+    };
+    dispose(): void;
+}
+
+interface PanelView {
+    /** The panels the slabs of the structure are cut into (as `toDestructibleSpec` names them), each with `slab`, the id of the slab it comes from. */
+    panels: StructurePart[];
+    /** Ids of the slabs that the spec no longer has (a panel for each room, or less, took their place). */
+    replaced: string[];
+    supports: Support[];
+}
+
+/** The kernel's types of the house's systems and state: materials, mirrors, cars, vegetation, interaction, room lights, the interactables kit and the build. */
+
+/** The house's materials by name (`plain`, `glass`, `dirt`...). */
+type MaterialTable = Record<string, THREE_NS.Material>;
+/** A mirror assembled with a real reflection: the group, its environment-map plane and the reflector (null when it failed). */
+interface MirrorEntry {
+    E: MirrorRecord;
+    g: THREE_NS.Group;
+    fake: THREE_NS.Mesh;
+    real: THREE_NS.Mesh | null;
+}
+/** Mirrors of a house: the assembled ones, the one reflecting now, a scratch vector and the house group. */
+interface MirrorState {
+    list: MirrorEntry[];
+    active: MirrorEntry | null;
+    tmp: THREE_NS.Vector3;
+    house: THREE_NS.Object3D | null;
+}
+/** A car model merged by material, built once per kind, quality and seed. */
+interface CarModel {
+    damageables: HouseFleetDamageable[];
+    /** Where the fleet group's centre (x, z) and floor (y) were. */
+    off: Vec3$1;
+    parts: {
+        geo: THREE_NS.BufferGeometry;
+        mat: THREE_NS.Material;
+    }[];
+    W: number;
+    L: number;
+    H: number;
+    tris: number;
+}
+/** The vegetation packages the game injected (`cfg.vegetation`): what the house uses of them. */
+interface VegetationLibs {
+    G: Pick<typeof Vegetation, 'scatter' | 'buildLot'> & Pick<typeof VegetationThree, 'createLotObject' | 'createVegetationMaterials'>;
+    S: SpeciesLibrary;
+}
+/** The plants of one group and height, collected by `vegItem` and merged by `assembleVegetation`. */
+interface VegetationGroup {
+    group: string;
+    y: number;
+    pl: Vegetation.Placement[];
+}
+/** The vegetation of the house being built (`shared.ctx.veg`). */
+interface VegetationContext extends VegetationLibs {
+    mats(): VegetationThree.VegetationMaterials;
+    groups: Map<string, VegetationGroup>;
+    /** Species the package knows (cached `toSpec` checks). */
+    ok: Map<string, boolean>;
+    opts: Omit<Vegetation.BuildLotOptions, 'seed'>;
+}
+/**
+ * A moving piece of the house (`definePiece`): a cabinet door, a drawer, a curtain, a gate, a light switch, a door handle, a lamp, or a part
+ * of the `part:` contract. `t` is where it is (0 closed, 1 open), `target` where it goes; `outer` stands at the hinge and `inner` moves.
+ */
+interface InteractivePiece {
+    name: string;
+    kind: string;
+    pivot: number[];
+    ry: number;
+    parent?: string;
+    meshes: THREE_NS.Mesh[];
+    t: number;
+    target: number;
+    t0?: number;
+    outer?: THREE_NS.Group;
+    inner?: THREE_NS.Object3D;
+    /** A handle: the door leaf and which of its groups holds it. */
+    leaf?: DoorLeaf;
+    k?: number;
+    /** A lamp: the room it lights. */
+    roomId?: string | null;
+    col?: BoxCollider;
+    gate?: ResultGate;
+    sgn?: number;
+    angle?: number;
+    travel?: number;
+    axis?: 'x' | 'y' | 'z';
+    /** The item that opens it. */
+    item?: InteractiveItem;
+    damageable?: Damageable;
+}
+/** Something the player can use (`E`): where they aim at, how far and at what angle it reaches, the pieces it moves, its prompt and action. */
+interface InteractiveItem {
+    type: string;
+    id: string;
+    floor: number;
+    anchor: number[];
+    range: number;
+    angle: number;
+    pieces: InteractivePiece[];
+    text(): string;
+    action(): void;
+    /** True: reached through walls (gates, mailbox). */
+    noWall?: boolean;
+    /** Its public view (`house.interactables`). */
+    pub?: HouseInteractable;
+}
+/** A piece of furniture that blocks walking: rotated rectangle on a floor (`-1`: the lot). */
+interface CollisionObject {
+    f: number;
+    cx: number;
+    cz: number;
+    c: number;
+    s: number;
+    hw: number;
+    hd: number;
+    type: string;
+}
+/** The interaction state of a house (`shared.inter`). */
+interface InteractiveState {
+    defs: Map<string, InteractivePiece>;
+    items: InteractiveItem[];
+    pieces: InteractivePiece[];
+    /** Lamp pieces per room. */
+    lights: Map<string, InteractivePiece[]>;
+    litRooms: Set<string>;
+    objs: CollisionObject[];
+    anim: Set<InteractivePiece>;
+    msg: {
+        text: string;
+        until: number;
+    } | null;
+    target: unknown;
+}
+/** The eye of whoever interacts, in house coordinates. */
+interface Eye {
+    x: number;
+    y: number;
+    z: number;
+    yaw: number;
+    pitch?: number;
+    floor: number;
+}
+/** The best target of an eye: its score (lower is better), prompt, action and what it is. */
+interface InteractionTarget {
+    score: number;
+    text: string;
+    action: () => unknown;
+    target: TargetRef;
+}
+/** What a target is: a door leaf, an item of the house or an object of the interactables kit (`kit`, with its public view in `pub`). */
+interface TargetRef {
+    id?: string;
+    type?: string;
+    kit?: unknown;
+    pub?: unknown;
+}
+/** A built house as the room lighting reads it (`House` is one). */
+interface LitHouse {
+    group?: THREE_NS.Object3D | null;
+    house: THREE_NS.Object3D;
+    lights: {
+        list: LightRequest[];
+    };
+    r: HouseRecord;
+    y0(f: number): number;
+    lightOn(room: unknown): boolean;
+    internal?: {
+        doorState?: Map<string, boolean>;
+    };
+}
+/** A rectangle of a light box in world x/z: `[x0, z0, x1, z1]`. */
+type BoxRect = [number, number, number, number];
+/** What a room light lit in the last update: the room (or outdoor lamp) key, its boxes, its y band, the exclusion box and its distance. */
+interface LightCrate {
+    k: unknown;
+    rects: BoxRect[];
+    y: [number, number];
+    exterior: boolean;
+    exclusion: BoxRect | null;
+    d: number;
+}
+/** The room lights of `lighting()`: one light per slot, given every frame to the rooms closest to the focus. */
+interface RoomLighting {
+    lights: readonly (LightHandle | THREE_NS.PointLight)[];
+    crates: (LightCrate | null)[];
+    n: number;
+    shadows: number;
+    stats: {
+        rooms: number;
+        external: number;
+        shadows: number;
+        shadowChanged: boolean;
+    };
+    /** Strength of the fake indirect light inside each box. */
+    indirect(v: number): void;
+    invalidate(): void;
+    update(houses: LitHouse | readonly (LitHouse | null | undefined)[] | null | undefined, focus: {
+        x: number;
+        y: number;
+        z: number;
+    }, op?: {
+        floorMax?: number;
+        focusHouse?: LitHouse;
+        focusRoom?: unknown;
+    }): RoomLighting['stats'];
+    dispose(): void;
+}
+/** The masks of the effect lights of a budget (`effectLights`). */
+interface EffectLighting {
+    update(houses: LitHouse | readonly (LitHouse | null | undefined)[] | null | undefined): void;
+}
+/** The interactables kit the game injected (`cfg.interactives`), bound: the modules, the adapter of the plan and the three.js side. */
+interface InteractablesRefs {
+    GI: typeof Interactables;
+    HH: HouseholdKit;
+    GT: {
+        createThreeAdapter(THREE: Three, options?: Record<string, unknown>): InteractablesGfx;
+    };
+    A: FloorplanAdapter;
+    gfx: InteractablesGfx;
+    items: boolean;
+    effects: boolean;
+    effectSink: unknown;
+    camera: unknown;
+    onEvent: ((event: Interactables.WorldEvent, pub: unknown) => void) | null;
+    onSeat: ((seat: KitSeat | null, event: Interactables.WorldEvent) => void) | null;
+}
+/** A kit object of the house: its plan entry, where it is drawn, its moving parts and its spec. */
+interface KitEntry {
+    id: string;
+    type: string;
+    entry: PlanEntry;
+    floor: number;
+    group: string;
+    root: THREE_NS.Group;
+    parts: Record<string, THREE_NS.Object3D>;
+    spec: Interactables.ObjectSpec;
+    /** The TV screen mesh, which swaps material. */
+    screen: THREE_NS.Mesh | null;
+    pos: Vec3$1;
+    ry: number;
+    origin: string;
+}
+/** The kit lamps of a room, its switches and whether it is lit (`ef`: some lamp on and powered). */
+interface KitRoomState {
+    id: string;
+    lamps: string[];
+    ef: boolean;
+    switches: string[];
+}
+/** Where the player sits or lies in the kit. */
+interface KitSeat {
+    object: string;
+    seatInfo: string;
+    pose: string;
+    eye: Vec3$1;
+    yaw: number;
+    pitch: number;
+    exitPoint: Vec3$1;
+    floor: number;
+    type: string | null;
+}
+/** The kit side of a house (`h.IV`). */
+interface InteractablesState {
+    k: InteractablesRefs;
+    plane: AdapterPlan;
+    world: Interactables.World;
+    water: WaterNetwork;
+    entries: Map<string, KitEntry>;
+    roots: KitEntry[];
+    replace: Set<string>;
+    roomStates: Map<string, KitRoomState>;
+    lampRoom: Map<string, string>;
+    anim: Map<string, {
+        object: string;
+        part: string;
+        target: number;
+        t0: number;
+    }>;
+    screens: Map<string, InteractablesScreen>;
+    efx: InteractablesEffects | null;
+    items: THREE_NS.Mesh | null;
+    itemsDirty: boolean;
+    itemsT: number;
+    dirty: boolean;
+    list: null;
+    listT: number;
+    t: number;
+    circuits: {
+        id: string;
+        room?: string;
+        outlets: string[];
+        switches: string[];
+        lamps: string[];
+    }[];
+    switchRooms: Set<string>;
+    warnings: string[];
+    tBuild: number;
+    mats: Record<string, THREE_NS.Material | undefined>;
+    added?: AddResult;
+    focus?: {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
+    isBlocked?: BlockedFn;
+    pub?: HouseInteractives;
+}
+/** What the house publishes of the interactables kit (`house.interactives`): the kit world and its tables, and the calls a game makes on it (in house coordinates). */
+interface HouseInteractives {
+    active: boolean;
+    world: Interactables.World;
+    plane: AdapterPlan;
+    kit: InteractablesRefs;
+    entries: Map<string, KitEntry>;
+    circuits: InteractablesState['circuits'];
+    roomStates: Map<string, KitRoomState>;
+    warnings: string[];
+    water: WaterNetwork;
+    /** TV screens (id -> kit screen). */
+    screens: Map<string, InteractablesScreen>;
+    /** The particle system (smoke). */
+    effects(): InteractablesEffects | null;
+    /** (x, z, floor) -> inside a wall (the check of the furniture doors' sweep). */
+    isBlocked: BlockedFn;
+    /** The kit objects one piece of furniture became (a sink: basin, cabinet, overhead). */
+    furnitureObjects(mid: string): KitEntry[];
+    target(eye: Eye, options?: KitTargetOptions): KitInteractionTarget | null;
+    interact(eye: Eye, options?: KitTargetOptions): boolean;
+    interactables(): {
+        id: string;
+        type: string;
+        floor: number;
+        pos: Vec3$1;
+        radius: number;
+        label: string;
+        act: () => boolean;
+    }[];
+    /** Where the player sits or lies, if they do. */
+    seatInfo(): KitSeat | null;
+    sit(object: string, seat: string): boolean;
+    stand(): Vec3$1 | null;
+    /** Opens (`target` truthy) or closes all the doors and drawers of a piece of furniture. */
+    opens(mid: string, target: unknown): void;
+    /** Reads a breaker (no `on`) or sets it. */
+    breaker(circuit: string, on?: unknown): boolean;
+    lightOn(roomId: string): boolean | null;
+    light(roomId: string, on: unknown): void;
+    /** Whether a kit animation is running. */
+    animate(): boolean;
+}
+/** A house being built or played, as the kit side reads it (the per-house state `enter(h)` swaps in). */
+interface HouseInstance {
+    ctx: BuildContext;
+    inter: InteractiveState;
+    state: SavedHouseState;
+    mirrors: MirrorState;
+    quality: 'high' | 'game';
+    /** Distance LOD now (0 full, 1 without the small pieces, 2 hidden) and the least the draw budget allows. */
+    lodCurrent: number;
+    lodMin: number;
+    IV?: InteractablesState | null;
+    groups?: Record<string, THREE_NS.Group>;
+    root?: THREE_NS.Group;
+    house?: THREE_NS.Group;
+    houseGroup: THREE_NS.Group;
+    destruction?: {
+        breach: {
+            setLod(n: number): void;
+        };
+    };
+}
+/** A kit object as an interaction target. */
+interface KitTarget extends TargetRef {
+    kit: true;
+    id: string;
+    type: string;
+    object: KitEntry;
+    item: Interactables.Interactable;
+    floor: number;
+    pos: number[];
+    text(): string;
+}
+/** The best kit target of an eye. */
+type KitInteractionTarget = InteractionTarget & {
+    target: KitTarget;
+};
+/** Options of the kit target: reach, cone and a filter of the candidates. */
+interface KitTargetOptions {
+    reach?: number;
+    cone?: number;
+    exclude?: (E: KitEntry, k: Interactables.Interactable) => boolean;
+}
+/** A text label of the plan view: a room name or a type with no model. */
+interface HouseLabel {
+    pos: THREE_NS.Vector3;
+    text: string;
+    group: string;
+    type: string;
+    floor?: number;
+}
+/** Gutters, downpipes and drains the roof drew (`house.gutters`). */
+interface GutterInfo {
+    /** Each gutter: floor, side of the roof, axis it runs along, from `a` to `b` at `p` across, at height `y`. */
+    gutters: {
+        f: number;
+        side: string;
+        axis: string;
+        a: number;
+        b: number;
+        p: number;
+        y: number;
+    }[];
+    /** Each downpipe: floor, place, bottom and top, and the drain it ends in (none when it floats over a lower roof). */
+    downpipes: {
+        f: number;
+        x: number;
+        z: number;
+        y0: number;
+        y1: number;
+        drain: [number, number] | null;
+        hornBox?: boolean;
+    }[];
+    drains: {
+        x: number;
+        z: number;
+    }[];
+}
+/** The plants the vegetation drew (`house.vegetation`). */
+interface VegetationInfo {
+    plants: number;
+    triangles: number;
+    colliders: (Vegetation.LotColliderData & {
+        y: number;
+        group: string;
+    })[];
+    lodCounts: number[];
+    materials: VegetationThree.VegetationMaterials;
+}
+/** What one build of a house knows while it draws (`shared.ctx`): the record, its tables and what each module collected. */
+interface BuildContext {
+    mv: Props3d;
+    types: TypeTable;
+    r: HouseRecord;
+    /** The colour roles of the palette, `0xrrggbb` (`r.colors`, its `meta` aside). */
+    colors: Record<string, Hex>;
+    cut: boolean;
+    night: boolean;
+    labels: HouseLabel[];
+    colliders: BoxCollider[];
+    /** How many of the colliders are walls (they come first). */
+    wallColliders: number;
+    stairs: StairRecord[];
+    noTerrain: boolean;
+    roomById: Record<string, HouseRoom>;
+    pieces: Map<string, PieceRecord>;
+    pieceObjects: Map<string, THREE_NS.Object3D[]>;
+    structureIndex: Record<string, StructurePart>;
+    panelView: PanelView;
+    panelsOf: Map<string, StructurePart[]>;
+    showPillars: boolean;
+    apartment: boolean;
+    /** Apartment building: floors, the unit's floor and the unit index. */
+    pa: number;
+    pf: number;
+    pu: number;
+    showBuilding: boolean;
+    limits: {
+        x0: number;
+        z0: number;
+        x1: number;
+        z1: number;
+    };
+    veg: VegetationContext | null;
+    vegInfo: VegetationInfo | null;
+    iv: InteractablesState | null;
+    leaves: DoorLeaf[];
+    /** Groups of the `part:` contract by name (`laundry_<seed>`, `mailbox_<id>`). */
+    parts: Record<string, THREE_NS.Object3D>;
+    clotheslines: unknown[];
+    animateDoorsOn: boolean;
+    waterTankPos?: {
+        x: number;
+        z: number;
+        y: number;
+        group: string;
+    };
+    roofRects: RoofRect[];
+    noPiece: boolean;
+    _flights?: {
+        r: HouseRecord;
+        l: Flight[];
+    };
+    solarInfo: SolarInfo | null;
+    electricalInfo: ElectricalInfo | null;
+    gutter: GutterConfig;
+    gutterInfo: GutterInfo | null;
+    /** Roof planes of the plan (`res.roof.panes`). */
+    panes: {
+        id: string;
+        aabb?: number[];
+        [extra: string]: unknown;
+    }[];
+    lights: LightRequest[];
+    unitRy?: number;
+    unitInverse: THREE_NS.Matrix4;
+    outbuildingList?: Outbuilding[];
+    tBuild: number;
+    /** Types with no builder, and how many items of each. */
+    noModel: Map<string, number>;
+}
+/** The state a house keeps between builds (`newState()`): doors, moving pieces, water and the kit world. */
+interface SavedHouseState {
+    doors: Map<string, boolean>;
+    inter: Map<string, number | boolean>;
+    water?: WaterState | null;
+    iv?: Interactables.WorldState | null;
+}
+
+/**
+ * The kernel `K` is the closure the team's Casa3DSDK kept in one function: every installer of a module reads what the earlier ones
+ * defined from it and adds what it defines (`Object.assign(K, ...)`). `Shared` holds the per-house state `enter(house)` swaps.
+ *
+ * The members are typed module by module (`KernelGeometry`, ...). Until every installer is typed, the index signature keeps the members
+ * of the modules not yet typed reachable; it goes away with the last one (docs/migracao-typescript.md). The modules already typed are
+ * checked with `strict` by `tsconfig.strict.json`.
+ */
+
+type Three = typeof THREE_NS;
+type Vec3$1 = [number, number, number];
+/** A colour as three.js takes it: `0xrrggbb`. */
+type Hex = number;
+/** Atlas cell of a face (`u0..v1`), its rotation in quarter turns, a mirror flag and a per-vertex colour multiplier. */
+interface UvRect {
+    u0: number;
+    v0: number;
+    u1: number;
+    v1: number;
+    rot?: number;
+    fx?: boolean | number;
+    vc?: (x: number, z: number) => readonly number[];
+}
+/** A destruction piece being drawn: the meshes record where it starts so a hit finds it again. */
+interface PieceRecord {
+    id: string;
+    mat: string;
+    role: string | null;
+    floor?: number;
+    [extra: string]: unknown;
+}
+/** A real mirror to assemble at the end of the build (`furniture/fixtures` writes it, `mirrors.ts` assembles it). */
+interface MirrorRecord {
+    x: number;
+    y: number;
+    z: number;
+    ry: number;
+    w: number;
+    h: number;
+    room: unknown;
+    floor?: number;
+    parent: string;
+}
+/** The frame an item is drawn in: where it stands (`x`, `z`, `ry`, `base` floor height, `y` mounting height) and its palette. */
+interface Frame {
+    x: number;
+    z: number;
+    ry: number;
+    base: number;
+    y?: number;
+    floor?: number;
+    /** Id of the room the item stands in. */
+    room?: string | null;
+    lampId?: string;
+    palette?: Record<string, Hex>;
+}
+/**
+ * A furniture item being drawn (the `M` every builder takes): its frame, its size, and what the house gave it (colour, seed, room).
+ * Builders read other flags by name.
+ */
+interface Mount extends Frame {
+    w: number;
+    d: number;
+    h: number;
+    id?: string;
+    seed?: string | number;
+    color?: Hex;
+    on?: boolean;
+    ceiling?: number;
+    typeWith?: string | null;
+    /** Hose of a wall tap, as points from the tap (`furniture/yard`). */
+    hose?: number[][];
+    u?: number;
+    v?: number;
+    [extra: string]: unknown;
+}
+/** A real light a builder asks for (`api.light`); the lighting turns it into a lamp. */
+interface LightRequest {
+    x: number;
+    y: number;
+    z: number;
+    color: Hex;
+    range: number;
+    type: string;
+    floor?: number;
+    group: string;
+    base: number;
+    /** The room id of the item that asked for it (a lamp of the lot has none). */
+    room?: string | null;
+    id?: string;
+    roomId?: string | null;
+    [extra: string]: unknown;
+}
+/** What a builder draws with, in the item's frame (`makeApi()`); the lamps and curtains swap it for a recorder. */
+interface FurnitureApi {
+    box(M: Frame, mat: string, x: number, y: number, z: number, w: number, h: number, d: number, color: Hex, ry?: number, rx?: number, rz?: number): void;
+    cylinder(M: Frame, mat: string, x: number, y: number, z: number, r: number, h: number, color: Hex, rx?: number, rz?: number, seg?: string): void;
+    leaf(M: Frame, x: number, y: number, z: number, w: number, h: number, color: Hex, ry?: number, rx?: number): void;
+    plane(M: Frame, mat: string, x: number, y: number, z: number, w: number, h: number, color: Hex, ry?: number, rx?: number, rz?: number, uv?: UvRect | null): void;
+    light(M: Frame, x: number, y: number, z: number, color: Hex, range: number, type: string, ex?: Record<string, unknown> | null): void;
+}
+/** Variations a builder takes (`FURNITURE.cabinet(M, A, { doors: 2 })`). */
+interface BuilderOptions {
+    color?: Hex;
+    top?: Hex;
+    useColor?: boolean;
+    ceiling?: number;
+    doors?: number;
+    glass?: boolean;
+    iron?: boolean;
+    open?: boolean;
+    crates?: boolean;
+    round?: boolean;
+    tablecloth?: boolean;
+    noChairs?: boolean;
+    oneSide?: boolean;
+    headboard?: boolean;
+    backrest?: boolean;
+    column?: boolean;
+    items?: boolean;
+    low?: boolean;
+    lowCrown?: boolean;
+    noBasin?: boolean;
+    noOverhead?: boolean;
+    register?: boolean;
+    shrub?: boolean;
+    stool?: boolean;
+    [flag: string]: unknown;
+}
+/** Draws one furniture item with the api, in the item's frame. */
+type FurnitureBuilder = (M: Mount, A: FurnitureApi, o?: BuilderOptions) => void;
+/** The `Reflector` of three's examples: a plane that mirrors the scene. */
+type ReflectorClass = new (geometry: THREE_NS.BufferGeometry, options: Record<string, unknown>) => THREE_NS.Mesh;
+/**
+ * An item of the house record (`r.items`, `r.stateItems`): the placed item of `game-floorplan` (its `ResultItem`), with the fields the
+ * state plugins add (`polygon` of a ground cover, an open door, the hose of a gas cylinder).
+ */
+interface HouseItem {
+    id: string;
+    type: string;
+    category: string;
+    x: number;
+    z: number;
+    ry: number;
+    w: number;
+    d: number;
+    h: number;
+    y: number;
+    room: string | null;
+    floor: number;
+    outdoor: boolean;
+    color?: number | string;
+    overhead?: boolean;
+    polygon?: number[][];
+    doorOpen?: boolean;
+    hose?: number[][];
+    assembly?: unknown;
+    /** Storeys a stair connects, or the id of the item this one serves. */
+    link?: {
+        from: number;
+        to: number;
+    } | string;
+    [extra: string]: unknown;
+}
+/** The builder picked for a furniture type, and where it came from (`props3d`, `game`...). */
+interface TypeEntry {
+    f: FurnitureBuilder;
+    source?: string;
+    [extra: string]: unknown;
+}
+/** Furniture type -> its builder (`typeTable(props)`). */
+type TypeTable = Record<string, TypeEntry>;
+/** What has plan rectangles: its `parts`, or its own `u0..v1` when it has none (a room, a lot zone). */
+interface RoomRects {
+    parts?: readonly Rect[] | null;
+    u0: number;
+    v0: number;
+    u1: number;
+    v1: number;
+}
+/** A room of the house record; the open areas of a plugin may be marked `outdoor`, and the rooms of an outbuilding name it. */
+type HouseRoom = ResultRoom & {
+    outdoor?: boolean;
+    outbuilding?: unknown;
+    [extra: string]: unknown;
+};
+/** A wall of the house record, with the structure fields the structure extension adds (`id`, `material`, `role`). */
+interface HouseWall extends PlanWall {
+    id?: string;
+    material?: string;
+    role?: string;
+    outbuilding?: string;
+}
+/** The house record the renderer draws: the `generate` result of `game-floorplan`, with the fields the plugins add to its rooms, walls and items. */
+interface HouseRecord extends Omit<FloorplanResultFields, 'rooms' | 'walls' | 'doors' | 'windows' | 'items' | 'stateItems'> {
+    rooms: HouseRoom[];
+    walls: HouseWall[];
+    doors: HouseDoor[];
+    windows: HouseWindow[];
+    items: HouseItem[];
+    stateItems: HouseItem[];
+    /** Utilities of `game-floorplan-structure` (empty until its extension ran). */
+    utilities?: Partial<Utilities>;
+    /** Walk-in yard buildings of `game-floorplan-structure`. */
+    outbuildings?: Outbuilding[];
+    /** The water tank of `game-floorplan-structure`. */
+    waterTank?: WaterTank | null;
+    /** The construction and the structure of `game-floorplan-structure` (its `extendWithStructure`). */
+    construction?: Construction;
+    structure?: Structure;
+    [extension: string]: unknown;
+}
+/** A door of the house record; an outbuilding's door names it, and has no stair steps or type of its own. */
+interface HouseDoor extends Omit<PlanDoor, 'type' | 'steps'> {
+    type?: string;
+    steps?: number;
+    outbuilding?: string;
+}
+/** A window of the house record; an outbuilding's window names it. */
+interface HouseWindow extends PlanWindow {
+    outbuilding?: string;
+}
+/** A flight of stairs between two storeys, once (the house record repeats the stair item on both): its plan box, the landing under its first steps when
+ * another flight stands below it, and the flat top of a flight with none above (`LP` long). */
+interface Flight {
+    m: HouseItem;
+    from: number;
+    to: number;
+    rect: Rect;
+    landing?: Rect;
+    top?: Rect;
+    LP?: number;
+}
+/** A stair drawn in the house (`ctx.stairs`): its item, storeys, foot height, rise and plan box, and where its landing starts (share of its depth). */
+interface StairRecord {
+    m: HouseItem;
+    f: number;
+    to: number;
+    y0: number;
+    H: number;
+    rect: Rect;
+    landingPoint: number;
+}
+/** A box collider of the house (`ctx.colliders`): a wall, door, board, lot wall or gate on storey `f` (`-1`: the lot); `off` while a door is open. */
+interface BoxCollider {
+    type: string;
+    f: number;
+    x0: number;
+    z0: number;
+    x1: number;
+    z1: number;
+    piece?: string;
+    off?: boolean;
+    [extra: string]: unknown;
+}
+/** A door leaf group: its name and where its hinge stands. */
+interface LeafGroup {
+    name: string;
+    pos: number[];
+}
+/** A door of the house as it moves (`ctx.leaves`): its state, its leaf groups and handles, and its collider. */
+interface DoorLeaf {
+    id: string;
+    floor: number;
+    type: string;
+    open: boolean;
+    t: number;
+    blockedFlag: boolean;
+    locked: boolean;
+    handleNames: string[];
+    hT: number;
+    cx: number;
+    cz: number;
+    visH: number;
+    groups: LeafGroup[];
+    col: BoxCollider | null;
+    minScale?: number;
+    rot?: number;
+    /** The leaf's groups once the build placed them. */
+    gs: THREE_NS.Group[];
+    /** The handle pieces (`linkDoorLeaves`). */
+    handles?: InteractivePiece[];
+    /** Where the door's movement is: turning the handle, swinging, letting the handle rise, or rattling when locked. */
+    phase?: 'handle' | 'swing' | 'rise' | 'rattle' | null;
+    anim?: boolean;
+    jig?: number;
+    [extra: string]: unknown;
+}
+/** A roof rectangle of the house (`ctx.roofRects`): where it is and, once drawn, the geometry the solar panels rest on. */
+interface RoofRect {
+    f: number;
+    r: Rect;
+    touchesU?: number[];
+    slab?: boolean;
+    outbuilding?: string;
+    yb?: number;
+    tp?: number;
+    gable?: boolean;
+    alongX?: boolean;
+    exterior?: Rect;
+    rm?: number;
+}
+/** Gutter settings of a house (`ctx.gutter`), drawn from its seed. */
+interface GutterConfig {
+    on: boolean;
+    rnd: () => number;
+    color: Hex;
+    bad: boolean;
+    fallback: boolean;
+    ncond?: number;
+    nbuz?: number;
+    bz?: Set<string>;
+}
+/** Water in a house's tank: kept in the house's state so it survives a rebuild (night, cut). */
+interface WaterState {
+    cap: number;
+    level: number;
+    rate: number;
+}
+/** The water network of a house (`house.water`): the tank level and the points that draw from it. */
+interface WaterApi {
+    capacity: number;
+    points: Record<string, PlumbingPoint>;
+    itemPoint: Record<string, string>;
+    runs: PlumbingRun[];
+    level(): number;
+    fraction(): number;
+    /** Draws litres from a point; returns the litres delivered. */
+    consume(pointId: string, liters: number): number;
+    fill(liters: number): number;
+    /** Litres per second; 0 stops it. */
+    leak(rate: number): number;
+    readonly leakage: number;
+    readonly dry: boolean;
+    on(ev: 'dry' | 'full', fn: (api: WaterApi) => void): () => void;
+    off(ev: 'dry' | 'full', fn: (api: WaterApi) => void): void;
+    step(dt: number): void;
+}
+/** The solar panels and inverter as the game sees them (`house.solar`). */
+interface SolarInfo {
+    type: string;
+    panels: {
+        id: string;
+        pos: Vec3$1;
+        tilt: number;
+        w: number;
+        length: number;
+    }[];
+    inverter: {
+        id: string;
+        pos: Vec3$1;
+        side: string;
+        link: string;
+    } | null;
+}
+/** The electrical structure as the game sees it (`house.electrical`). */
+interface ElectricalInfo {
+    pole: {
+        pos: Vec3$1;
+        h: number;
+    } | null;
+    meter: {
+        id: string;
+        pos: Vec3$1;
+        place: string;
+    } | null;
+    panel: {
+        id: string;
+        pos: Vec3$1;
+        normal: Vec3$1;
+        room: string;
+        breakers: number;
+    } | null;
+    conduits: string[];
+    outlets: {
+        id: string;
+        pos: Vec3$1;
+        normal: Vec3$1;
+        room: string;
+        floor: number;
+        type: string;
+        voltage: number;
+    }[];
+    switches: {
+        id: string;
+        pos: Vec3$1;
+        normal: Vec3$1;
+        room: string;
+        floor: number;
+        controls: string[];
+    }[];
+    circuits: unknown[];
+    exposed: boolean;
+}
+
+type AreaText = {
+    group: string;
+    name: string;
+    controls: Record<'package' | 'template' | 'state' | 'seed' | 'quality' | 'lod' | 'houses' | 'budget' | 'floor_view' | 'hit', string>;
+    hints: Record<'template' | 'houses' | 'budget' | 'lod' | 'floor_view' | 'hit', string>;
+    actions: Record<'build' | 'enter' | 'up' | 'down' | 'door' | 'strike' | 'reset' | 'clear', string>;
+    options: {
+        quality: Record<string, string>;
+        lod: Record<string, string>;
+        floor_view: Record<string, string>;
+        hit: Record<string, string>;
+        state: Record<string, string>;
+    };
+    layers: Record<'roof' | 'lot' | 'night' | 'room_lights', string>;
+    metrics: Record<'houses' | 'parts' | 'standing' | 'broken' | 'holes' | 'draw_calls' | 'triangles' | 'lod' | 'floor' | 'doors_open' | 'target' | 'planned', string>;
+    sheet: {
+        kicker: string;
+        title: string;
+        template: string;
+        seed: string;
+        state: string;
+        floors: string;
+        size: string;
+        parts: string;
+        look: string;
+        none: string;
+        no_engine: string;
+    };
+    specimens: Record<string, string>;
+    scenarios: Record<string, string>;
+    steps: Record<'built' | 'no_engine' | 'entered' | 'floor' | 'no_floor' | 'door' | 'no_door' | 'strike' | 'no_aim' | 'cleared' | 'reset' | 'one_pillar_broke' | 'slabs_whole' | 'no_slab_fell' | 'two_slab_fell' | 'two_roof_fell' | 'partition_broke' | 'slab_stayed' | 'glass_hole' | 'glass_broke' | 'walls_whole' | 'tank_hole' | 'tank_leaked' | 'gas_exploded' | 'gas_damaged', string>;
+};
+
+/** The room as these scenarios use it: its destruction world, and `spawn` of an item at a point (its root carries the specimen's spec in `userData.floorplanSpec`). */
+interface AreaRoom {
+    world: DestructionWorld;
+    spawn(item: string, position: [number, number, number], rotationY: number): {
+        objectId: string;
+        root: {
+            userData: Record<string, unknown>;
+        };
+    };
+}
+/** What the room hands a scenario (`ScenarioContext` of game-test-room), narrowed to what these use. */
+interface AreaContext {
+    room: AreaRoom;
+    step(seconds: number): void;
+    expect(condition: boolean, label: string, data?: Record<string, unknown>): void;
+}
+type Vec3 = readonly [number, number, number];
+/** Where the team's page lays its specimens (the arena has 14 m of half width). */
+declare const SPECIMEN_AT: Vec3;
+/**
+ * The six structural scenarios of the team's house area (sala-de-testes/area-casas, L3833-3868), same ids and same checks, on the specimens the area builds: destroy a pillar, two pillars, a partition,
+ * shoot a window, puncture the water tank, set the gas bottle on fire. The hits are the team's (3 MJ blunt on a pillar, 600 J 9 mm on the glass and the tank, 900 C fire on the bottle). A scenario
+ * passes when every check holds; the names of the checks are in `text.steps`.
+ */
+declare function createHouseScenarios(text: AreaText, at?: Vec3): Array<ModuleScenario<AreaContext>>;
+
+/** The part of the floorplan engine (`engine` of `@adatechnology/game-floorplan`, with the content packs the page registered) the test area reads. */
+interface FloorplanEngineLike {
+    generate(template: string, options?: {
+        seed?: number;
+        state?: string;
+        floors?: number;
+    }): FloorplanResult;
+    listTemplates(): Array<{
+        id: string;
+        name?: string;
+        floors?: number;
+        floorRange?: number[] | null;
+    }>;
+    listStates(): string[];
+    translate?(namespace: string, key: string, locale?: string, vars?: Record<string, string | number>): string;
+}
+/** A pack of templates the bench lists together (residential, commercial, rural, post-apocalyptic). Ids the engine does not know are left out. */
+interface TemplateGroup {
+    id: string;
+    /** Name by locale (`en`, `pt-BR`); the id when absent. */
+    name?: Record<string, string>;
+    templates: readonly string[];
+}
+/** A small house the area lays out for the structural scenarios: the structure spec of a template, drawn as boxes named by part (the team's HouseArea items). */
+interface SpecimenDef {
+    /** Item id (`house_casa_portico`): the scenarios and the golden name them. */
+    id: string;
+    template: string;
+    seed?: number;
+    state?: string;
+    /** The bearing walls only close: a frame of pillars and beams carries the building. */
+    portico?: boolean;
+    /**
+     * How the structure is sized (`toDestructibleSpec`): `safety` is the share of its capacity a pillar uses at rest, `redundancy` the most it uses after one other pillar is lost.
+     * A slab on four pillars is held by the sum of the four: with `safety` 0.72 and `redundancy` 0.97 it holds one loss (0.96) and falls with two.
+     */
+    sizing?: {
+        safety?: number;
+        redundancy?: number;
+        safetyOthers?: number;
+    };
+    /** Name by locale; the text of the area when absent. */
+    name?: Record<string, string>;
+}
+interface FloorplanTestOptions {
+    locale?: string;
+    /** The engine with the packs registered. Without it the module has no houses to build. */
+    engine?: FloorplanEngineLike;
+    /** The packs the bench lists, in order. Default: every template of the engine in one group. */
+    groups?: readonly TemplateGroup[];
+    /** The states the bench offers (`normal`, `fortified`, `abandoned`). Default: the engine's. */
+    states?: readonly string[];
+    /** The room's destruction world and renderer (`room.world`, `room.renderer`): the houses built here register in them, so every shot, blast and fire of the room reaches the walls. */
+    world?: DestructionWorld;
+    renderer?: DestructionRenderer;
+    /** Passed to the house renderer: `fleet`, `reflector`, `interactives`, `vegetation`, `props`, `textures`... */
+    house?: Partial<HouseRendererOptions>;
+    /** Template and seed the bench starts with. */
+    template?: string;
+    seed?: number;
+    /** Specimens of the structural scenarios; default the five of the team's house area, those whose template the engine has. */
+    specimens?: readonly SpecimenDef[];
+    /** Half size of the room's arena (`createTestRoom({ arenaSize })`), 14 by default: where the houses are laid. */
+    arenaSize?: number;
+    /** Where the specimens stand for the scenarios (the team's page: `[-5, 0, -11]`). */
+    specimenAt?: readonly [number, number, number];
+}
+
+declare const FLOORPLAN_AREA_ID = "floorplan_area";
+type Placed = {
+    house: House;
+    plan: FloorplanResult;
+    seed: number;
+    width: number;
+    depth: number;
+};
+/**
+ * The houses test area as a `TestableModule`: any typology of the content packs the page registered (residential, commercial, rural, post-apocalyptic) built with game-floorplan-three from a seed, laid
+ * in the room, with the player able to walk in (walls and closed doors stop the walk), use the doors (E), go up and down the floors, see the level of detail (manual, by distance, or shared among a row
+ * of houses by a draw-call budget), and hit the walls with what the room throws (its tools, or the bench's hit): the houses register in the room's destruction world, so shots, blows, blasts and fire
+ * reach the structure and the room's renderer draws the fracture, the brick courses and the collapse. Dust and sparks are the room's own effects: this module draws no particles.
+ * Everything that is a pack of content comes in by option: this package knows no game.
+ */
+declare function createFloorplanTestModule(options?: FloorplanTestOptions): TestableModule<AreaContext> & {
+    readonly houses: readonly Placed[];
+    build(): void;
+    clear(): void;
+    groups(): readonly TemplateGroup[];
+};
+
+/**
+ * The five items of the team's house area (sala-de-testes/area-casas): a frame house, a whole house, a wood-frame house, a log cabin and a tent. The team's frame house is its single-storey house A; here it is the
+ * two-storey townhouse, because the ceiling slab of the single-storey plan keeps standing on its bearing partitions when two pillars go (see evidence, T2.6). The frame house is a reinforced concrete frame (T10 §12): the slabs
+ * are cut into panels on real beams, the pillars are sized (`sizing`) to carry the load of the ones lost, and the beams to carry the span the lost pillar leaves: one pillar lost and the slab stays,
+ * the two ends of a side lost and that side comes down (owner, 2026-10-24: "4 pilares e a sustentação é a soma dos 4"; 2026-10-25: the real structure of the houses).
+ */
+declare const DEFAULT_SPECIMENS: readonly SpecimenDef[];
+/** What the area keeps of a built specimen: the structure spec the house draws (what the destruction world is given) and the plan it came from. */
+interface SpecimenSpec {
+    readonly spec: DestructibleSpec;
+    readonly plan: FloorplanResult;
+}
+/**
+ * The structure spec of a specimen: the engine draws the plan, the house renderer draws the house, and the house describes its structure (`house.structure.spec`) with what the water tank holds and
+ * what makes the gas bottle explode. The spec is cached per three.js namespace and specimen; each call hands out a copy.
+ */
+declare function specimenSpec(THREE: Three, engine: FloorplanEngineLike, def: SpecimenDef, houseOptions?: Partial<HouseRendererOptions>): SpecimenSpec;
+/**
+ * One box (or cylinder, sphere) per part, named by the part id and coloured by its material, in the space of the house (the origin at the corner of the plan): what the team's house area draws, so the
+ * room binds each mesh to the part of the same name. The anchored terrain slab is left out (the room has a floor).
+ */
+declare function buildSpecimenMeshes(THREE: Three, spec: DestructibleSpec): THREE_NS.Group;
+
+export { type AreaContext as A, type BuildOptions as B, DEFAULT_SPECIMENS as D, FLOORPLAN_AREA_ID as F, type HouseRendererOptions as H, type LightingOptions as L, type Messages as M, type RoomRects as R, SPECIMEN_AT as S, type Three as T, type HouseRenderer as a, type HouseRecord as b, type Damageable as c, type FloorplanEngineLike as d, type FloorplanTestOptions as e, type House as f, type HouseBoxCollider as g, type HouseFurnitureCollider as h, type HouseInteractable as i, type HouseInteractives as j, type HousePart as k, type HousePlan as l, type HousePoint as m, type HouseTargetOptions as n, type SpecimenDef as o, type TemplateGroup as p, type Translate as q, buildSpecimenMeshes as r, createFloorplanTestModule as s, createHouseScenarios as t, createTranslator as u, en as v, locales as w, ptBR as x, specimenSpec as y };