@pascal-app/core 1.0.3 → 1.0.5

package/dist/lib/corner-pair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corner-pair.d.ts","sourceRoot":"","sources":["../../src/lib/corner-pair.ts"],"names":[],"mappings":"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"}

package/dist/lib/corner-pair.js

@@ -0,0 +1,130 @@
+/** How close a wall's end must be to a point to meet there (m). */
+const AT = 1e-3;
+/** How close a window's edge must be to its wall's end to be one side of a corner pair (m). */
+const REACHES = 0.01;
+/**
+ * How near a corner a window counts as being at it, to wrap it or join it to the window on the
+ * other wall (m); a window this near is slid to the corner when it joins.
+ */
+export const CORNER_REACH_M = 0.3;
+/** A corner this close to folded back or to straight is no corner (degrees). */
+export const DEGENERATE_CORNER_DEG = 10;
+/** Whether two walls meeting at `angle` (degrees) make a corner a window can wrap. */
+export const isWrappableAngle = (angle) => angle >= DEGENERATE_CORNER_DEG && angle <= 180 - DEGENERATE_CORNER_DEG;
+/**
+ * Whether the glass of a window fuses at a corner: a fixed, rectangular, framed window's does. The
+ * other families keep their frames, so their sides meet at the frames as at a post.
+ */
+export const fusesAtCorner = (window) => !window.source &&
+    window.openingKind !== 'opening' &&
+    (window.windowType ?? 'fixed') === 'fixed' &&
+    (window.openingShape ?? 'rectangle') === 'rectangle';
+const distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
+export const wallLengthOf = (wall) => distance(wall.start, wall.end);
+export const wallEndPoint = (wall, end) => end === 'start' ? wall.start : wall.end;
+/** The walls of a level ending at a point, with the end that does. */
+export function wallsEndingAt(nodes, levelId, point, includeCurved = false) {
+    return Object.values(nodes).flatMap((node) => {
+        if (node.type !== 'wall' ||
+            (levelId && node.parentId !== levelId) ||
+            (node.curveOffset && !includeCurved))
+            return [];
+        const wall = node;
+        const end = distance(wall.start, point) <= AT ? 'start' : distance(wall.end, point) <= AT ? 'end' : null;
+        return end ? [{ wall, end }] : [];
+    });
+}
+/** The angle two walls make at the corner they share, between their directions away from it. */
+export function cornerAngle(a, b) {
+    const away = ({ wall, end }) => {
+        const [from, to] = end === 'start' ? [wall.start, wall.end] : [wall.end, wall.start];
+        const length = distance(from, to);
+        return [(to[0] - from[0]) / length, (to[1] - from[1]) / length];
+    };
+    const [u, v] = [away(a), away(b)];
+    const cos = Math.max(-1, Math.min(1, u[0] * v[0] + u[1] * v[1]));
+    return (Math.acos(cos) * 180) / Math.PI;
+}
+/** Whether a window's edge reaches `end` of its wall. */
+export function windowReachesEnd(nodes, window, end) {
+    const wall = nodes[window.parentId ?? ''];
+    return wall?.type === 'wall' && Math.abs(windowEndGap(wall, window, end)) <= REACHES;
+}
+/** The end of its wall a window's edge reaches, if it reaches one; `start` when it spans the wall. */
+export function windowCornerEnd(nodes, window) {
+    return windowReachesEnd(nodes, window, 'start')
+        ? 'start'
+        : windowReachesEnd(nodes, window, 'end')
+            ? 'end'
+            : null;
+}
+/** How far a window's edge is from an end of its wall (m); negative past it. */
+export function windowEndGap(wall, window, end) {
+    return end === 'start'
+        ? window.position[0] - window.width / 2
+        : wallLengthOf(wall) - (window.position[0] + window.width / 2);
+}
+/** The end of its wall a window is within `reach` of, the nearer if both; null when neither. */
+export function windowNearCornerEnd(nodes, window, reach = CORNER_REACH_M) {
+    const wall = nodes[window.parentId ?? ''];
+    if (wall?.type !== 'wall')
+        return null;
+    const gaps = ['start', 'end']
+        .map((end) => ({ end, gap: windowEndGap(wall, window, end) }))
+        .filter(({ gap }) => gap <= reach)
+        .sort((a, b) => a.gap - b.gap);
+    return gaps[0]?.end ?? null;
+}
+/**
+ * A window's corner pair: its wall, the end it runs to, the partner on the other wall and the
+ * angle between the walls; null when it has none. A `corner` that no longer makes one is no pair:
+ * the partner gone or not naming it back, either side moved off its corner, or the walls no longer
+ * meeting there on one level at an angle a window wraps.
+ */
+export function cornerPair(nodes, window) {
+    const corner = window.corner;
+    const partner = corner ? nodes[corner.partnerId] : undefined;
+    if (!corner || partner?.type !== 'window')
+        return null;
+    const other = partner;
+    if (other.corner?.partnerId !== window.id)
+        return null;
+    if (!windowReachesEnd(nodes, window, corner.end) ||
+        !windowReachesEnd(nodes, other, other.corner.end))
+        return null;
+    const [wall, partnerWall] = [nodes[window.parentId ?? ''], nodes[other.parentId ?? '']];
+    if (wall?.type !== 'wall' || partnerWall?.type !== 'wall' || wall.id === partnerWall.id)
+        return null;
+    if (wall.parentId !== partnerWall.parentId ||
+        distance(wallEndPoint(wall, corner.end), wallEndPoint(partnerWall, other.corner.end)) > AT)
+        return null;
+    const angle = cornerAngle({ wall: wall, end: corner.end }, { wall: partnerWall, end: other.corner.end });
+    if (!isWrappableAngle(angle))
+        return null;
+    return {
+        wall: wall,
+        end: corner.end,
+        partner: other,
+        partnerWall,
+        angle,
+        post: corner.post,
+    };
+}
+/**
+ * The updates that clear a window's `corner`, and its partner's when the partner names it back:
+ * Unwrap, and what a move, a delete or a merge leaves when the window is no longer one side of
+ * that pair. Whether the pair still holds or not, so a broken link is never left behind.
+ */
+export function cornerLinkClears(nodes, windowId) {
+    const window = nodes[windowId];
+    const corner = window?.type === 'window' ? window.corner : undefined;
+    if (!corner)
+        return [];
+    const partner = nodes[corner.partnerId];
+    return [
+        { id: windowId, data: { corner: undefined } },
+        ...(partner?.type === 'window' && partner.corner?.partnerId === windowId
+            ? [{ id: partner.id, data: { corner: undefined } }]
+            : []),
+    ];
+}

