@pascal-app/core 1.0.3 → 1.0.5

package/dist/lib/floor-room-faces.d.ts

@@ -0,0 +1,5 @@
+import { type ExtractedRoom } from './room-graph.js';
+import type { BoundaryNode } from './room-topology-index.js';
+export declare function floorRoomFaces(boundaries: BoundaryNode[]): ExtractedRoom[];
+export declare function roomPolygonKey(polygon: readonly (readonly number[])[], holes?: readonly (readonly (readonly number[])[])[]): string;
+//# sourceMappingURL=floor-room-faces.d.ts.map

package/dist/lib/floor-room-faces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-room-faces.d.ts","sourceRoot":"","sources":["../../src/lib/floor-room-faces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAgB,MAAM,cAAc,CAAA;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAIzD,wBAAgB,cAAc,CAAC,UAAU,EAAE,YAAY,EAAE,GAAG,aAAa,EAAE,CAmB1E;AAED,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACvC,KAAK,GAAE,SAAS,CAAC,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,EAAO,GACtD,MAAM,CAOR"}

package/dist/lib/floor-room-faces.js

@@ -0,0 +1,29 @@
+import { extractRooms } from './room-graph.js';
+const facesByGeometry = new Map();
+export function floorRoomFaces(boundaries) {
+    const ordered = [...boundaries].sort((a, b) => a.id.localeCompare(b.id));
+    const signature = JSON.stringify(ordered.map((boundary) => [
+        boundary.id,
+        boundary.type,
+        boundary.start,
+        boundary.end,
+        boundary.type === 'wall'
+            ? [boundary.curveOffset, boundary.thickness, boundary.justification]
+            : null,
+    ]));
+    const cached = facesByGeometry.get(signature);
+    if (cached)
+        return cached;
+    const faces = extractRooms(ordered);
+    facesByGeometry.set(signature, faces);
+    if (facesByGeometry.size > 64)
+        facesByGeometry.delete(facesByGeometry.keys().next().value);
+    return faces;
+}
+export function roomPolygonKey(polygon, holes = []) {
+    const ring = (points) => points
+        .map(([x, z]) => `${Math.round(x * 1e6)},${Math.round(z * 1e6)}`)
+        .sort()
+        .join(';');
+    return [ring(polygon), ...holes.map(ring).sort()].join('|');
+}

package/dist/lib/floor-script.d.ts

@@ -0,0 +1,24 @@
+import type { AnyNode, CompiledGeometryScript, ZoneFloorScript } from '../schema/index.js';
+type SceneNodes = Readonly<Record<string, AnyNode>>;
+/**
+ * What a room's floor script is built for, in level coordinates and metres: the room's walking
+ * floor (its outline inside the wall faces, on its floor plate) as `polygon` with its `holes`, and
+ * the plate's top, `elevation`. The module lays its boards out over it; the compiler cuts the build
+ * to the polygon less its holes.
+ */
+export type FloorScriptInputs = {
+    polygon: [number, number][];
+    holes: [number, number][][];
+    elevation: number;
+};
+/**
+ * The floor a room's script builds on, or null when the room has none (no floor plate: `hasFloor`
+ * false, or not enclosed yet). Several pieces (a floor cut through by a wall) give the largest.
+ */
+export declare function floorScriptInputs(nodes: SceneNodes, zoneId: string): FloorScriptInputs | null;
+/** The key a floor script keeps of the floor it was built for (`ZoneFloorScript.inputs`). */
+export declare function floorScriptInputsKey(inputs: FloorScriptInputs): string;
+/** A compile as the zone keeps it: its script source and the key of the floor it was built for. */
+export declare function floorScriptRecord(compiled: CompiledGeometryScript, inputs: FloorScriptInputs, previous?: ZoneFloorScript): ZoneFloorScript;
+export {};
+//# sourceMappingURL=floor-script.d.ts.map

package/dist/lib/floor-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-script.d.ts","sourceRoot":"","sources":["../../src/lib/floor-script.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAejF,KAAK,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAEnD;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;IAC3B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,CAAA;IAC3B,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAQD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CA0B7F;AAED,6FAA6F;AAC7F,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAEtE;AAED,mGAAmG;AACnG,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,sBAAsB,EAChC,MAAM,EAAE,iBAAiB,EACzB,QAAQ,CAAC,EAAE,eAAe,GACzB,eAAe,CAEjB"}

package/dist/lib/floor-script.js

