@pascal-app/core 1.0.6 → 1.1.0

package/dist/lib/grade-standing.js

@@ -1,6 +1,10 @@
 import { BELOW_GRADE_TOLERANCE, getLevelElevations, isLevelBelowGrade, levelPlaneWorldY, } from '../services/storey.js';
 import { pointInPolygon } from '../systems/slab/slab-support.js';
+import { getWallCurveFrameAt, getWallCurveLength } from '../systems/wall/wall-curve.js';
+import { getWallFaceOffsets } from '../systems/wall/wall-frame.js';
 import { levelUnderNamedGround } from './ground-level.js';
+import { getOpeningFloorDatum } from './opening-floor-datum.js';
+import { area, intersection, union } from './polygon-boolean.js';
 import { isSiteFlatwork } from './site-flatwork.js';
 import { heightAt } from './terrain-field.js';
 import { terrainFieldOf } from './terrain-source.js';
@@ -58,7 +62,7 @@ function flatFloorsStanding(nodes, level, fallback) {
     const slabs = floorSlabsOf(nodes, level);
     if (slabs.length === 0)
         return fallback;
-    const buried = slabs.filter((slab) => floorBuriedOnFlatSite(plane + slab.elevation)).length;
+    const buried = slabs.filter((slab) => floorBuriedOnFlatSite(plane + slabGradeElevation(nodes, level, slab))).length;
     if (buried === 0)
         return 'at-grade';
     return buried === slabs.length ? 'below-grade' : 'partly-below-grade';
@@ -67,18 +71,134 @@ function flatFloorsStanding(nodes, level, fallback) {
 export function floorBuriedOnFlatSite(floorY) {
     return SITE_DATUM_Y - floorY > BELOW_GRADE_TOLERANCE;
 }
-/** The floor slabs of the house on a level: not a basin, not site flatwork, with a plan. */
+const floorSlabsMemo = new WeakMap();
+/**
+ * The floor slabs of the house on a level: not a basin, not site flatwork, with a plan, and on a
+ * level with rooms, under one of them. A slab outside every room (an entry pad, a stoop) is the
+ * site's, as flatwork is, not a floor the ground can bury.
+ */
 function floorSlabsOf(nodes, level) {
+    let levels = floorSlabsMemo.get(nodes);
+    if (!levels) {
+        levels = new Map();
+        floorSlabsMemo.set(nodes, levels);
+    }
+    const hit = levels.get(level.id);
+    if (hit)
+        return hit;
     const slabs = [];
+    const rooms = [];
     for (const childId of level.children) {
-        const slab = nodes[childId];
-        if (slab?.type !== 'slab' || slab.recessed === true || slab.polygon.length < 3)
+        const child = nodes[childId];
+        if (child?.type === 'zone' && child.spaceRole === 'room' && child.polygon.length >= 3)
+            rooms.push({ outer: child.polygon, holes: child.holes ?? [] });
+        if (child?.type !== 'slab' || child.recessed === true || child.polygon.length < 3)
             continue;
-        if (isSiteFlatwork(slab))
+        if (isSiteFlatwork(child))
             continue;
-        slabs.push(slab);
+        slabs.push(child);
+    }
+    const indoors = rooms.length ? union(rooms) : null;
+    const floors = indoors
+        ? slabs.filter((slab) => area(intersection(slab.polygon, indoors)) > OUTDOOR_SLAB_AREA)
+        : slabs;
+    levels.set(level.id, floors);
+    return floors;
+}
+/** A slab sharing less than this with the level's rooms (m²) stands outside them. */
+const OUTDOOR_SLAB_AREA = 1e-3;
+/** How far past a wall's face a door's two sides are looked at. */
+const DOOR_SIDE_REACH = 0.1;
+const gradeElevationsMemo = new WeakMap();
+/**
+ * The level-local elevation the ground is judged against over a floor slab: its own top, except
+ * for a floor sunk under its level's floor that opens to the outside through a door reaching down
+ * to it (a garage below the house, its door onto the drive). The ground outside that door comes
+ * down to it, so it is no basement: it is judged at its level's floor, and does not leave the
+ * level partly below grade.
+ */
+export function slabGradeElevation(nodes, level, slab) {
+    let levels = gradeElevationsMemo.get(nodes);
+    if (!levels) {
+        levels = new Map();
+        gradeElevationsMemo.set(nodes, levels);
+    }
+    let walkOuts = levels.get(level.id);
+    if (!walkOuts) {
+        walkOuts = sunkenFloorsOpeningOut(nodes, level);
+        levels.set(level.id, walkOuts);
+    }
+    return walkOuts.get(slab.id) ?? slab.elevation;
+}
+/**
+ * The world Y of `level`'s lowest floor as the ground judges it ({@link slabGradeElevation}): a
+ * garage sunk under the floor and opening out to the drive leaves it at the level's floor. `null`
+ * for a level with no floor slab, or no plane.
+ */
+export function levelGradeFloorWorldY(nodes, level) {
+    const plane = levelPlaneWorldY(nodes, level.id);
+    const slabs = floorSlabsOf(nodes, level);
+    if (plane === null || slabs.length === 0)
+        return null;
+    return plane + Math.min(...slabs.map((slab) => slabGradeElevation(nodes, level, slab)));
+}
+/** {@link slabGradeElevation}'s exceptions on `level`: slab id to the level floor it is judged at. */
+function sunkenFloorsOpeningOut(nodes, level) {
+    const walkOuts = new Map();
+    const slabs = floorSlabsOf(nodes, level);
+    if (slabs.length < 2)
+        return walkOuts;
+    const floor = Math.max(...slabs.map((slab) => slab.elevation));
+    const floorsAt = ([x, z]) => slabs.filter((slab) => pointInPolygon(x, z, slab.polygon));
+    for (const wallId of level.children) {
+        const wall = nodes[wallId];
+        if (wall?.type !== 'wall')
+            continue;
+        const length = getWallCurveLength(wall);
+        if (length < 1e-9)
+            continue;
+        const faces = getWallFaceOffsets(wall);
+        for (const doorId of wall.children ?? []) {
+            const door = nodes[doorId];
+            if (door?.type !== 'door')
+                continue;
+            const { position, height } = door;
+            // A raw legacy door places itself by `offset` until it is loaded.
+            if (!Array.isArray(position))
+                continue;
+            const bottom = getOpeningFloorDatum(wall, door, nodes) + position[1] - height / 2;
+            const frame = getWallCurveFrameAt(wall, position[0] / length);
+            const side = (offset) => [
+                frame.point.x + frame.normal.x * offset,
+                frame.point.y + frame.normal.y * offset,
+            ];
+            const a = floorsAt(side(faces.a + DOOR_SIDE_REACH));
+            const b = floorsAt(side(faces.b - DOOR_SIDE_REACH));
+            // A door between a floor and no floor at all opens to the outside.
+            const inside = a.length === 0 ? b : b.length === 0 ? a : [];
+            for (const slab of inside)
+                if (slab.elevation < floor && bottom <= slab.elevation + BELOW_GRADE_TOLERANCE)
+                    walkOuts.set(slab.id, floor);
+        }
+    }
+    // The rest of that floor: a garage's floor may be several plates at its height (of its room, or
+    // joining the one the door is on).
+    for (let grown = walkOuts.size > 0; grown;) {
+        grown = false;
+        for (const slab of slabs) {
+            if (walkOuts.has(slab.id))
+                continue;
+            const joined = slabs.some((other) => walkOuts.has(other.id) &&
+                Math.abs(other.elevation - slab.elevation) < 1e-3 &&
+                ((slab.zoneIds ?? []).some((id) => other.zoneIds?.includes(id)) ||
+                    union([slab.polygon, other.polygon]).length === 1));
+            if (joined) {
+                walkOuts.set(slab.id, floor);
+                grown = true;
+            }
+        }
     }
-    return slabs;
+    return walkOuts;
 }
 /** The site's terrain field for the site this level stands on, or null on a flat site. */
 export function terrainFieldOverLevel(nodes, level) {
@@ -91,7 +211,7 @@ export function terrainFieldOverLevel(nodes, level) {
 /**
  * World XZ samples over the level's floor slabs: each slab's corners plus a grid across it no
  * coarser than the terrain's own spacing, capped so a big plate stays cheap. Slabs are the
- * footprint the grade ring already trusts (`belowGradeFootprints`).
+ * footprint the ground's hole already trusts (`belowGradeFootprints`).
  */
 export function footprintSamples(nodes, level, field) {
     return footprintFloorSamples(nodes, level, field).map(([x, z]) => [x, z]);
@@ -112,7 +232,7 @@ export function footprintFloorSamples(nodes, level, field) {
     for (const slab of floorSlabsOf(nodes, level)) {
         for (const [x, z] of slabSamples(slab.polygon, field.spacing)) {
             const [worldX, worldZ] = levelLocalToWorldXZ(placed, x, z);
-            samples.push([worldX, worldZ, plane + slab.elevation]);
+            samples.push([worldX, worldZ, plane + slabGradeElevation(nodes, level, slab)]);
         }
     }
     return samples;

package/dist/lib/ground-seat.d.ts

@@ -1,15 +1,6 @@
 import type { AnyNode, AnyNodeId, LevelNode } from '../schema/index.js';
-import { type FoundationReading } from './foundation-construction.js';
-/** How far the ground floor's datum may stand from its seat and still count as seated on it. */
+/** How far the ground floor's datum may stand from grade and still count as seated on it. */
 export declare const GROUND_SEAT_TOLERANCE = 0.05;
-/**
- * Where "Set as ground floor" and `set_ground_level` stand the ground floor over finished grade
- * on the generic (block) foundation: the top of the foundation, where the wood framing starts, 8
- * in (0.203 m) above the ground. IRC R317.1 keeps wood framing resting on a foundation wall at
- * least 8 in from exposed ground. A building's region and style can choose another construction
- * and its own seat (`GroundSeat.aboveGrade`, `FOUNDATION_CONSTRUCTIONS`).
- */
-export declare const GROUND_FLOOR_ABOVE_GRADE: number;
 /**
  * The grade a level's floor is seated against: the flat datum on a flat site, and on shaped
  * terrain the ground's mean height over the level's floor slabs (the building's own origin when it
@@ -28,19 +19,8 @@ export type GroundSeat = {
     gradeElevation: number;
     /** How far the floor datum stands over grade: negative when it is sunk. */
     offset: number;
-    /** How far the building's foundation construction stands the ground floor over grade, metres. */
-    aboveGrade: number;
-    /** The construction, the region and style it was read from. */
-    foundation: FoundationReading;
-    /**
-     * The floor datum stands between grade and the foundation's top (`aboveGrade`, or the block's
-     * 8 in where that is higher), within {@link GROUND_SEAT_TOLERANCE}: what a scene seated before
-     * the 8 in rule, one seated by it and one seated by its own region's construction all satisfy,
-     * so a check has nothing to say about any of them.
-     */
+    /** The floor datum stands on grade, within {@link GROUND_SEAT_TOLERANCE}. */
     seated: boolean;
-    /** The floor datum stands at `aboveGrade` over grade, within the tolerance. */
-    atFoundationTop: boolean;
 };
 /** `null` for an id that is no building, or a building with no level at or over the ground. */
 export declare function groundSeat(nodes: Record<AnyNodeId, AnyNode>, buildingId: string): GroundSeat | null;

package/dist/lib/ground-seat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ground-seat.d.ts","sourceRoot":"","sources":["../../src/lib/ground-seat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAgB,SAAS,EAAE,MAAM,WAAW,CAAA;AAE5E,OAAO,EAEL,KAAK,iBAAiB,EAEvB,MAAM,2BAA2B,CAAA;AAMlC,gGAAgG;AAChG,eAAO,MAAM,qBAAqB,OAAO,CAAA;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,QAA8C,CAAA;AAEnF;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAa3F;AAED,4DAA4D;AAC5D,MAAM,MAAM,UAAU,GAAG;IACvB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,uEAAuE;IACvE,QAAQ,EAAE,OAAO,CAAA;IACjB,oEAAoE;IACpE,cAAc,EAAE,MAAM,CAAA;IACtB,qCAAqC;IACrC,cAAc,EAAE,MAAM,CAAA;IACtB,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAA;IACd,iGAAiG;IACjG,UAAU,EAAE,MAAM,CAAA;IAClB,+DAA+D;IAC/D,UAAU,EAAE,iBAAiB,CAAA;IAC7B;;;;;OAKG;IACH,MAAM,EAAE,OAAO,CAAA;IACf,+EAA+E;IAC/E,eAAe,EAAE,OAAO,CAAA;CACzB,CAAA;AAED,+FAA+F;AAC/F,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,UAAU,EAAE,MAAM,GACjB,UAAU,GAAG,IAAI,CAsBnB"}
+{"version":3,"file":"ground-seat.d.ts","sourceRoot":"","sources":["../../src/lib/ground-seat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAgB,SAAS,EAAE,MAAM,WAAW,CAAA;AAO5E,6FAA6F;AAC7F,eAAO,MAAM,qBAAqB,OAAO,CAAA;AAEzC;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAa3F;AAED,4DAA4D;AAC5D,MAAM,MAAM,UAAU,GAAG;IACvB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,uEAAuE;IACvE,QAAQ,EAAE,OAAO,CAAA;IACjB,oEAAoE;IACpE,cAAc,EAAE,MAAM,CAAA;IACtB,qCAAqC;IACrC,cAAc,EAAE,MAAM,CAAA;IACtB,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAA;IACd,6EAA6E;IAC7E,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,+FAA+F;AAC/F,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,UAAU,EAAE,MAAM,GACjB,UAAU,GAAG,IAAI,CAenB"}

package/dist/lib/ground-seat.js

@@ -1,19 +1,10 @@
 import { getStoreyDatum } from '../services/storey-datum.js';
-import { FOUNDATION_CONSTRUCTIONS, foundationReadingOf, } from './foundation-construction.js';
 import { footprintSamples, terrainFieldOverLevel } from './grade-standing.js';
 import { groundLevelOf } from './ground-level.js';
 import { heightAt } from './terrain-field.js';
 import { levelLocalToWorldXZ, SITE_DATUM_Y } from './terrain-support-query.js';
-/** How far the ground floor's datum may stand from its seat and still count as seated on it. */
+/** How far the ground floor's datum may stand from grade and still count as seated on it. */
 export const GROUND_SEAT_TOLERANCE = 0.05;
-/**
- * Where "Set as ground floor" and `set_ground_level` stand the ground floor over finished grade
- * on the generic (block) foundation: the top of the foundation, where the wood framing starts, 8
- * in (0.203 m) above the ground. IRC R317.1 keeps wood framing resting on a foundation wall at
- * least 8 in from exposed ground. A building's region and style can choose another construction
- * and its own seat (`GroundSeat.aboveGrade`, `FOUNDATION_CONSTRUCTIONS`).
- */
-export const GROUND_FLOOR_ABOVE_GRADE = FOUNDATION_CONSTRUCTIONS.cmu.seatAboveGrade;
 /**
  * The grade a level's floor is seated against: the flat datum on a flat site, and on shaped
  * terrain the ground's mean height over the level's floor slabs (the building's own origin when it
@@ -43,8 +34,6 @@ export function groundSeat(nodes, buildingId) {
         return null;
     const gradeElevation = gradeUnderLevel(nodes, ground.level);
     const offset = datum.floorElevation - gradeElevation;
-    const foundation = foundationReadingOf(nodes, buildingId);
-    const aboveGrade = foundation.construction.seatAboveGrade;
     return {
         buildingId,
         levelId: ground.level.id,
@@ -52,10 +41,6 @@ export function groundSeat(nodes, buildingId) {
         floorElevation: datum.floorElevation,
         gradeElevation,
         offset,
-        aboveGrade,
-        foundation,
-        seated: offset >= -GROUND_SEAT_TOLERANCE &&
-            offset <= Math.max(aboveGrade, GROUND_FLOOR_ABOVE_GRADE) + GROUND_SEAT_TOLERANCE,
-        atFoundationTop: Math.abs(offset - aboveGrade) <= GROUND_SEAT_TOLERANCE,
+        seated: Math.abs(offset) <= GROUND_SEAT_TOLERANCE,
     };
 }

package/dist/lib/ground-window.d.ts

@@ -11,7 +11,8 @@ export type GroundBox = {
 };
 /**
  * The world box of one level: its floor slabs' extent (its walls' if it has no slab), from its
- * lowest floor (the sunken room of a split level) to the height of its highest floor's ceiling.
+ * lowest floor (the sunken room of a split level; not a garage sunk under the floor that opens out
+ * to the drive, whose ground comes down to it) to the height of its highest floor's ceiling.
  */
 export declare function levelGroundBox(nodes: Record<AnyNodeId, AnyNode>, levelId: string): GroundBox | null;
 /**

package/dist/lib/ground-window.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ground-window.d.ts","sourceRoot":"","sources":["../../src/lib/ground-window.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAA2B,MAAM,WAAW,CAAA;AAO5E;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG;IAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAA;AAExF;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,MAAM,GACd,SAAS,GAAG,IAAI,CAQlB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GACzB,SAAS,GAAG,IAAI,CASlB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,MAAM,GACd,SAAS,GAAG,IAAI,CAUlB;AAOD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,GAAG,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACtC,GAAG,EAAE,SAAS,GACb,OAAO,CAwBT"}
+{"version":3,"file":"ground-window.d.ts","sourceRoot":"","sources":["../../src/lib/ground-window.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAA2B,MAAM,WAAW,CAAA;AAQ5E;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG;IAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAA;AAExF;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,MAAM,GACd,SAAS,GAAG,IAAI,CASlB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,GACzB,SAAS,GAAG,IAAI,CASlB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,MAAM,GACd,SAAS,GAAG,IAAI,CAUlB;AAOD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,GAAG,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACtC,GAAG,EAAE,SAAS,GACb,OAAO,CAwBT"}

package/dist/lib/ground-window.js

@@ -1,11 +1,13 @@
 import { getLevelElevations, levelFloorWorldY, levelLowestFloorWorldY } from '../services/storey.js';
+import { levelGradeFloorWorldY } from './grade-standing.js';
 import { isSiteFlatwork } from './site-flatwork.js';
 import { heightAt } from './terrain-field.js';
 import { terrainFieldOf } from './terrain-source.js';
 import { levelLocalToWorldXZ } from './terrain-support-query.js';
 /**
  * The world box of one level: its floor slabs' extent (its walls' if it has no slab), from its
- * lowest floor (the sunken room of a split level) to the height of its highest floor's ceiling.
+ * lowest floor (the sunken room of a split level; not a garage sunk under the floor that opens out
+ * to the drive, whose ground comes down to it) to the height of its highest floor's ceiling.
  */
 export function levelGroundBox(nodes, levelId) {
     const level = nodes[levelId];
@@ -16,7 +18,8 @@ export function levelGroundBox(nodes, levelId) {
     const points = footprintPoints(nodes, level);
     if (points.length === 0)
         return null;
-    return boxOf(points, levelLowestFloorWorldY(nodes, levelId) ?? floorY, floorY + height);
+    const lowest = levelGradeFloorWorldY(nodes, level) ?? levelLowestFloorWorldY(nodes, levelId);
+    return boxOf(points, lowest ?? floorY, floorY + height);
 }
 /**
  * The world box of a building (every building, with no id): the union of its levels' boxes.

package/dist/lib/hierarchy.d.ts

@@ -0,0 +1,19 @@
+import type { AnyNode, AnyNodeId } from '../schema/types.js';
+type NodeMap = Readonly<Record<string, Pick<AnyNode, 'parentId'>>>;
+type NodeLookup = (id: AnyNodeId) => Pick<AnyNode, 'parentId'> | undefined;
+/**
+ * Whether assigning `newParentId` to `nodeId` would put `nodeId` on a cycle of
+ * parent links. A cycle the chain already holds without `nodeId` is not one it
+ * creates: counting it would refuse every edit beneath an old cyclic scene.
+ */
+export declare function wouldCreateHierarchyCycle(nodeId: AnyNodeId, newParentId: AnyNodeId | null, nodes: NodeMap | NodeLookup): boolean;
+/** Return each distinct cycle encoded by `parentId` links. */
+export declare function findHierarchyCycles(nodes: NodeMap): AnyNodeId[][];
+/** The `parentId` error each node on a cycle raises, as every scene check lists it. */
+export declare function hierarchyCycleErrors(nodes: NodeMap): {
+    nodeId: AnyNodeId;
+    path: 'parentId';
+    message: string;
+}[];
+export {};
+//# sourceMappingURL=hierarchy.d.ts.map

package/dist/lib/hierarchy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hierarchy.d.ts","sourceRoot":"","sources":["../../src/lib/hierarchy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEzD,KAAK,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;AAClE,KAAK,UAAU,GAAG,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,GAAG,SAAS,CAAA;AAE1E;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,SAAS,EACjB,WAAW,EAAE,SAAS,GAAG,IAAI,EAC7B,KAAK,EAAE,OAAO,GAAG,UAAU,GAC1B,OAAO,CAaT;AAED,8DAA8D;AAC9D,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,EAAE,EAAE,CAwBjE;AAED,uFAAuF;AACvF,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,GACb;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,CAK5D"}

package/dist/lib/hierarchy.js

@@ -0,0 +1,53 @@
+/**
+ * Whether assigning `newParentId` to `nodeId` would put `nodeId` on a cycle of
+ * parent links. A cycle the chain already holds without `nodeId` is not one it
+ * creates: counting it would refuse every edit beneath an old cyclic scene.
+ */
+export function wouldCreateHierarchyCycle(nodeId, newParentId, nodes) {
+    if (!newParentId)
+        return false;
+    const nodeAt = typeof nodes === 'function' ? nodes : (id) => nodes[id];
+    const seen = new Set();
+    let currentId = newParentId;
+    while (currentId) {
+        if (currentId === nodeId)
+            return true;
+        if (seen.has(currentId))
+            return false;
+        seen.add(currentId);
+        currentId = nodeAt(currentId)?.parentId ?? null;
+    }
+    return false;
+}
+/** Return each distinct cycle encoded by `parentId` links. */
+export function findHierarchyCycles(nodes) {
+    const visited = new Set();
+    const cycles = [];
+    for (const startId of Object.keys(nodes)) {
+        if (visited.has(startId))
+            continue;
+        const chain = [];
+        const positions = new Map();
+        let currentId = startId;
+        while (currentId && nodes[currentId] && !visited.has(currentId)) {
+            const position = positions.get(currentId);
+            if (position !== undefined) {
+                cycles.push(chain.slice(position));
+                break;
+            }
+            positions.set(currentId, chain.length);
+            chain.push(currentId);
+            currentId = nodes[currentId]?.parentId ?? null;
+        }
+        for (const id of chain)
+            visited.add(id);
+    }
+    return cycles;
+}
+/** The `parentId` error each node on a cycle raises, as every scene check lists it. */
+export function hierarchyCycleErrors(nodes) {
+    return findHierarchyCycles(nodes).flatMap((cycle) => {
+        const message = `hierarchy cycle detected: ${[...cycle, cycle[0]].join(' -> ')}`;
+        return cycle.map((nodeId) => ({ nodeId, path: 'parentId', message }));
+    });
+}

package/dist/lib/level-footprints.d.ts

@@ -2,6 +2,8 @@ import type { WallNode } from '../schema/index.js';
 import { type MultiPolygon } from './polygon-boolean.js';
 import type { LevelFootprintContext, TopologyRoom } from './room-topology-index.js';
 export declare function roomWallFootprints(rooms: readonly TopologyRoom[]): MultiPolygon;
+/** The footprints of the railings round `room` (a deck's guard): no house wall among them. */
+export declare function roomRailingFootprints(room: TopologyRoom): MultiPolygon;
 export declare function roomClearPolygon(room: TopologyRoom): MultiPolygon;
 /** Rooms must belong to the same immutable level topology revision. */
 export declare function plateFootprint(rooms: readonly TopologyRoom[]): MultiPolygon;

package/dist/lib/level-footprints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"level-footprints.d.ts","sourceRoot":"","sources":["../../src/lib/level-footprints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAKzC,OAAO,EAIL,KAAK,YAAY,EAGlB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAmLhF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,CAE/E;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CASjE;AAED,uEAAuE;AACvE,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,CA8F3E;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvB,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACtB,CAAA;AA2ED,mGAAmG;AACnG,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,qBAAqB,EAClD,KAAK,CAAC,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,YAAY,CAAA;CAAE,GAC7D,eAAe,EAAE,CA2EnB;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD"}
+{"version":3,"file":"level-footprints.d.ts","sourceRoot":"","sources":["../../src/lib/level-footprints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAMzC,OAAO,EAIL,KAAK,YAAY,EAGlB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAmLhF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,CAE/E;AAED,8FAA8F;AAC9F,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAMtE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CASjE;AAED,uEAAuE;AACvE,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,CA8F3E;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvB,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACtB,CAAA;AA2ED,mGAAmG;AACnG,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,qBAAqB,EAClD,KAAK,CAAC,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,YAAY,CAAA;CAAE,GAC7D,eAAe,EAAE,CA2EnB;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD"}

package/dist/lib/level-footprints.js

@@ -1,3 +1,4 @@
+import { isRailingWall } from '../schema/nodes/railing-wall.js';
 import { getWallSurfacePolygon, isCurvedWall } from '../systems/wall/wall-curve.js';
 import { calculateLevelMiters, getWallPlanFootprint } from '../systems/wall/wall-footprint.js';
 import { getWallFaceLine } from '../systems/wall/wall-frame.js';
@@ -165,6 +166,12 @@ function recoverWallFootprint(plate, footprint, context) {
 export function roomWallFootprints(rooms) {
     return union(boundaryFootprints(rooms).map(({ polygon }) => polygon));
 }
+/** The footprints of the railings round `room` (a deck's guard): no house wall among them. */
+export function roomRailingFootprints(room) {
+    return union(boundaryFootprints([room])
+        .filter(({ id }) => isRailingWall(room.context.walls.get(id)))
+        .map(({ polygon }) => polygon));
+}
 export function roomClearPolygon(room) {
     const cached = clearCache.get(room);
     if (cached)

package/dist/lib/opening-casing.d.ts

@@ -0,0 +1,67 @@
+import type { AnyNode, DoorNode, WallFace, WindowNode } from '../schema/index.js';
+import { DEFAULT_OPENING_CASING_WIDTH, OPENING_CASING_PROUD } from '../schema/nodes/opening-types.js';
+/**
+ * Door and window casing: flat boards on the finished faces of the host wall
+ * around the opening, over the drywall or siding. The wall cutout is the unit's
+ * own width × height and the casing never reaches into it: each board starts at
+ * the cutout's edge and runs outward, `OPENING_CASING_PROUD` off the face. A
+ * window gets a picture frame (head, two legs, bottom), a door a head and two
+ * legs, butted at the corners: the head and bottom run the full width over the
+ * legs' ends.
+ *
+ * Everything here is in the host frame, centred on the opening: x along the
+ * host toward its end, y up, z across it toward face `a`. The 3D builders turn
+ * that into the unit's own frame (a unit facing the back is turned half round,
+ * see `openingHostFacing`); the plan draws it as it is.
+ */
+export { DEFAULT_OPENING_CASING_WIDTH, OPENING_CASING_PROUD };
+type CasedOpening = DoorNode | WindowNode;
+export type OpeningCasingHost = {
+    /** The host's total thickness with its finishes: each face is half of it off the mid-plane (m). */
+    thickness: number;
+    /** Room side, when known, for a window's interior stool. */
+    interiorFace?: WallFace;
+    exteriorFace?: WallFace;
+    /** The host end a corner window runs to: no leg there; the head and bottom stop at the opening. */
+    cornerEnd?: 'start' | 'end';
+};
+export type OpeningCasingFace = {
+    face: WallFace;
+    /** Across the host, from the opening's centre plane to the finished face (m). */
+    plane: number;
+    /** The way the face looks across the host: +1 for `a`, -1 for `b`. */
+    out: 1 | -1;
+};
+export type OpeningCasingBoard = {
+    face: WallFace;
+    /**
+     * `leg` boards stand beside the opening, the part a plan cut shows. A `foot` carries a leg on
+     * down past a window's sill to the bottom board, which sits under the sill on that face.
+     */
+    part: 'head' | 'leg' | 'foot' | 'bottom';
+    /** Centre, from the opening's centre in the host frame (m). */
+    center: [number, number, number];
+    /** Along the host, up, across it (m). */
+    size: [number, number, number];
+};
+/** The face width of an opening's casing boards; a save from before casing has the default. */
+export declare function openingCasingWidth(opening: Pick<CasedOpening, 'casingWidth'>): number;
+/**
+ * +1 when the unit faces the host's front (its own +z is face `a`), -1 when it is turned half
+ * round to face the back, which mirrors its x and z against the host's.
+ */
+export declare function openingHostFacing(opening: Partial<Pick<CasedOpening, 'rotation'>>): 1 | -1;
+/** Roof face a is outside; an unbounded wall follows the same a/outside, b/inside convention. */
+export declare function openingInteriorFace(opening: Pick<CasedOpening, 'parentId' | 'roofSegmentId'>, nodes: Readonly<Record<string, AnyNode>>): WallFace;
+/**
+ * The host an opening is cased on: its wall, or the roof-segment face it is cut into (a gable
+ * end, whose face `a` is the outside). Null where casing has nowhere to go: a curtain wall, a
+ * railing (its openings are gaps in the guard), a dormer face, a unit built from a script (its
+ * script draws its own trim).
+ */
+export declare function resolveOpeningCasingHost(opening: CasedOpening, nodes: Readonly<Record<string, AnyNode>>, host?: AnyNode | undefined): OpeningCasingHost | null;
+/** The host faces an opening is cased on: both unless turned off (a save from before has both). */
+export declare function openingCasingFaces(opening: Pick<CasedOpening, 'position' | 'casingFaceA' | 'casingFaceB'>, host: OpeningCasingHost): OpeningCasingFace[];
+/** The casing boards of a rectangular opening on each face it is cased on, in the host frame. */
+export declare function openingCasingBoards(opening: CasedOpening, host: OpeningCasingHost): OpeningCasingBoard[];
+//# sourceMappingURL=opening-casing.d.ts.map

package/dist/lib/opening-casing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-casing.d.ts","sourceRoot":"","sources":["../../src/lib/opening-casing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACxE,OAAO,EAAE,4BAA4B,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAA;AAOlG;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,4BAA4B,EAAE,oBAAoB,EAAE,CAAA;AAE7D,KAAK,YAAY,GAAG,QAAQ,GAAG,UAAU,CAAA;AAIzC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,mGAAmG;IACnG,SAAS,EAAE,MAAM,CAAA;IACjB,4DAA4D;IAC5D,YAAY,CAAC,EAAE,QAAQ,CAAA;IACvB,YAAY,CAAC,EAAE,QAAQ,CAAA;IACvB,mGAAmG;IACnG,SAAS,CAAC,EAAE,OAAO,GAAG,KAAK,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,QAAQ,CAAA;IACd,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAA;IACb,sEAAsE;IACtE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;CACZ,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,QAAQ,CAAA;IACd;;;OAGG;IACH,IAAI,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAA;IACxC,+DAA+D;IAC/D,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,yCAAyC;IACzC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAC/B,CAAA;AAED,+FAA+F;AAC/F,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,aAAa,CAAC,GAAG,MAAM,CAGrF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAE1F;AAED,iGAAiG;AACjG,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,UAAU,GAAG,eAAe,CAAC,EACzD,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,QAAQ,CAKV;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,IAAI,GAAE,OAAO,GAAG,SAAkE,GACjF,iBAAiB,GAAG,IAAI,CA2B1B;AAED,mGAAmG;AACnG,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,UAAU,GAAG,aAAa,GAAG,aAAa,CAAC,EACvE,IAAI,EAAE,iBAAiB,GACtB,iBAAiB,EAAE,CAOrB;AAcD,iGAAiG;AACjG,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,iBAAiB,GACtB,kBAAkB,EAAE,CAoCtB"}

package/dist/lib/opening-casing.js

@@ -0,0 +1,131 @@
+import { DEFAULT_OPENING_CASING_WIDTH, OPENING_CASING_PROUD } from '../schema/nodes/opening-types.js';
+import { DEFAULT_WALL_THICKNESS, getWallThickness } from '../systems/wall/wall-footprint.js';
+import { roomSideFaces } from '../systems/wall/wall-room-sides.js';
+import { cornerPair } from './corner-pair.js';
+import { getDoorOpeningSize } from './door-opening.js';
+import { openingExteriorFace } from './opening-exterior-face.js';
+/**
+ * Door and window casing: flat boards on the finished faces of the host wall
+ * around the opening, over the drywall or siding. The wall cutout is the unit's
+ * own width × height and the casing never reaches into it: each board starts at
+ * the cutout's edge and runs outward, `OPENING_CASING_PROUD` off the face. A
+ * window gets a picture frame (head, two legs, bottom), a door a head and two
+ * legs, butted at the corners: the head and bottom run the full width over the
+ * legs' ends.
+ *
+ * Everything here is in the host frame, centred on the opening: x along the
+ * host toward its end, y up, z across it toward face `a`. The 3D builders turn
+ * that into the unit's own frame (a unit facing the back is turned half round,
+ * see `openingHostFacing`); the plan draws it as it is.
+ */
+export { DEFAULT_OPENING_CASING_WIDTH, OPENING_CASING_PROUD };
+/** The face width of an opening's casing boards; a save from before casing has the default. */
+export function openingCasingWidth(opening) {
+    const width = opening.casingWidth;
+    return typeof width === 'number' && width > 0 ? width : DEFAULT_OPENING_CASING_WIDTH;
+}
+/**
+ * +1 when the unit faces the host's front (its own +z is face `a`), -1 when it is turned half
+ * round to face the back, which mirrors its x and z against the host's.
+ */
+export function openingHostFacing(opening) {
+    return Math.cos(opening.rotation?.[1] ?? 0) >= 0 ? 1 : -1;
+}
+/** Roof face a is outside; an unbounded wall follows the same a/outside, b/inside convention. */
+export function openingInteriorFace(opening, nodes) {
+    if (!opening.roofSegmentId && opening.parentId && nodes[opening.parentId]?.type === 'wall') {
+        return roomSideFaces(nodes, opening.parentId).inside ?? 'b';
+    }
+    return 'b';
+}
+/**
+ * The host an opening is cased on: its wall, or the roof-segment face it is cut into (a gable
+ * end, whose face `a` is the outside). Null where casing has nowhere to go: a curtain wall, a
+ * railing (its openings are gaps in the guard), a dormer face, a unit built from a script (its
+ * script draws its own trim).
+ */
+export function resolveOpeningCasingHost(opening, nodes, host = nodes[opening.roofSegmentId ?? opening.parentId ?? '']) {
+    if (opening.source)
+        return null;
+    const exteriorFace = opening.type === 'window' ? openingExteriorFace(opening, nodes) : undefined;
+    const interior = opening.type === 'window'
+        ? {
+            exteriorFace,
+            ...(opening.sillInterior
+                ? {
+                    interiorFace: exteriorFace === 'a' ? 'b' : 'a',
+                }
+                : {}),
+        }
+        : {};
+    if (opening.roofSegmentId) {
+        return host?.type === 'roof-segment'
+            ? { thickness: host.wallThickness ?? DEFAULT_WALL_THICKNESS, ...interior }
+            : null;
+    }
+    if (host?.type !== 'wall' || host.wallType === 'curtain' || host.wallType === 'railing')
+        return null;
+    const pair = opening.type === 'window' ? cornerPair(nodes, opening) : null;
+    return {
+        thickness: getWallThickness(host),
+        ...interior,
+        ...(pair ? { cornerEnd: pair.end } : {}),
+    };
+}
+/** The host faces an opening is cased on: both unless turned off (a save from before has both). */
+export function openingCasingFaces(opening, host) {
+    const offset = opening.position[2] ?? 0;
+    const half = host.thickness / 2;
+    const faces = [];
+    if (opening.casingFaceA === true)
+        faces.push({ face: 'a', plane: half - offset, out: 1 });
+    if (opening.casingFaceB === true)
+        faces.push({ face: 'b', plane: -half - offset, out: -1 });
+    return faces;
+}
+/** The casing bottom clears whichever sill is on this host face. */
+function sillDrop(opening, face, host) {
+    if (opening.type !== 'window' || opening.openingKind === 'opening')
+        return 0;
+    const front = host.exteriorFace ?? (openingHostFacing(opening) === 1 ? 'a' : 'b');
+    return Math.max(opening.sill && face === front ? Math.max(opening.sillThickness ?? 0, 0) : 0, opening.sillInterior && face === (host.interiorFace ?? 'b')
+        ? (opening.sillInteriorThickness ?? 0.03)
+        : 0);
+}
+/** The casing boards of a rectangular opening on each face it is cased on, in the host frame. */
+export function openingCasingBoards(opening, host) {
+    const width = openingCasingWidth(opening);
+    const proud = OPENING_CASING_PROUD;
+    const size = getDoorOpeningSize(opening);
+    const halfWidth = size.width / 2;
+    const halfHeight = size.height / 2;
+    const offsetX = -size.leafOffsetX * openingHostFacing(opening);
+    const offsetY = (size.height - opening.height) / 2;
+    const corner = host.cornerEnd === 'start' ? -1 : host.cornerEnd === 'end' ? 1 : 0;
+    const left = -halfWidth - (corner === -1 ? 0 : width);
+    const right = halfWidth + (corner === 1 ? 0 : width);
+    const legs = [-1, 1]
+        .filter((side) => side !== corner)
+        .map((side) => side < 0 ? [-halfWidth - width, -halfWidth] : [halfWidth, halfWidth + width]);
+    const boards = [];
+    for (const { face, plane, out } of openingCasingFaces(opening, host)) {
+        const z = plane + (out * proud) / 2;
+        const board = (part, [x0, x1], [y0, y1]) => boards.push({
+            face,
+            part,
+            center: [(x0 + x1) / 2 + offsetX, (y0 + y1) / 2 + offsetY, z],
+            size: [x1 - x0, y1 - y0, proud],
+        });
+        board('head', [left, right], [halfHeight, halfHeight + width]);
+        for (const along of legs)
+            board('leg', along, [-halfHeight, halfHeight]);
+        if (opening.type !== 'window')
+            continue;
+        const drop = sillDrop(opening, face, host);
+        if (drop > 1e-6)
+            for (const along of legs)
+                board('foot', along, [-halfHeight - drop, -halfHeight]);
+        board('bottom', [left, right], [-halfHeight - drop - width, -halfHeight - drop]);
+    }
+    return boards;
+}

package/dist/lib/opening-exterior-face.d.ts

@@ -0,0 +1,6 @@
+import type { AnyNode, WallFace, WindowNode } from '../schema/index.js';
+type Opening = Pick<WindowNode, 'parentId' | 'wallId' | 'roofSegmentId' | 'dormerId' | 'side' | 'rotation'>;
+/** The unoccupied face; ambiguous walls retain the placement face. Generated roof faces face out on a. */
+export declare function openingExteriorFace(opening: Opening, nodes: Readonly<Record<string, AnyNode>>): WallFace;
+export {};
+//# sourceMappingURL=opening-exterior-face.d.ts.map

package/dist/lib/opening-exterior-face.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-exterior-face.d.ts","sourceRoot":"","sources":["../../src/lib/opening-exterior-face.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAG9D,KAAK,OAAO,GAAG,IAAI,CACjB,UAAU,EACV,UAAU,GAAG,QAAQ,GAAG,eAAe,GAAG,UAAU,GAAG,MAAM,GAAG,UAAU,CAC3E,CAAA;AAED,0GAA0G;AAC1G,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,QAAQ,CASV"}