package/dist/lib/corner-snap.d.ts

@@ -0,0 +1,54 @@
+import type { AnyNode, WallNode } from '../schema/index.js';
+import { type WallEnd } from './corner-pair.js';
+/**
+ * Placing or dragging a window near a corner: inside the corner zone the window snaps its edge to
+ * the corner and the window waiting on the other wall, if any, is found, so the tool can highlight
+ * it and say the two will join. Pure: the tools read the answer.
+ */
+type Nodes = Readonly<Record<string, AnyNode>>;
+/** How near a corner the zone starts (m): a window's edge this close to a wall's end snaps to it. */
+export declare const CORNER_SNAP_ENTER_M = 0.3;
+/** How far out the zone reaches for a window already snapped (m), so its edge does not flicker. */
+export declare const CORNER_SNAP_EXIT_M: number;
+export type CornerSnap = {
+    /** The end of the window's wall the corner is at. */
+    end: WallEnd;
+    /** The window's centre along its wall once snapped (m). */
+    centreX: number;
+    corner: [number, number];
+    otherWall: WallNode;
+    otherEnd: WallEnd;
+    /** The window waiting at the other wall's corner, the nearest, if one is. */
+    waitingId: string | null;
+};
+/**
+ * Why a wall end in the zone is not a corner window's: a lone wall, a T-junction, a curved or
+ * curtain wall, a flat angle or a full wall would otherwise give no sign, so the hint says it. With
+ * a window waiting, why the two cannot join: an opening in the way of sliding them to the corner,
+ * or the waiting window too tall for this wall.
+ */
+export type CornerBlockReason = 'free_end' | 'several_walls' | 'angle' | 'curved' | 'curtain' | 'no_room' | 'in_the_way' | 'too_tall';
+export type CornerBlock = {
+    reason: CornerBlockReason;
+    end: WallEnd;
+};
+export type CornerInput = {
+    wallId: string;
+    /** Where the window's centre is along its wall (m). */
+    centreX: number;
+    width: number;
+    /** The window's height and the sill it stands at (m), for the match the other wall would take. */
+    height?: number;
+    sillHeight?: number;
+    /** The window being dragged: never the one waiting. */
+    ignoreId?: string;
+    /** The end snapped to or blocked at the last time, so the zone is wider while the window stays in it. */
+    held?: WallEnd | null;
+};
+/** The snap and the block for one window position: at most one of them is set. */
+export declare function evaluateCorner(nodes: Nodes, input: CornerInput): {
+    snap: CornerSnap | null;
+    block: CornerBlock | null;
+};
+export {};
+//# sourceMappingURL=corner-snap.d.ts.map