@@ -0,0 +1,51 @@
+import { DEFAULT_SLAB_ELEVATION } from '../schema/nodes/slab.js';
+import { scriptSource } from './geometry-script-node.js';
+import { levelWallCover, plateLevelContext } from './plate-surface.js';
+import { area, difference, intersection, union, } from './polygon-boolean.js';
+import { roomFloorPlate } from './room-floor-plate.js';
+import { scriptInputsKey } from './script-inputs-key.js';
+const round = (value) => Math.round(value * 1e4) / 1e4;
+const roundRing = (ring) => ring.map(([x, z]) => [round(x), round(z)]);
+/** Inputs by wall cover (memoised per wall signature in `levelWallCover`), then by room and plate. */
+const inputsByCover = new WeakMap();
+/**
+ * The floor a room's script builds on, or null when the room has none (no floor plate: `hasFloor`
+ * false, or not enclosed yet). Several pieces (a floor cut through by a wall) give the largest.
+ */
+export function floorScriptInputs(nodes, zoneId) {
+    const zone = nodes[zoneId];
+    if (zone?.type !== 'zone' || zone.polygon.length < 3 || !zone.parentId)
+        return null;
+    const context = plateLevelContext(nodes[zone.parentId] ?? null, (id) => nodes[id]);
+    const plate = roomFloorPlate(context.slabs, zone.id);
+    if (!plate || plate.polygon.length < 3)
+        return null;
+    const cover = levelWallCover(context.walls);
+    const cache = inputsByCover.get(cover) ?? new Map();
+    inputsByCover.set(cover, cache);
+    const elevation = round(plate.elevation ?? DEFAULT_SLAB_ELEVATION);
+    const key = JSON.stringify([zone.polygon, zone.holes, plate.polygon, plate.holes, elevation]);
+    if (cache.has(key))
+        return cache.get(key);
+    const room = union([{ outer: zone.polygon, holes: zone.holes ?? [] }]);
+    const floor = intersection(cover.length ? difference(room, cover) : room, union([{ outer: plate.polygon, holes: plate.holes ?? [] }]));
+    let largest;
+    for (const piece of floor)
+        if (!largest || area([piece]) > area([largest]))
+            largest = piece;
+    const inputs = largest
+        ? { polygon: roundRing(largest.outer), holes: largest.holes.map(roundRing), elevation }
+        : null;
+    if (cache.size > 64)
+        cache.delete(cache.keys().next().value);
+    cache.set(key, inputs);
+    return inputs;
+}
+/** The key a floor script keeps of the floor it was built for (`ZoneFloorScript.inputs`). */
+export function floorScriptInputsKey(inputs) {
+    return scriptInputsKey(JSON.stringify([inputs.polygon, inputs.holes, inputs.elevation]));
+}
+/** A compile as the zone keeps it: its script source and the key of the floor it was built for. */
+export function floorScriptRecord(compiled, inputs, previous) {
+    return { ...scriptSource(compiled, {}, previous), inputs: floorScriptInputsKey(inputs) };
+}

package/dist/lib/floor-step-finish.d.ts

@@ -0,0 +1,49 @@
+import type { ZoneNode } from '../schema/index.js';
+/**
+ * A room's steps — the riser faces where its floor drops to a lower one — are
+ * painted per doorway. Each riser is keyed by what it steps through: the door
+ * (or floor-anchored window) it sits under, else the lower room it looks at.
+ * A riser draws as `step:<ownerZoneId>/<key>`; `step:<ownerZoneId>` alone is
+ * the room scope, every step of the room.
+ *
+ * What a step shows, highest first:
+ *   1. an override for its doorway (`zone.floorStepOverrides`, exact step
+ *      index before the whole doorway)
+ *   2. the owning room's `floorStepFinish`
+ *   3. the owning room's floor finish
+ *
+ * An override belongs to its doorway, not to whichever room is higher. When a
+ * floor edit hands the step to the room on the other side, the override stays
+ * where it was painted and is read through from there, so the step keeps its
+ * colour; the next paint or erase of that step moves or clears it.
+ */
+export type FloorStepOverride = NonNullable<ZoneNode['floorStepOverrides']>[number];
+type StepZone = Pick<ZoneNode, 'id' | 'parentId' | 'floorStepOverrides'>;
+export declare function floorStepRole(zoneId: string, key?: string, step?: number): string;
+export declare function parseFloorStepRole(role: string): {
+    zoneId: string;
+    key: string | null;
+    step: number | null;
+} | null;
+/**
+ * Whether painting `target` paints the step mesh drawn as `role`: the room scope
+ * covers every step of the room, a doorway every step index of that doorway.
+ */
+export declare function floorStepRoleCovers(target: string, role: string): boolean;
+/** The override painting step `key` (`#step`) of `zone`, wherever it is stored. */
+export declare function floorStepOverrideFor<Z extends StepZone>(zone: Z, key: string, step: number | null, zones: readonly Z[]): FloorStepOverride | undefined;
+/** What a step of `zone` keyed `key` draws; `undefined` = the plate's own top. */
+export declare function resolveFloorStepFinish(zone: Pick<ZoneNode, 'id' | 'parentId' | 'floorStepOverrides' | 'floorStepFinish' | 'floor'>, key: string | null, step: number | null, zones: readonly StepZone[]): string | Record<string, unknown> | undefined;
+/**
+ * The rooms that change when step `key` of `owner` is painted (`finish`) or
+ * erased (`undefined`): the doorway's paint is dropped from every holder and,
+ * painting, written on the owner — one colour per doorway. No step index paints
+ * the whole doorway, so its per-step entries go too.
+ */
+export declare function withFloorStepOverride<Z extends StepZone>(owner: Z, key: string, step: number | null, finish: string | undefined, zones: readonly Z[]): Z[];
+/** `zone` without the overrides keyed by `keys` (deleted doors), or null when none go. */
+export declare function withoutFloorStepOverrideKeys<Z extends StepZone>(zone: Z, keys: ReadonlySet<string>): Z | null;
+/** `zone` with override keys naming a retired room renamed to its survivor, or null. */
+export declare function remapFloorStepOverrideKeys<Z extends StepZone>(zone: Z, remap: ReadonlyMap<string, string>): Z | null;
+export {};
+//# sourceMappingURL=floor-step-finish.d.ts.map