package/dist/lib/corner-snap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corner-snap.d.ts","sourceRoot":"","sources":["../../src/lib/corner-snap.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAc,MAAM,WAAW,CAAA;AAC9D,OAAO,EAKL,KAAK,OAAO,EAMb,MAAM,eAAe,CAAA;AAEtB;;;;GAIG;AAEH,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAE9C,qGAAqG;AACrG,eAAO,MAAM,mBAAmB,MAAiB,CAAA;AACjD,mGAAmG;AACnG,eAAO,MAAM,kBAAkB,QAAuB,CAAA;AAEtD,MAAM,MAAM,UAAU,GAAG;IACvB,qDAAqD;IACrD,GAAG,EAAE,OAAO,CAAA;IACZ,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxB,SAAS,EAAE,QAAQ,CAAA;IACnB,QAAQ,EAAE,OAAO,CAAA;IACjB,6EAA6E;IAC7E,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CACzB,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GACzB,UAAU,GACV,eAAe,GACf,OAAO,GACP,QAAQ,GACR,SAAS,GACT,SAAS,GACT,YAAY,GACZ,UAAU,CAAA;AAEd,MAAM,MAAM,WAAW,GAAG;IAAE,MAAM,EAAE,iBAAiB,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,CAAA;AAErE,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,uDAAuD;IACvD,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,kGAAkG;IAClG,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,yGAAyG;IACzG,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;CACtB,CAAA;AAoHD,kFAAkF;AAClF,wBAAgB,cAAc,CAC5B,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,WAAW,GACjB;IAAE,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAA;CAAE,CAMxD"}

package/dist/lib/corner-snap.js

@@ -0,0 +1,125 @@
+import { isAgentRefusal } from '../agent-tools/refusal.js';
+import { mergeWindows } from '../building/merge-windows.js';
+import { planWallOpening } from '../building/wall-openings.js';
+import { CORNER_REACH_M, cornerAngle, cornerPair, isWrappableAngle, wallEndPoint, wallLengthOf, wallsEndingAt, windowEndGap, windowNearCornerEnd, } from './corner-pair.js';
+/** How near a corner the zone starts (m): a window's edge this close to a wall's end snaps to it. */
+export const CORNER_SNAP_ENTER_M = CORNER_REACH_M;
+/** How far out the zone reaches for a window already snapped (m), so its edge does not flicker. */
+export const CORNER_SNAP_EXIT_M = CORNER_REACH_M + 0.1;
+const isCurved = (wall) => Boolean(wall.curveOffset);
+const isCurtain = (wall) => wall.wallType === 'curtain';
+function evaluate(nodes, input) {
+    const wall = nodes[input.wallId];
+    if (wall?.type !== 'wall')
+        return null;
+    const length = wallLengthOf(wall);
+    if (input.width > length)
+        return null;
+    const gaps = ['start', 'end']
+        .map((end) => ({
+        end,
+        gap: end === 'start'
+            ? input.centreX - input.width / 2
+            : length - (input.centreX + input.width / 2),
+    }))
+        .filter(({ end, gap }) => gap <= (input.held === end ? CORNER_SNAP_EXIT_M : CORNER_SNAP_ENTER_M))
+        .sort((a, b) => a.gap - b.gap);
+    const end = gaps[0]?.end;
+    if (!end)
+        return null;
+    const blocked = (reason) => ({ block: { reason, end } });
+    if (isCurved(wall))
+        return blocked('curved');
+    const point = wallEndPoint(wall, end);
+    // Curved walls are counted here only to be named: they never make a corner window.
+    const others = wallsEndingAt(nodes, wall.parentId ?? undefined, point, true).filter((meeting) => meeting.wall.id !== wall.id);
+    if (others.some((meeting) => isCurved(meeting.wall)))
+        return blocked('curved');
+    if (others.length === 0)
+        return blocked('free_end');
+    if (others.length > 1)
+        return blocked('several_walls');
+    const { wall: otherWall, end: otherEnd } = others[0];
+    if (isCurtain(wall) || isCurtain(otherWall))
+        return blocked('curtain');
+    const angle = cornerAngle({ wall: wall, end }, { wall: otherWall, end: otherEnd });
+    if (!isWrappableAngle(angle))
+        return blocked('angle');
+    const waiting = Object.values(nodes)
+        .filter((node) => node.type === 'window' &&
+        node.parentId === otherWall.id &&
+        node.id !== input.ignoreId &&
+        // Free, or the partner of the window being dragged: dropped back, the pair holds.
+        [undefined, input.ignoreId].includes(cornerPair(nodes, node)?.partner.id) &&
+        !node.metadata?.isTransient &&
+        windowNearCornerEnd(nodes, node) === otherEnd)
+        .sort((a, b) => windowEndGap(otherWall, a, otherEnd) - windowEndGap(otherWall, b, otherEnd))[0];
+    const centreX = end === 'start' ? input.width / 2 : length - input.width / 2;
+    // With a window waiting, the click merges the two: where that merge would be refused, the corner
+    // says why rather than placing a plain window on the click.
+    const self = input.ignoreId ? nodes[input.ignoreId] : undefined;
+    if (waiting && self?.type === 'window') {
+        const height = input.height ?? self.height;
+        const sill = input.sillHeight ?? self.position[1] - self.height / 2;
+        const placed = {
+            ...self,
+            parentId: wall.id,
+            width: input.width,
+            height,
+            position: [centreX, sill + height / 2, self.position[2]],
+            corner: undefined,
+        };
+        try {
+            mergeWindows({ ...nodes, [placed.id]: placed }, waiting.id, placed.id);
+        }
+        catch (error) {
+            if (!isAgentRefusal(error))
+                throw error;
+            return error.code === 'height_exceeds_wall'
+                ? blocked('too_tall')
+                : error.code === 'opening_overlap'
+                    ? blocked('in_the_way')
+                    : null;
+        }
+    }
+    // With none waiting the click makes the match on the other wall: if that wall cannot take it,
+    // the corner is not offered.
+    if (!waiting) {
+        const otherLength = wallLengthOf(otherWall);
+        const width = Math.min(input.width, otherLength);
+        const height = input.height ?? 1.5;
+        try {
+            planWallOpening(nodes, {
+                kind: 'window',
+                wallId: otherWall.id,
+                t: (otherEnd === 'start' ? width / 2 : otherLength - width / 2) / otherLength,
+                width,
+                height,
+                ...(input.sillHeight === undefined ? {} : { sillHeight: input.sillHeight }),
+            });
+        }
+        catch (error) {
+            if (isAgentRefusal(error))
+                return blocked('no_room');
+            throw error;
+        }
+    }
+    return {
+        snap: {
+            end,
+            centreX,
+            corner: [point[0], point[1]],
+            otherWall,
+            otherEnd,
+            waitingId: waiting?.id ?? null,
+        },
+    };
+}
+/** The snap and the block for one window position: at most one of them is set. */
+export function evaluateCorner(nodes, input) {
+    const found = evaluate(nodes, input);
+    return {
+        snap: found && 'snap' in found ? found.snap : null,
+        block: found && 'block' in found ? found.block : null,
+    };
+}