package/dist/lib/floor-step-finish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-step-finish.d.ts","sourceRoot":"","sources":["../../src/lib/floor-step-finish.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAA;AACnF,KAAK,QAAQ,GAAG,IAAI,CAAC,QAAQ,EAAE,IAAI,GAAG,UAAU,GAAG,oBAAoB,CAAC,CAAA;AAExE,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAGjF;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,GACX;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,IAAI,CAQpE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAOzE;AAwCD,mFAAmF;AACnF,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,QAAQ,EACrD,IAAI,EAAE,CAAC,EACP,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,KAAK,EAAE,SAAS,CAAC,EAAE,GAClB,iBAAiB,GAAG,SAAS,CAM/B;AAED,kFAAkF;AAClF,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,GAAG,UAAU,GAAG,oBAAoB,GAAG,iBAAiB,GAAG,OAAO,CAAC,EAC5F,GAAG,EAAE,MAAM,GAAG,IAAI,EAClB,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,KAAK,EAAE,SAAS,QAAQ,EAAE,GACzB,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAM9C;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,QAAQ,EACtD,KAAK,EAAE,CAAC,EACR,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,KAAK,EAAE,SAAS,CAAC,EAAE,GAClB,CAAC,EAAE,CAqBL;AASD,0FAA0F;AAC1F,wBAAgB,4BAA4B,CAAC,CAAC,SAAS,QAAQ,EAC7D,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,GACxB,CAAC,GAAG,IAAI,CAOV;AAED,wFAAwF;AACxF,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,QAAQ,EAC3D,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,CAAC,GAAG,IAAI,CAYV"}

package/dist/lib/floor-step-finish.js