package/dist/lib/critically-damped.d.ts

@@ -0,0 +1,11 @@
+/**
+ * One step of a critically damped spring (the exact solution, so frames of any length take the same
+ * path): it settles on `target` in about `response` seconds without overshooting, and a new target
+ * turns it around from where it is, carrying its speed. The camera that follows a build and the roof
+ * that lifts out of its way move this way.
+ */
+export declare function criticallyDamped(state: {
+    x: number;
+    v: number;
+}, target: number, response: number, dt: number): void;
+//# sourceMappingURL=critically-damped.d.ts.map

package/dist/lib/critically-damped.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"critically-damped.d.ts","sourceRoot":"","sources":["../../src/lib/critically-damped.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAC/B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,GACT,IAAI,CAON"}

package/dist/lib/critically-damped.js

@@ -0,0 +1,14 @@
+/**
+ * One step of a critically damped spring (the exact solution, so frames of any length take the same
+ * path): it settles on `target` in about `response` seconds without overshooting, and a new target
+ * turns it around from where it is, carrying its speed. The camera that follows a build and the roof
+ * that lifts out of its way move this way.
+ */
+export function criticallyDamped(state, target, response, dt) {
+    const omega = (2 * Math.PI) / Math.max(1e-3, response);
+    const offset = state.x - target;
+    const carry = state.v + omega * offset;
+    const decay = Math.exp(-omega * dt);
+    state.x = target + (offset + carry * dt) * decay;
+    state.v = (state.v - omega * carry * dt) * decay;
+}

package/dist/lib/cutter-host.d.ts

@@ -0,0 +1,5 @@
+import type { AnyNode } from '../schema/index.js';
+export declare function isCutterName(name: string): boolean;
+/** A cutter can only remove its object's host, never an overlapping neighbour. */
+export declare function resolveCutterHost(node: AnyNode, name: string, nodes: Readonly<Record<string, AnyNode>>): AnyNode | undefined;
+//# sourceMappingURL=cutter-host.d.ts.map

package/dist/lib/cutter-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cutter-host.d.ts","sourceRoot":"","sources":["../../src/lib/cutter-host.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAY,MAAM,WAAW,CAAA;AAMlD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED,kFAAkF;AAClF,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,OAAO,GAAG,SAAS,CAyBrB"}

package/dist/lib/cutter-host.js

@@ -0,0 +1,30 @@
+import { getScaledDimensions } from '../schema/nodes/item.js';
+import { liftedManualSlab } from './floor-construction-lift.js';
+import { selectSlabSupportForItem } from './item-slab-support.js';
+import { getRenderableSlabPolygon, slabPolygonContextForLevel } from './slab-polygon.js';
+export function isCutterName(name) {
+    return name === 'cutout' || name === 'cut:wall' || name === 'cut:ceiling' || name === 'cut:slab';
+}
+/** A cutter can only remove its object's host, never an overlapping neighbour. */
+export function resolveCutterHost(node, name, nodes) {
+    if (!isCutterName(name))
+        return;
+    const parentId = node.parentId ?? ('wallId' in node ? node.wallId : undefined);
+    const parent = parentId ? nodes[parentId] : undefined;
+    let host;
+    if (parent?.type === 'wall' || parent?.type === 'ceiling' || parent?.type === 'slab') {
+        host = parent;
+    }
+    else if (node.type === 'item' && !node.asset.attachTo && parent?.type === 'level') {
+        if (node.supportSlabId === 'ground')
+            return;
+        const context = slabPolygonContextForLevel(parent, (id) => nodes[id]);
+        const slabs = Object.values(nodes)
+            .filter((candidate) => candidate.type === 'slab' && candidate.parentId === parent.id)
+            .map((slab) => liftedManualSlab(nodes, slab));
+        host = selectSlabSupportForItem(slabs, { position: node.position, dimensions: getScaledDimensions(node), rotation: node.rotation }, (slab) => getRenderableSlabPolygon(slab, context), { preferredSlabId: node.supportSlabId });
+    }
+    if (name !== 'cutout' && host?.type !== name.slice(4))
+        return;
+    return host;
+}

package/dist/lib/deepest-drawn.d.ts

@@ -0,0 +1,18 @@
+import type { AnyNode, AnyNodeId } from '../schema/index.js';
+type Nodes = Record<AnyNodeId, AnyNode>;
+/**
+ * The lowest the site's ground lies: the sculpted terrain's lowest height where the site has one,
+ * the flat plane everywhere else. How far a dive under the ground is measured from.
+ */
+export declare function lowestGroundY(nodes: Nodes): number;
+/**
+ * The world Y of the deepest thing the scene draws: the bottom of the footing under the lowest floor
+ * slab (its underside less a footing's thickness; never above the walls' base, as the footing
+ * itself is). A recessed slab (a basin) is drawn down to its own underside, with no footing under
+ * it. Site flatwork (a lawn, a driveway) is not a floor of the house and counts for nothing. A
+ * footing under a floor at or over grade sits about as deep, and never nearer the dive's own floor,
+ * so the floors alone decide. `null` for a scene with no floor.
+ */
+export declare function deepestDrawnY(nodes: Nodes): number | null;
+export {};
+//# sourceMappingURL=deepest-drawn.d.ts.map

package/dist/lib/deepest-drawn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepest-drawn.d.ts","sourceRoot":"","sources":["../../src/lib/deepest-drawn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAQnD,KAAK,KAAK,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;AAIvC;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAclD;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CAsBzD"}

package/dist/lib/deepest-drawn.js

@@ -0,0 +1,65 @@
+import { getLevelElevations } from '../services/storey.js';
+import { FOUNDATION_STANDARD } from './foundation-standard.js';
+import { isSiteFlatwork } from './site-flatwork.js';
+import { FLAT_GROUND_Y } from './site-ground-height.js';
+import { heightAtSample } from './terrain-field.js';
+import { terrainFieldOf } from './terrain-source.js';
+const lowestHeight = new WeakMap();
+/**
+ * The lowest the site's ground lies: the sculpted terrain's lowest height where the site has one,
+ * the flat plane everywhere else. How far a dive under the ground is measured from.
+ */
+export function lowestGroundY(nodes) {
+    const site = Object.values(nodes).find((node) => node.type === 'site');
+    const field = site ? terrainFieldOf(site) : null;
+    if (!field)
+        return FLAT_GROUND_Y;
+    let lowest = lowestHeight.get(field);
+    if (lowest === undefined) {
+        lowest = Number.POSITIVE_INFINITY;
+        for (let row = 0; row < field.rows; row += 1)
+            for (let col = 0; col < field.cols; col += 1)
+                lowest = Math.min(lowest, heightAtSample(field, col, row));
+        if (!Number.isFinite(lowest))
+            lowest = FLAT_GROUND_Y;
+        lowestHeight.set(field, lowest);
+    }
+    return lowest;
+}
+/**
+ * The world Y of the deepest thing the scene draws: the bottom of the footing under the lowest floor
+ * slab (its underside less a footing's thickness; never above the walls' base, as the footing
+ * itself is). A recessed slab (a basin) is drawn down to its own underside, with no footing under
+ * it. Site flatwork (a lawn, a driveway) is not a floor of the house and counts for nothing. A
+ * footing under a floor at or over grade sits about as deep, and never nearer the dive's own floor,
+ * so the floors alone decide. `null` for a scene with no floor.
+ */
+export function deepestDrawnY(nodes) {
+    const elevations = getLevelElevations(nodes);
+    let deepest = null;
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'level')
+            continue;
+        const elevation = elevations.get(node.id);
+        if (!elevation)
+            continue;
+        const building = elevation.buildingId ? nodes[elevation.buildingId] : undefined;
+        const planeY = (building?.type === 'building' ? building.position[1] : 0) + elevation.baseY;
+        let floorUnderside = planeY;
+        let basinUnderside = Number.POSITIVE_INFINITY;
+        for (const id of node.children) {
+            const child = nodes[id];
+            if (child?.type !== 'slab' || isSiteFlatwork(child))
+                continue;
+            const underside = planeY + child.elevation - child.thickness;
+            if (child.recessed === true)
+                basinUnderside = Math.min(basinUnderside, underside);
+            else
+                floorUnderside = Math.min(floorUnderside, underside);
+        }
+        const bottom = Math.min(floorUnderside - FOUNDATION_STANDARD.footingThickness, basinUnderside);
+        if (deepest === null || bottom < deepest)
+            deepest = bottom;
+    }
+    return deepest;
+}