@@ -0,0 +1,128 @@
+export function floorStepRole(zoneId, key, step) {
+    if (!key)
+        return `step:${zoneId}`;
+    return step === undefined ? `step:${zoneId}/${key}` : `step:${zoneId}/${key}#${step}`;
+}
+export function parseFloorStepRole(role) {
+    const match = /^step:([^/#]+)(?:\/([^/#]+)(?:#(\d+))?)?$/.exec(role);
+    if (!match)
+        return null;
+    return {
+        zoneId: match[1],
+        key: match[2] ?? null,
+        step: match[3] === undefined ? null : Number(match[3]),
+    };
+}
+/**
+ * Whether painting `target` paints the step mesh drawn as `role`: the room scope
+ * covers every step of the room, a doorway every step index of that doorway.
+ */
+export function floorStepRoleCovers(target, role) {
+    if (target === role)
+        return true;
+    const wide = parseFloorStepRole(target);
+    const mesh = parseFloorStepRole(role);
+    if (!(wide && mesh) || wide.zoneId !== mesh.zoneId)
+        return false;
+    if (!wide.key)
+        return true;
+    return wide.key === mesh.key && wide.step === null;
+}
+/**
+ * Every (room, key) pair that stores paint for the doorway `key` of `zone`'s
+ * steps: the owner itself, and whoever stored it before the owner changed — for
+ * a door, any other room keyed by the same door; for a step keyed by the lower
+ * room, that room keyed back by the owner.
+ */
+function doorwayHolders(zone, key, zones) {
+    const siblings = zones
+        .filter((other) => other.id !== zone.id && other.parentId === zone.parentId)
+        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    const lower = siblings.find((other) => other.id === key);
+    if (lower)
+        return [
+            { zone, key },
+            { zone: lower, key: zone.id },
+        ];
+    if (zones.some((other) => other.id === key))
+        return [{ zone, key }];
+    return [{ zone, key }, ...siblings.map((other) => ({ zone: other, key }))];
+}
+function pick(overrides, key, step) {
+    if (!overrides?.length)
+        return undefined;
+    return ((step === null
+        ? undefined
+        : overrides.find((entry) => entry.key === key && entry.step === step)) ??
+        overrides.find((entry) => entry.key === key && entry.step === undefined));
+}
+/** The override painting step `key` (`#step`) of `zone`, wherever it is stored. */
+export function floorStepOverrideFor(zone, key, step, zones) {
+    for (const holder of doorwayHolders(zone, key, zones)) {
+        const found = pick(holder.zone.floorStepOverrides, holder.key, step);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+/** What a step of `zone` keyed `key` draws; `undefined` = the plate's own top. */
+export function resolveFloorStepFinish(zone, key, step, zones) {
+    return ((key ? floorStepOverrideFor(zone, key, step, zones)?.finish : undefined) ??
+        zone.floorStepFinish ??
+        zone.floor?.finish);
+}
+/**
+ * The rooms that change when step `key` of `owner` is painted (`finish`) or
+ * erased (`undefined`): the doorway's paint is dropped from every holder and,
+ * painting, written on the owner — one colour per doorway. No step index paints
+ * the whole doorway, so its per-step entries go too.
+ */
+export function withFloorStepOverride(owner, key, step, finish, zones) {
+    const changed = new Map();
+    for (const holder of doorwayHolders(owner, key, zones)) {
+        const current = holder.zone.floorStepOverrides ?? [];
+        const kept = current.filter((entry) => entry.key !== holder.key || (step !== null && entry.step !== step));
+        if (kept.length !== current.length)
+            changed.set(holder.zone.id, withOverrides(holder.zone, kept));
+    }
+    if (finish !== undefined) {
+        const base = changed.get(owner.id) ?? owner;
+        changed.set(owner.id, withOverrides(base, [
+            ...(base.floorStepOverrides ?? []),
+            { key, ...(step === null ? {} : { step }), finish },
+        ]));
+    }
+    return [...changed.values()];
+}
+function withOverrides(zone, overrides) {
+    const next = { ...zone };
+    if (overrides.length)
+        next.floorStepOverrides = overrides;
+    else
+        delete next.floorStepOverrides;
+    return next;
+}
+/** `zone` without the overrides keyed by `keys` (deleted doors), or null when none go. */
+export function withoutFloorStepOverrideKeys(zone, keys) {
+    const current = zone.floorStepOverrides;
+    if (!current?.some((entry) => keys.has(entry.key)))
+        return null;
+    return withOverrides(zone, current.filter((entry) => !keys.has(entry.key)));
+}
+/** `zone` with override keys naming a retired room renamed to its survivor, or null. */
+export function remapFloorStepOverrideKeys(zone, remap) {
+    const current = zone.floorStepOverrides;
+    if (!current?.some((entry) => remap.has(entry.key)))
+        return null;
+    const byKey = new Map();
+    for (const entry of current) {
+        const key = remap.get(entry.key) ?? entry.key;
+        if (key === zone.id)
+            continue;
+        const id = `${key}#${entry.step ?? ''}`;
+        // An entry already under the survivor's key was painted on that step itself.
+        if (!byKey.has(id) || !remap.has(entry.key))
+            byKey.set(id, { ...entry, key });
+    }
+    return withOverrides(zone, [...byKey.values()]);
+}

package/dist/lib/foundation-construction.d.ts

@@ -0,0 +1,73 @@
+import type { AnyNode, AnyNodeId } from '../schema/index.js';
+import type { Assembly } from '../schema/assembly.js';
+/** What a foundation wall is built of: block, or cast in place. */
+export type FoundationConstructionId = 'cmu' | 'cast-concrete';
+/** Where the scene says the building stands, as far as foundation practice goes. */
+export type FoundationRegionId = 'us' | 'europe' | 'generic';
+export type FoundationConstruction = {
+    id: FoundationConstructionId;
+    /** Short name, for the results the agent reads. */
+    label: string;
+    /** The wall as the agent is told of it. */
+    description: string;
+    /** The stack a new foundation wall stores, outside in (the wall's thickness is its sum). */
+    assembly: Assembly;
+    /** The course the generic foundation draws up to the floor, where the walls above it are thinner. */
+    stemThickness: number;
+    /** How far the ground floor stands over finished grade: the top of the foundation, metres. */
+    seatAboveGrade: number;
+    /** Where the seat comes from. */
+    seatBasis: string;
+    /** Whether the numbers cite a standard (`standard`) or are a sensible default (`default`). */
+    source: 'standard' | 'default';
+};
+/**
+ * The foundation constructions, as data: the wall a person gets below grade, the course the generic
+ * foundation draws, and how high the floor stands over the ground. The generic one (`cmu`) is the
+ * US residential practice and stays the answer wherever nothing says better.
+ *
+ * - `cmu`: 8 in block, 2x4 pressure-treated furring laid flat inside (IRC R404.1, R317.1), the
+ *   floor 8 in over grade (R317.1 keeps wood framing that far off exposed ground).
+ * - `cast-concrete`: the continental and British practice of a cast wall, 25 cm, insulated and
+ *   waterproofed on the outside. The thicknesses are the usual ones (cellar walls of 20 to 25 cm,
+ *   perimeter insulation of 10 cm, a 4 mm bitumen sheet), a sensible default rather than one
+ *   country's code. The floor 15 cm over the ground: the damp-proof course of British practice
+ *   (Approved Document C, NHBC) stands at least 150 mm over it, and plinths elsewhere run as high.
+ */
+export declare const FOUNDATION_CONSTRUCTIONS: Record<FoundationConstructionId, FoundationConstruction>;
+/**
+ * What the tool descriptions say of the construction, in one phrase; a test keeps its numbers equal
+ * to the data above.
+ */
+export declare const FOUNDATION_BY_REGION_NOTE = "built of what the building's region says: 8 in CMU with 2x4 pressure-treated furring laid flat inside (0.241 m) in the United States and where the scene does not say where the building stands, 25 cm cast concrete insulated and waterproofed outside (0.354 m) in Europe; the result names the region it read";
+/** What the scene says about where the building stands, and the construction that follows. */
+export type FoundationReading = {
+    region: FoundationRegionId;
+    construction: FoundationConstruction;
+    /** Why this construction, for the agent: the region read and what it was read from. */
+    basis: string;
+};
+type Nodes = Record<AnyNodeId, AnyNode>;
+/**
+ * Where the scene says the building stands, from what it carries without any plugin and in the
+ * order Bones' jurisdiction guess reads the same site: the state set by hand on the site
+ * (`metadata.codeOverrides.state`), the site's address state, the parcel's state; then, which
+ * Bones has no use for, the country the dossier's address ends with, and last the site's
+ * coordinates (a point over Europe). Nothing else is guessed: not the browser (core runs on the
+ * server too, where there is none), and a state or country that is not recognised leaves the
+ * region generic.
+ */
+export declare function foundationRegionOf(nodes: Nodes, buildingId?: string | null): {
+    region: FoundationRegionId;
+    basis: string;
+};
+/**
+ * The foundation construction of a building, by region: the US block practice, cast concrete in
+ * Europe, and the generic block where the scene says nothing. `basis` names what was read, for the
+ * agent to repeat.
+ */
+export declare function foundationReadingOf(nodes: Nodes, buildingId?: string | null): FoundationReading;
+/** The reading for the building a level belongs to (no building: the site's region alone). */
+export declare function foundationReadingOfLevel(nodes: Nodes, levelId: string): FoundationReading;
+export {};
+//# sourceMappingURL=foundation-construction.d.ts.map

package/dist/lib/foundation-construction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foundation-construction.d.ts","sourceRoot":"","sources":["../../src/lib/foundation-construction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAGlD,mEAAmE;AACnE,MAAM,MAAM,wBAAwB,GAAG,KAAK,GAAG,eAAe,CAAA;AAE9D,oFAAoF;AACpF,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG,QAAQ,GAAG,SAAS,CAAA;AAE5D,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,wBAAwB,CAAA;IAC5B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAA;IACb,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAA;IACnB,4FAA4F;IAC5F,QAAQ,EAAE,QAAQ,CAAA;IAClB,qGAAqG;IACrG,aAAa,EAAE,MAAM,CAAA;IACrB,8FAA8F;IAC9F,cAAc,EAAE,MAAM,CAAA;IACtB,iCAAiC;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,8FAA8F;IAC9F,MAAM,EAAE,UAAU,GAAG,SAAS,CAAA;CAC/B,CAAA;AAID;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,wBAAwB,EAAE,sBAAsB,CAuC7F,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB,qTAC8Q,CAAA;AAEpT,8FAA8F;AAC9F,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,kBAAkB,CAAA;IAC1B,YAAY,EAAE,sBAAsB,CAAA;IACpC,uFAAuF;IACvF,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,KAAK,KAAK,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;AAmIvC;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GACzB;IAAE,MAAM,EAAE,kBAAkB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAwC/C;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,iBAAiB,CAS/F;AAED,8FAA8F;AAC9F,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAGzF"}

package/dist/lib/foundation-construction.js

@@ -0,0 +1,242 @@
+import { FOUNDATION_STANDARD } from './foundation-standard.js';
+const INCH = 0.0254;
+/**
+ * The foundation constructions, as data: the wall a person gets below grade, the course the generic
+ * foundation draws, and how high the floor stands over the ground. The generic one (`cmu`) is the
+ * US residential practice and stays the answer wherever nothing says better.
+ *
+ * - `cmu`: 8 in block, 2x4 pressure-treated furring laid flat inside (IRC R404.1, R317.1), the
+ *   floor 8 in over grade (R317.1 keeps wood framing that far off exposed ground).
+ * - `cast-concrete`: the continental and British practice of a cast wall, 25 cm, insulated and
+ *   waterproofed on the outside. The thicknesses are the usual ones (cellar walls of 20 to 25 cm,
+ *   perimeter insulation of 10 cm, a 4 mm bitumen sheet), a sensible default rather than one
+ *   country's code. The floor 15 cm over the ground: the damp-proof course of British practice
+ *   (Approved Document C, NHBC) stands at least 150 mm over it, and plinths elsewhere run as high.
+ */
+export const FOUNDATION_CONSTRUCTIONS = {
+    cmu: {
+        id: 'cmu',
+        label: 'CMU',
+        description: '8 in (0.203 m) CMU with 2x4 pressure-treated furring laid flat on the inside, 16 in on centre, interior finish as the level has it',
+        assembly: {
+            layers: [
+                { id: 'block', role: 'structure', core: true, material: 'cmu', thickness: 0.203 },
+                // IRC R317.1: furring on the inside of below-grade masonry is pressure treated, 16 in on centre.
+                { id: 'furring', role: 'furring', material: 'pressure-treated wood', thickness: 0.038 },
+            ],
+            face: 'exterior',
+        },
+        stemThickness: FOUNDATION_STANDARD.stemThickness,
+        seatAboveGrade: 0.203,
+        seatBasis: 'IRC R317.1 keeps wood framing resting on a foundation wall 8 in from exposed ground',
+        source: 'standard',
+    },
+    'cast-concrete': {
+        id: 'cast-concrete',
+        label: 'cast concrete',
+        description: '25 cm (0.25 m) cast concrete with 10 cm of insulation and a bitumen waterproofing membrane on the outside, interior finish as the level has it',
+        assembly: {
+            layers: [
+                { id: 'membrane', role: 'membrane', material: 'bitumen membrane', thickness: 0.004 },
+                { id: 'insulation', role: 'insulation', material: 'perimeter insulation', thickness: 0.1 },
+                { id: 'concrete', role: 'structure', core: true, material: 'concrete', thickness: 0.25 },
+            ],
+            face: 'exterior',
+        },
+        stemThickness: 0.25,
+        seatAboveGrade: 0.15,
+        seatBasis: 'a sensible default: the damp-proof course of British practice (Approved Document C, NHBC) stands at least 150 mm over the ground and continental plinths run about as high; verify the local rule',
+        source: 'default',
+    },
+};
+/**
+ * What the tool descriptions say of the construction, in one phrase; a test keeps its numbers equal
+ * to the data above.
+ */
+export const FOUNDATION_BY_REGION_NOTE = "built of what the building's region says: 8 in CMU with 2x4 pressure-treated furring laid flat inside (0.241 m) in the United States and where the scene does not say where the building stands, 25 cm cast concrete insulated and waterproofed outside (0.354 m) in Europe; the result names the region it read";
+const US_STATES = new Set('AL AK AZ AR CA CO CT DE DC FL GA HI ID IL IN IA KS KY LA ME MD MA MI MN MS MO MT NE NV NH NJ NM NY NC ND OH OK OR PA RI SC SD TN TX UT VT VA WA WV WI WY'.split(' '));
+const US_STATE_NAMES = Object.fromEntries([
+    ['ALABAMA', 'AL'],
+    ['ALASKA', 'AK'],
+    ['ARIZONA', 'AZ'],
+    ['ARKANSAS', 'AR'],
+    ['CALIFORNIA', 'CA'],
+    ['COLORADO', 'CO'],
+    ['CONNECTICUT', 'CT'],
+    ['DELAWARE', 'DE'],
+    ['DISTRICT OF COLUMBIA', 'DC'],
+    ['FLORIDA', 'FL'],
+    ['GEORGIA', 'GA'],
+    ['HAWAII', 'HI'],
+    ['IDAHO', 'ID'],
+    ['ILLINOIS', 'IL'],
+    ['INDIANA', 'IN'],
+    ['IOWA', 'IA'],
+    ['KANSAS', 'KS'],
+    ['KENTUCKY', 'KY'],
+    ['LOUISIANA', 'LA'],
+    ['MAINE', 'ME'],
+    ['MARYLAND', 'MD'],
+    ['MASSACHUSETTS', 'MA'],
+    ['MICHIGAN', 'MI'],
+    ['MINNESOTA', 'MN'],
+    ['MISSISSIPPI', 'MS'],
+    ['MISSOURI', 'MO'],
+    ['MONTANA', 'MT'],
+    ['NEBRASKA', 'NE'],
+    ['NEVADA', 'NV'],
+    ['NEW HAMPSHIRE', 'NH'],
+    ['NEW JERSEY', 'NJ'],
+    ['NEW MEXICO', 'NM'],
+    ['NEW YORK', 'NY'],
+    ['NORTH CAROLINA', 'NC'],
+    ['NORTH DAKOTA', 'ND'],
+    ['OHIO', 'OH'],
+    ['OKLAHOMA', 'OK'],
+    ['OREGON', 'OR'],
+    ['PENNSYLVANIA', 'PA'],
+    ['RHODE ISLAND', 'RI'],
+    ['SOUTH CAROLINA', 'SC'],
+    ['SOUTH DAKOTA', 'SD'],
+    ['TENNESSEE', 'TN'],
+    ['TEXAS', 'TX'],
+    ['UTAH', 'UT'],
+    ['VERMONT', 'VT'],
+    ['VIRGINIA', 'VA'],
+    ['WASHINGTON', 'WA'],
+    ['WEST VIRGINIA', 'WV'],
+    ['WISCONSIN', 'WI'],
+    ['WYOMING', 'WY'],
+]);
+/** 'tx', 'Texas', 'TEXAS ' → 'TX'; null for anything that is no US state (a Canadian province, a French région). */
+function usStateOf(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const text = raw.trim().toUpperCase().replace(/\s+/g, ' ');
+    if (US_STATES.has(text))
+        return text;
+    return US_STATE_NAMES[text] ?? null;
+}
+const fold = (text) => text
+    .normalize('NFD')
+    .replace(/\p{Diacritic}/gu, '')
+    .toLowerCase()
+    .replace(/[^a-z ]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+const UNITED_STATES_NAMES = new Set(['usa', 'us', 'united states', 'united states of america']);
+/** The countries a formatted address can end with, where masonry and cast foundations are the practice. */
+const EUROPEAN_COUNTRY_NAMES = new Set([
+    'albania, andorra, austria, belgium, belgique, belgie, bosnia and herzegovina, bulgaria, croatia, cyprus,',
+    'czechia, czech republic, denmark, estonia, finland, france, germany, deutschland, greece, hungary,',
+    'iceland, ireland, italy, italia, latvia, liechtenstein, lithuania, luxembourg, malta, monaco,',
+    'montenegro, netherlands, nederland, north macedonia, norway, poland, portugal, romania,',
+    'san marino, serbia, slovakia, slovenia, spain, espana, sweden, switzerland, suisse, schweiz,',
+    'svizzera, united kingdom, uk, great britain, england, scotland, wales, northern ireland',
+]
+    .join(' ')
+    .split(',')
+    .map((name) => name.trim()));
+/** The country the last part of a formatted address names ('…, 75008 Paris, France'), as a region. */
+function regionOfAddress(formatted) {
+    if (typeof formatted !== 'string')
+        return null;
+    const last = formatted.split(',').at(-1);
+    if (!last)
+        return null;
+    const country = fold(last);
+    if (UNITED_STATES_NAMES.has(country))
+        return { region: 'us', country: last.trim() };
+    if (EUROPEAN_COUNTRY_NAMES.has(country))
+        return { region: 'europe', country: last.trim() };
+    return null;
+}
+/**
+ * A coarse box over Europe, for a site with a point and no address. It leaves out Africa and the
+ * Near East, and what it takes in beyond the continent (Anatolia's west, Kaliningrad) is masonry
+ * country too. Canada and the United States are not read from coordinates: their border is no
+ * box, and a site with only a point there keeps the generic construction.
+ */
+function inEurope(lat, lng) {
+    return lat >= 36 && lat <= 71.5 && lng >= -10.7 && lng <= 31;
+}
+function finite(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function siteOf(nodes, buildingId) {
+    const building = buildingId ? nodes[buildingId] : undefined;
+    const parent = building?.parentId ? nodes[building.parentId] : undefined;
+    if (parent?.type === 'site')
+        return parent;
+    const site = Object.values(nodes).find((node) => node.type === 'site');
+    return site ?? null;
+}
+/**
+ * Where the scene says the building stands, from what it carries without any plugin and in the
+ * order Bones' jurisdiction guess reads the same site: the state set by hand on the site
+ * (`metadata.codeOverrides.state`), the site's address state, the parcel's state; then, which
+ * Bones has no use for, the country the dossier's address ends with, and last the site's
+ * coordinates (a point over Europe). Nothing else is guessed: not the browser (core runs on the
+ * server too, where there is none), and a state or country that is not recognised leaves the
+ * region generic.
+ */
+export function foundationRegionOf(nodes, buildingId) {
+    const site = siteOf(nodes, buildingId);
+    const nowhere = {
+        region: 'generic',
+        basis: 'the scene does not say where the building stands (no site state, address country or coordinates)',
+    };
+    if (!site)
+        return nowhere;
+    const overrides = site.metadata?.codeOverrides;
+    const byHand = usStateOf(overrides?.state);
+    if (byHand)
+        return { region: 'us', basis: `the site's code overrides set the state ${byHand}` };
+    const addressState = usStateOf(site.address?.state);
+    if (addressState)
+        return { region: 'us', basis: `the site's address is in the state ${addressState}` };
+    const parcelState = usStateOf(site.parcel?.state);
+    if (parcelState)
+        return { region: 'us', basis: `the site's parcel is in the state ${parcelState}` };
+    const dossier = site.dossier;
+    const named = regionOfAddress(dossier?.address?.formatted);
+    if (named) {
+        return {
+            region: named.region,
+            basis: `the site's dossier address ends with ${named.country}`,
+        };
+    }
+    const origin = site.parcel?.originLngLat;
+    const points = [
+        { lat: dossier?.point?.lat, lng: dossier?.point?.lng },
+        ...(Array.isArray(origin) ? [{ lat: origin[1], lng: origin[0] }] : []),
+    ];
+    for (const { lat, lng } of points) {
+        if (finite(lat) && finite(lng) && inEurope(lat, lng)) {
+            return {
+                region: 'europe',
+                basis: `the site's coordinates (${lat.toFixed(2)}, ${lng.toFixed(2)}) lie in Europe`,
+            };
+        }
+    }
+    return nowhere;
+}
+/**
+ * The foundation construction of a building, by region: the US block practice, cast concrete in
+ * Europe, and the generic block where the scene says nothing. `basis` names what was read, for the
+ * agent to repeat.
+ */
+export function foundationReadingOf(nodes, buildingId) {
+    const { region, basis: regionBasis } = foundationRegionOf(nodes, buildingId);
+    const id = region === 'europe' ? 'cast-concrete' : 'cmu';
+    const regionPart = region === 'generic'
+        ? `no region known (${regionBasis})`
+        : `region ${region === 'us' ? 'United States' : 'Europe'} (${regionBasis})`;
+    const basis = `${regionPart}${region === 'generic' ? '; the generic block foundation applies' : ''}`;
+    return { region, construction: FOUNDATION_CONSTRUCTIONS[id], basis };
+}
+/** The reading for the building a level belongs to (no building: the site's region alone). */
+export function foundationReadingOfLevel(nodes, levelId) {
+    const parent = nodes[(nodes[levelId]?.parentId ?? '')];
+    return foundationReadingOf(nodes, parent?.type === 'building' ? parent.id : null);
+}

package/dist/lib/foundation-standard.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The standard numbers of a residential foundation, in metres, stated once: the generic foundation
+ * the viewer draws under every building (`genericFoundation`), Bones' pour and the sections
+ * plugin's drawings all read them. They are the common US residential values (IRC chapters 4 and
+ * 5), not a jurisdiction's: core holds no frost data, so what depends on one (the frost line, the
+ * wall convention) stays with the jurisdiction profile in Bones.
+ */
+export declare const FOUNDATION_STANDARD: {
+    /** Continuous footing under an exterior wall: 16 in wide, the usual pour for light framing (IRC R403.1). */
+    readonly footingWidth: number;
+    /** 6 in is the minimum (IRC Table R403.1(1)); 8 in is the near-universal pour. */
+    readonly footingThickness: number;
+    /**
+     * How far the footing's bottom sits under the lowest grade where nothing says better: 12 in, the
+     * shallowest Bones allows (IRC R403.1.4.1 asks for the frost line, which core does not know). A
+     * generic depth, drawn as one.
+     */
+    readonly footingBelowGrade: number;
+    /** The foundation wall (the stem) from the footing up to the floor: 8 in (IRC R404.1). */
+    readonly stemThickness: number;
+    /** A crawl space vent, 8 × 16 in screened for 50 sq in net (IRC R408.1), within 3 ft of each corner, set 2 ft in (R408.2). */
+    readonly ventWidth: number;
+    readonly ventHeight: number;
+    readonly ventNetAreaSqIn: 50;
+    readonly ventCornerInset: number;
+    /** The crawl space access through the stem: 16 × 24 in (IRC R408.4). */
+    readonly crawlAccessWidth: number;
+    readonly crawlAccessHeight: number;
+};
+//# sourceMappingURL=foundation-standard.d.ts.map