package/dist/lib/door-operation.d.ts

@@ -1,7 +1,7 @@
 import type { DoorNode, DoorType } from '../schema/nodes/door.js';
 export declare const SECTIONAL_GARAGE_RENDER_OPEN_SCALE = 0.88;
 export declare function clampDoorOperationState(value: number | undefined): number;
-export declare function isOperationDoorType(doorType: DoorType | DoorNode['doorType'] | string | undefined): doorType is "folding" | "pocket" | "barn" | "sliding" | "garage-sectional" | "garage-rollup" | "garage-tiltup";
+export declare function isOperationDoorType(doorType: DoorType | DoorNode['doorType'] | string | undefined): doorType is "barn" | "folding" | "garage-rollup" | "garage-sectional" | "garage-tiltup" | "pocket" | "sliding";
 export declare function getDoorRenderOpenAmount(doorType: DoorType | DoorNode['doorType'], operationState: number | undefined): number;
 export declare function getGarageVisibleOpeningRatio(doorType: DoorType | DoorNode['doorType'], operationState: number | undefined): number;
 //# sourceMappingURL=door-operation.d.ts.map

package/dist/lib/exterior-wall-loops.d.ts

@@ -0,0 +1,17 @@
+import type { WallNode } from '../schema/index.js';
+import { type SpaceBoundaryFace } from './room-graph.js';
+/**
+ * The outside loops of a storey's walls. Wall ends within `joinTolerance` metres are one corner: a
+ * millimetre by default; a vectorised plan's near-miss corners may need a few centimetres.
+ */
+export declare function exteriorWallLoops(walls: WallNode[], joinTolerance?: number): SpaceBoundaryFace[][];
+/** The outlines of a storey's walls: each outside loop as a polygon on the walls' centrelines. */
+export declare function exteriorWallOutlines(walls: WallNode[], joinTolerance?: number): [number, number][][];
+/**
+ * The walls a closed circuit of walls encloses: not on the storey's outline and strictly inside one
+ * of its outside loops (a partition, as opposed to a wall that holds the outside back). A wall no
+ * closed circuit surrounds (an open run, the first walls of a plan, a wall drawn outside) is not
+ * enclosed.
+ */
+export declare function enclosedWallIds(walls: WallNode[], joinTolerance?: number): Set<WallNode['id']>;
+//# sourceMappingURL=exterior-wall-loops.d.ts.map

package/dist/lib/exterior-wall-loops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exterior-wall-loops.d.ts","sourceRoot":"","sources":["../../src/lib/exterior-wall-loops.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC,OAAO,EAOL,KAAK,iBAAiB,EAEvB,MAAM,cAAc,CAAA;AAwVrB;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,QAAQ,EAAE,EACjB,aAAa,SAA0B,GACtC,iBAAiB,EAAE,EAAE,CAEvB;AAED,kGAAkG;AAClG,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,EAAE,EACjB,aAAa,SAA0B,GACtC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,CAEtB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,QAAQ,EAAE,EACjB,aAAa,SAA0B,GACtC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAmBrB"}