@pascal-app/core 1.0.6 → 1.1.0

package/dist/lib/porch-framing-sync.js

@@ -0,0 +1,206 @@
+import { beamBottomElevation, createBeam } from './beam.js';
+import { createFramingPost, FRAMING_POST_MIN_HEIGHT, framingPostFields, framingPostSize, } from './framing-post.js';
+import { planPorchFraming, porchFramingSettings } from './porch-framing.js';
+/** The porch a post or beam was made for, when the kernel made it. */
+export function porchPartOf(node) {
+    if (node?.type !== 'column' && node?.type !== 'beam')
+        return null;
+    const metadata = node.metadata;
+    return typeof metadata?.porchOf === 'string' && typeof metadata.porchPart === 'string'
+        ? metadata
+        : null;
+}
+/** Keep generated parts linked when reconciliation assigns their room its stable ID. */
+export function remapPorchOwner(metadata, ids) {
+    return typeof metadata?.porchOf === 'string' && ids.has(metadata.porchOf)
+        ? { ...metadata, porchOf: ids.get(metadata.porchOf) }
+        : undefined;
+}
+const round = (value) => Math.round(value * 1e6) / 1e6;
+/** A part's shape, as it was made: anything else is a hand edit. */
+function seedOf(part) {
+    if (part.type === 'column')
+        return JSON.stringify([part.position[0], part.position[2], part.width, part.depth, part.height, part.rotation].map(round));
+    return JSON.stringify([
+        ...[...part.start, ...part.end, part.width, part.depth].map(round),
+        part.topElevation === undefined ? null : round(part.topElevation),
+        part.placement,
+    ]);
+}
+/**
+ * A porch part's id and shape, for the structure sync to notice a hand edit or a delete (and run
+ * the kernel, which hands the porch's framing over); null for any other node.
+ */
+export function porchPartSignature(node) {
+    return porchPartOf(node) ? JSON.stringify([node.id, seedOf(node)]) : null;
+}
+function edited(part) {
+    return seedOf(part) !== porchPartOf(part)?.porchSeed;
+}
+/**
+ * A room the kernel frames, still closed and its framing automatic: a covered porch (automatic
+ * unless switched off), or a deck or patio whose posts and beam are switched on (`auto: true`, to
+ * carry a roof over it; off by default).
+ */
+function framedPorch(zone) {
+    if (!zone || zone.enclosureStatus === 'open')
+        return false;
+    if (zone.roomType === 'porch')
+        return zone.hasCeiling !== false && zone.porchFraming?.auto !== false;
+    return coverOptional(zone) && zone.porchFraming?.auto === true;
+}
+/** A deck or patio: its posts and beam are off until switched on. */
+function coverOptional(zone) {
+    return zone.roomType === 'deck' || zone.roomType === 'patio';
+}
+/** The floor plate a porch's posts stand on: its own step-down plate, else the one it shares. */
+function porchPlate(zone, plates) {
+    const holding = plates.filter((plate) => plate.zoneIds?.includes(zone.id));
+    return holding.find((plate) => plate.plateRole !== 'base') ?? holding[0];
+}
+const yawOf = (start, end) => Math.atan2(-(end[1] - start[1]), end[0] - start[0]);
+function withPorch(node, zone, key) {
+    const metadata = { porchOf: zone.id, porchPart: key, porchSeed: '' };
+    const tagged = { ...node, metadata: { ...node.metadata, ...metadata } };
+    tagged.metadata.porchSeed = seedOf(tagged);
+    return tagged;
+}
+/** The porch's planned parts as nodes, reusing the ids (and the touches) of the ones it has. */
+function buildParts(zone, plan, owned, plate, levelId, nodes, mintId) {
+    const settings = porchFramingSettings(zone);
+    const byKey = new Map(owned.map((part) => [porchPartOf(part).porchPart, part]));
+    const beams = new Map();
+    for (const planned of plan.beams) {
+        const existing = byKey.get(planned.key);
+        const fresh = createBeam({
+            start: planned.start,
+            end: planned.end,
+            preset: settings.beamSize,
+            levelId,
+            supportSlabId: plate?.id,
+            name: `${zone.name} beam`,
+        });
+        const beam = existing?.type === 'beam'
+            ? {
+                ...existing,
+                start: fresh.start,
+                end: fresh.end,
+                width: fresh.width,
+                depth: fresh.depth,
+                size: fresh.size,
+                plies: fresh.plies,
+                material: fresh.material,
+                placement: 'dropped',
+                topElevation: undefined,
+                supportSlabId: plate?.id,
+            }
+            : { ...fresh, id: mintId('beam') };
+        beams.set(planned.key, withPorch(beam, zone, planned.key));
+    }
+    const foot = plate?.elevation ?? 0;
+    const posts = plan.posts.map((planned) => {
+        // Up to the underside of the beam it carries (the lower of two at a corner).
+        const bottoms = planned.beams.flatMap((key) => {
+            const beam = beams.get(key);
+            return beam ? [beamBottomElevation(nodes, beam)] : [];
+        });
+        const height = Math.max(FRAMING_POST_MIN_HEIGHT, Math.min(...bottoms) - foot);
+        const run = plan.beams.find((beam) => beam.key === planned.beams.at(-1));
+        const rotation = run ? yawOf(run.start, run.end) : 0;
+        const existing = byKey.get(planned.key);
+        const position = [planned.position[0], 0, planned.position[1]];
+        const post = existing?.type === 'column'
+            ? {
+                ...existing,
+                ...(framingPostSize(existing) === settings.postSize
+                    ? {}
+                    : framingPostFields(settings.postSize, existing.postBase ?? 'post-base')),
+                position,
+                rotation,
+                height,
+                supportSlabId: plate?.id,
+            }
+            : {
+                ...createFramingPost({
+                    position: planned.position,
+                    size: settings.postSize,
+                    base: 'post-base',
+                    height,
+                    levelId,
+                    supportSlabId: plate?.id,
+                    rotation,
+                    name: `${zone.name} post`,
+                }),
+                id: mintId('column'),
+            };
+        return withPorch(post, zone, planned.key);
+    });
+    return [...beams.values(), ...posts];
+}
+/**
+ * The kernel's porch framing pass over one level: which posts and beams to put and delete, and
+ * the porches whose framing a hand edit has handed to the user. `zones` are the level's rooms as
+ * the pass leaves them, `plates` its floor plates, `current` a node as the pass has it so far;
+ * `previousNodes` (the scene before the edit) tells a deleted part from one never made.
+ */
+export function reconcilePorchFraming({ levelId, nodes, previousNodes, zones, plates, current, mintId, }) {
+    const put = [];
+    const remove = [];
+    const owned = new Map();
+    for (const node of Object.values(nodes)) {
+        const part = porchPartOf(node);
+        if (!part || node.parentId !== levelId)
+            continue;
+        const latest = (current(node.id) ?? node);
+        owned.set(part.porchOf, [...(owned.get(part.porchOf) ?? []), latest]);
+    }
+    const zonesById = new Map(zones.map((zone) => [zone.id, zone]));
+    // A porch gone, or no longer a covered one: what it made goes with it; a part edited by hand
+    // stays, the user's own. A deck's or patio's switched off goes whole, edited or not.
+    for (const [zoneId, parts] of owned) {
+        const zone = zonesById.get(zoneId);
+        if (framedPorch(zone) || zone?.porchFraming?.auto === false)
+            continue;
+        const switchedOff = !!zone && coverOptional(zone) && zone.porchFraming?.auto === undefined;
+        for (const part of parts) {
+            if (switchedOff || !edited(part))
+                remove.push(part.id);
+            else {
+                const { porchOf: _porchOf, porchPart: _porchPart, porchSeed: _seed, ...metadata } = part.metadata;
+                put.push({ ...part, metadata });
+            }
+        }
+    }
+    for (const zone of zones) {
+        if (!framedPorch(zone))
+            continue;
+        const parts = owned.get(zone.id) ?? [];
+        const before = previousNodes?.[zone.id];
+        const settingsChanged = before?.type !== 'zone' ||
+            before.roomType !== zone.roomType ||
+            JSON.stringify(before.porchFraming ?? null) !== JSON.stringify(zone.porchFraming ?? null);
+        const plan = planPorchFraming(zone, nodes);
+        if (!settingsChanged) {
+            // A part of the plan gone since the edit before: deleted by hand. (One the plan dropped
+            // went with an earlier pass.)
+            const planned = new Set([...plan.posts, ...plan.beams].map((part) => part.key));
+            const deleted = Object.values(previousNodes ?? {}).some((node) => {
+                const part = porchPartOf(node);
+                return part?.porchOf === zone.id && planned.has(part.porchPart) && !nodes[node.id];
+            });
+            if (deleted || parts.some(edited)) {
+                put.push({ ...zone, porchFraming: { ...zone.porchFraming, auto: false } });
+                continue;
+            }
+        }
+        const built = buildParts(zone, plan, 
+        // Settings changed: what a hand made goes too; the porch is rebuilt from its settings.
+        parts, porchPlate(zone, plates), levelId, nodes, mintId);
+        const kept = new Set(built.map((part) => part.id));
+        for (const part of parts)
+            if (!kept.has(part.id))
+                remove.push(part.id);
+        put.push(...built);
+    }
+    return { put, delete: remove };
+}

package/dist/lib/porch-framing.d.ts

@@ -0,0 +1,44 @@
+import type { AnyNode, ZoneNode } from '../schema/index.js';
+import { type FramingPostSize } from './framing-post.js';
+/** Post faces sit this far in from the slab edge. */
+export declare const PORCH_POST_SETBACK: number;
+/** Posts no more than 8 ft apart (the porch generator's and DCA 6's limit). */
+export declare const PORCH_POST_SPACING: number;
+export type PorchFramingSettings = {
+    /** A framing post size (`FRAMING_POST_SIZES`). */
+    postSize: FramingPostSize;
+    postSpacing: number;
+    /** A stock beam size id (`BEAM_SIZE_PRESETS`). */
+    beamSize: string;
+};
+export declare const DEFAULT_PORCH_FRAMING: PorchFramingSettings;
+/** A porch's framing settings: its own, else the defaults (an unknown size is the default). */
+export declare function porchFramingSettings(zone: Pick<ZoneNode, 'porchFraming'>): PorchFramingSettings;
+type P = [number, number];
+export type PorchPostPlan = {
+    /** Stable within the porch: which corner or side, and which bay. */
+    key: string;
+    position: P;
+    /** Actual post width (square). */
+    size: number;
+    /** The beams (their keys) it stands under: two at a corner, one along a side. */
+    beams: string[];
+};
+export type PorchBeamPlan = {
+    key: string;
+    start: P;
+    end: P;
+    width: number;
+    depth: number;
+};
+export type PorchFramingPlan = {
+    posts: PorchPostPlan[];
+    beams: PorchBeamPlan[];
+};
+/**
+ * The posts and beams for porch `zone` among `nodes` (its level's walls decide which sides are
+ * open). Empty when no side is open.
+ */
+export declare function planPorchFraming(zone: Pick<ZoneNode, 'polygon' | 'parentId' | 'porchFraming'>, nodes: Readonly<Record<string, AnyNode>>): PorchFramingPlan;
+export {};
+//# sourceMappingURL=porch-framing.d.ts.map

package/dist/lib/porch-framing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"porch-framing.d.ts","sourceRoot":"","sources":["../../src/lib/porch-framing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAY,QAAQ,EAAE,MAAM,WAAW,CAAA;AAG5D,OAAO,EAAiD,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAepG,qDAAqD;AACrD,eAAO,MAAM,kBAAkB,QAAW,CAAA;AAC1C,+EAA+E;AAC/E,eAAO,MAAM,kBAAkB,QAAS,CAAA;AAExC,MAAM,MAAM,oBAAoB,GAAG;IACjC,kDAAkD;IAClD,QAAQ,EAAE,eAAe,CAAA;IACzB,WAAW,EAAE,MAAM,CAAA;IACnB,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,oBAInC,CAAA;AAKD,+FAA+F;AAC/F,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,cAAc,CAAC,GAAG,oBAAoB,CAU/F;AAED,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEzB,MAAM,MAAM,aAAa,GAAG;IAC1B,oEAAoE;IACpE,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,CAAC,CAAA;IACX,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,iFAAiF;IACjF,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,CAAC,CAAA;IACR,GAAG,EAAE,CAAC,CAAA;IACN,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAAE,KAAK,EAAE,aAAa,EAAE,CAAC;IAAC,KAAK,EAAE,aAAa,EAAE,CAAA;CAAE,CAAA;AAkCjF;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,GAAG,UAAU,GAAG,cAAc,CAAC,EAC7D,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,gBAAgB,CAqFlB"}

package/dist/lib/porch-framing.js

@@ -0,0 +1,159 @@
+import { DEFAULT_BEAM_SIZE_PRESET_ID } from '../schema/nodes/beam.js';
+import { beamSizePreset } from './beam.js';
+import { DEFAULT_FRAMING_POST_SIZE, FRAMING_POST_SIZES } from './framing-post.js';
+/**
+ * Where a porch's posts and beam go (a porch room, `lib/outdoor-room`): a post on each outside
+ * corner, where two open sides meet (a porch in a corner of the house gets its one corner post),
+ * more along each open side at most `postSpacing` apart, evenly; none where a side meets the house,
+ * whose wall carries the beam's end. The beam runs along each open side on the posts, dropped
+ * under the porch ceiling. Pure geometry: the structure kernel turns it into post and beam nodes.
+ *
+ * A side is open when no wall stands on it (an invisible wall) or the wall on it is a railing.
+ */
+const IN = 0.0254;
+const FT = 0.3048;
+/** Post faces sit this far in from the slab edge. */
+export const PORCH_POST_SETBACK = 1.5 * IN;
+/** Posts no more than 8 ft apart (the porch generator's and DCA 6's limit). */
+export const PORCH_POST_SPACING = 8 * FT;
+export const DEFAULT_PORCH_FRAMING = {
+    postSize: DEFAULT_FRAMING_POST_SIZE,
+    postSpacing: PORCH_POST_SPACING,
+    beamSize: DEFAULT_BEAM_SIZE_PRESET_ID,
+};
+const isPostSize = (size) => !!size && Object.hasOwn(FRAMING_POST_SIZES, size);
+/** A porch's framing settings: its own, else the defaults (an unknown size is the default). */
+export function porchFramingSettings(zone) {
+    const own = zone.porchFraming;
+    return {
+        postSize: isPostSize(own?.postSize) ? own.postSize : DEFAULT_PORCH_FRAMING.postSize,
+        postSpacing: own?.postSpacing ?? DEFAULT_PORCH_FRAMING.postSpacing,
+        beamSize: own?.beamSize && beamSizePreset(own.beamSize)
+            ? beamSizePreset(own.beamSize).id
+            : DEFAULT_PORCH_FRAMING.beamSize,
+    };
+}
+const sub = (a, b) => [a[0] - b[0], a[1] - b[1]];
+const add = (a, b) => [a[0] + b[0], a[1] + b[1]];
+const scale = (a, s) => [a[0] * s, a[1] * s];
+const len = (a) => Math.hypot(a[0], a[1]);
+const unit = (a) => {
+    const l = len(a);
+    return l > 1e-12 ? [a[0] / l, a[1] / l] : [0, 0];
+};
+/** The wall standing along `a` → `b` (its reference line on the segment), if any. */
+function wallAlong(a, b, walls) {
+    const dir = unit(sub(b, a));
+    const mid = scale(add(a, b), 0.5);
+    return walls.find((wall) => {
+        if ((wall.curveOffset ?? 0) !== 0)
+            return false;
+        const w = sub(wall.end, wall.start);
+        const length = len(w);
+        if (length < 1e-6)
+            return false;
+        const u = scale(w, 1 / length);
+        if (Math.abs(u[0] * dir[1] - u[1] * dir[0]) > 1e-3)
+            return false;
+        const rel = sub(mid, wall.start);
+        const across = Math.abs(rel[0] * u[1] - rel[1] * u[0]);
+        const along = rel[0] * u[0] + rel[1] * u[1];
+        return across < 1e-3 && along > -1e-3 && along < length + 1e-3;
+    });
+}
+/** Whether a wall is a railing, which a porch's posts and beam still stand along. */
+function isRailing(wall) {
+    return wall.wallType === 'railing';
+}
+/**
+ * The posts and beams for porch `zone` among `nodes` (its level's walls decide which sides are
+ * open). Empty when no side is open.
+ */
+export function planPorchFraming(zone, nodes) {
+    const settings = porchFramingSettings(zone);
+    const postSize = FRAMING_POST_SIZES[settings.postSize];
+    const beam = beamSizePreset(settings.beamSize);
+    const spacing = Math.max(0.6, settings.postSpacing);
+    const walls = Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === zone.parentId);
+    const polygon = zone.polygon;
+    const n = polygon.length;
+    if (n < 3)
+        return { posts: [], beams: [] };
+    // Inward normals: the polygon's winding decides which side of each edge is inside.
+    let area = 0;
+    for (let i = 0; i < n; i++) {
+        const a = polygon[i];
+        const b = polygon[(i + 1) % n];
+        area += a[0] * b[1] - b[0] * a[1];
+    }
+    const turn = area > 0 ? 1 : -1;
+    const edges = polygon.map((a, i) => {
+        const b = polygon[(i + 1) % n];
+        const wall = wallAlong(a, b, walls);
+        const dir = unit(sub(b, a));
+        const inward = [-dir[1] * turn, dir[0] * turn];
+        return { a, b, dir, inward, open: !wall || isRailing(wall), wall };
+    });
+    const inset = postSize / 2 + PORCH_POST_SETBACK;
+    const posts = [];
+    const beams = [];
+    // The post line of an edge: the edge moved in by the inset.
+    const onLine = (edge, p) => add(p, scale(edge.inward, inset));
+    // The outside corner where open edge i-1 meets open edge i: the two post lines' crossing.
+    const corner = (i) => {
+        const prev = edges[(i - 1 + n) % n];
+        const next = edges[i];
+        const p = onLine(prev, prev.b);
+        const q = onLine(next, next.a);
+        const denom = prev.dir[0] * next.dir[1] - prev.dir[1] * next.dir[0];
+        if (Math.abs(denom) < 1e-9)
+            return q;
+        const t = ((q[0] - p[0]) * next.dir[1] - (q[1] - p[1]) * next.dir[0]) / denom;
+        return add(p, scale(prev.dir, t));
+    };
+    edges.forEach((edge, i) => {
+        if (!edge.open)
+            return;
+        const prev = edges[(i - 1 + n) % n];
+        const next = edges[(i + 1) % n];
+        const startCorner = prev.open;
+        const endCorner = next.open;
+        // A side meeting the house starts at the wall's face, where the beam bears.
+        const startFace = startCorner ? 0 : (prev.wall?.thickness ?? 0.15) / 2;
+        const endFace = endCorner ? 0 : (next.wall?.thickness ?? 0.15) / 2;
+        const start = startCorner ? corner(i) : add(onLine(edge, edge.a), scale(edge.dir, startFace));
+        const end = endCorner
+            ? corner((i + 1) % n)
+            : sub(onLine(edge, edge.b), scale(edge.dir, endFace));
+        if (startCorner)
+            posts.push({
+                key: `corner:${i}`,
+                position: start,
+                size: postSize,
+                beams: [`beam:${(i - 1 + n) % n}`, `beam:${i}`],
+            });
+        const run = sub(end, start);
+        const length = len(run);
+        if (length < postSize)
+            return;
+        const bays = Math.max(1, Math.ceil(length / spacing - 1e-9));
+        for (let k = 1; k < bays; k++)
+            posts.push({
+                key: `side:${i}:${k}`,
+                position: add(start, scale(run, k / bays)),
+                size: postSize,
+                beams: [`beam:${i}`],
+            });
+        // The beam reaches the corner posts' outside faces, so two sides' beams meet over a corner.
+        const reachStart = startCorner ? postSize / 2 : 0;
+        const reachEnd = endCorner ? postSize / 2 : 0;
+        beams.push({
+            key: `beam:${i}`,
+            start: sub(start, scale(edge.dir, reachStart)),
+            end: add(end, scale(edge.dir, reachEnd)),
+            width: beam.width,
+            depth: beam.depth,
+        });
+    });
+    return { posts, beams };
+}

package/dist/lib/railing-rooms.d.ts

@@ -0,0 +1,13 @@
+import type { WallNode } from '../schema/index.js';
+import type { BoundarySpan } from './room-topology-index.js';
+/** The ids of the railing walls among `walls`. */
+export declare function railingWallIds(walls: readonly WallNode[]): Set<string>;
+/**
+ * The rooms a railing fences off from the outside: a railing on the room's edge with no room
+ * standing behind some stretch of it (a deck's or a porch's guard on the storey's outline). A
+ * railing is a guard, not an enclosure, so such a room is outside whatever covers it, and a wall
+ * it shares with the house faces outdoors. A railing with rooms on both faces (round a stair well,
+ * along a loft) leaves them inside.
+ */
+export declare function railingFencedRoomIds(spans: readonly BoundarySpan[], railingIds: ReadonlySet<string>): Set<string>;
+//# sourceMappingURL=railing-rooms.d.ts.map

package/dist/lib/railing-rooms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"railing-rooms.d.ts","sourceRoot":"","sources":["../../src/lib/railing-rooms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAKzD,kDAAkD;AAClD,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAEtE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,GAC9B,GAAG,CAAC,MAAM,CAAC,CAwBb"}

package/dist/lib/railing-rooms.js

@@ -0,0 +1,37 @@
+import { isRailingWall } from '../schema/nodes/railing-wall.js';
+/** Span overlap below this (a fraction of the boundary) is a shared endpoint, not a shared edge. */
+const SPAN_OVERLAP = 1e-6;
+/** The ids of the railing walls among `walls`. */
+export function railingWallIds(walls) {
+    return new Set(walls.flatMap((wall) => (isRailingWall(wall) ? [wall.id] : [])));
+}
+/**
+ * The rooms a railing fences off from the outside: a railing on the room's edge with no room
+ * standing behind some stretch of it (a deck's or a porch's guard on the storey's outline). A
+ * railing is a guard, not an enclosure, so such a room is outside whatever covers it, and a wall
+ * it shares with the house faces outdoors. A railing with rooms on both faces (round a stair well,
+ * along a loft) leaves them inside.
+ */
+export function railingFencedRoomIds(spans, railingIds) {
+    const railings = spans.filter((span) => span.kind === 'wall' && railingIds.has(span.boundaryId));
+    const fenced = new Set();
+    for (const span of railings) {
+        const behind = railings
+            .filter((other) => other.boundaryId === span.boundaryId &&
+            other.face !== span.face &&
+            Math.min(span.t1, other.t1) - Math.max(span.t0, other.t0) > SPAN_OVERLAP)
+            .sort((a, b) => a.t0 - b.t0);
+        let reach = span.t0;
+        let open = false;
+        for (const other of behind) {
+            if (other.t0 > reach + SPAN_OVERLAP) {
+                open = true;
+                break;
+            }
+            reach = Math.max(reach, other.t1);
+        }
+        if (open || reach < span.t1 - SPAN_OVERLAP)
+            fenced.add(span.roomId);
+    }
+    return fenced;
+}

package/dist/lib/roof-eave.d.ts

@@ -0,0 +1,135 @@
+import { type RoofSegmentNode } from '../schema/nodes/roof-segment.js';
+import type { RoofEaveCut } from '../schema/nodes/roof-types.js';
+/** A 1x board's actual thickness: every fascia and rake board is nominal 1x. */
+export declare const FASCIA_THICKNESS: number;
+/** How far a fascia or rake board drops below the tails' lowest point, past a soffit's edge. */
+export declare const FASCIA_DROP: number;
+/** The run of a plumb-and-level tail's level cut: a 2x4's width for the soffit's edge to nail to. */
+export declare const LEVEL_CUT_RUN: number;
+/** A boxed eave's soffit: a 1/2 in panel nailed up to the level cuts. */
+export declare const SOFFIT_THICKNESS: number;
+export type FasciaStock = '1x6' | '1x8' | '1x10' | '1x12';
+/** The 1x boards a fascia or rake board is cut from, narrowest first, at their actual widths. */
+export declare const FASCIA_STOCK: readonly {
+    size: FasciaStock;
+    width: number;
+}[];
+/**
+ * The 1x a board `width` wide is cut from: the narrowest stock as wide, ripped down to it when
+ * wider. Past a 1x12 no 1x is wide enough: a ripped width of wider stock (`stock` null).
+ */
+export declare function fasciaStockFor(width: number): {
+    stock: FasciaStock | null;
+    ripped: boolean;
+};
+/** A point of an eave's section: `s` out from the plate line in plan, `y` up from the plate's plane there. */
+export type EavePoint = readonly [number, number];
+/** The numbers an eave is cut from (`roofEaveProfile`), the roof shell's and Bones' alike. */
+export type RoofEaveInput = {
+    /** The slope's tangent, falling outward; 0 for a flat roof, negative where it rises (a shed's high edge). */
+    tan: number;
+    /** Out from the plate line (the wall's centre line), in plan, to the overhang's end: where the tails are cut. */
+    reach: number;
+    /** Out from the plate line to the wall's outer face. */
+    wallOut: number;
+    /** The tails' depth square to the slope: a rafter's, or a truss's top chord. */
+    tailDepth: number;
+    /**
+     * How far the tails' underside stands over the plate's plane, plumb: 0 for a rafter, its bottom
+     * chord's depth for a truss's top chord, which rides it at the heel.
+     */
+    tailLift: number;
+    /** The deck's depth square to the slope, from the plate's plane to the sheathing's top. */
+    deckDepth: number;
+    /** Absent, plumb. */
+    cut?: RoofEaveCut;
+    /** The fascia's own height (its width as a board) and thickness, where the plane sets them. */
+    fasciaHeight?: number;
+    fasciaThickness?: number;
+    /** How far the fascia's top stands over the sheathing's: a flat roof's coping band over its membrane. */
+    fasciaRise?: number;
+};
+/**
+ * One eave's section, the rule the roof shell's eave edge, fascia and soffit and Bones' rafter tails
+ * and fascia are all cut by, so the frame never hangs below the shell nor pokes out of it.
+ */
+export type RoofEaveProfile = {
+    /** The cut drawn: a flat eave, or an edge rising outward, is plumb whatever the plane asks. */
+    cut: RoofEaveCut;
+    tan: number;
+    cos: number;
+    sin: number;
+    reach: number;
+    wallOut: number;
+    /** The sheathing's top at `s`. */
+    top: (s: number) => number;
+    /** The tails' underside at `s`. */
+    under: (s: number) => number;
+    /**
+     * The tails' end, from its top corner on the sheathing's top down: a plumb or square cut's two
+     * ends, or a plumb cut's and then its level cut's inner end.
+     */
+    end: readonly EavePoint[];
+    /** The tails' lowest point's height. */
+    low: number;
+    fascia: {
+        /** Its section: back top, front top, front bottom, back bottom. */
+        corners: readonly [EavePoint, EavePoint, EavePoint, EavePoint];
+        /** Its width as a board: plumb, its height; square to the slope, its depth along its face. */
+        height: number;
+        thickness: number;
+        /** Square to the slope (a `square` cut's), else plumb. */
+        square: boolean;
+        stock: FasciaStock | null;
+        ripped: boolean;
+    };
+    /** A boxed eave's soffit: its top (on the level cuts) and thickness, from the wall's outer face out to the fascia's back. */
+    soffit: {
+        y: number;
+        thickness: number;
+        from: number;
+        to: number;
+    } | null;
+    /**
+     * The rake board over a barge rafter on this slope: plumb, its top on the sheathing's top, as deep
+     * plumb (`height`) as the fascia is at the corner, or over a boxed eave as the barge with the
+     * fascia's drop; `width` is square to its edges, as a board.
+     */
+    rake: {
+        height: number;
+        width: number;
+        stock: FasciaStock | null;
+        ripped: boolean;
+    };
+};
+/**
+ * An eave cut to its plane's rule. The tails reach `reach` out from the plate line along the
+ * sheathing's top, the deck's full depth under it:
+ *  - plumb: the tails cut plumb there; a plumb 1x fascia covers their face, its top flush with the
+ *    sheathing's top (under the drip edge), its bottom about `FASCIA_DROP` below their lowest point;
+ *  - square: the tails cut square to the slope through the sheathing's outer edge, the fascia square
+ *    to the slope on them, its top face in the sheathing's plane;
+ *  - plumb-level: the plumb cut, and under it a level cut `LEVEL_CUT_RUN` long (at most half the tail's
+ *    plumb depth deep) that a soffit nails up to, run level from the fascia's back to the wall.
+ * The fascia is as deep as that takes (a whole 1x where one drops at least 1/4 in under the tails,
+ * else one ripped to it), unless the plane sets its own.
+ */
+export declare function roofEaveProfile(input: RoofEaveInput): RoofEaveProfile;
+/**
+ * Whether a point of an eave's section, out past the wall's outer face, lies in the shell's eave
+ * (`tolerance` either way): under the sheathing's top, inside the tails' end cut, and over their
+ * underside or a boxed eave's soffit.
+ */
+export declare function eaveContains(profile: RoofEaveProfile, [s, y]: EavePoint, tolerance?: number): boolean;
+type EaveSegment = Pick<RoofSegmentNode, 'roofType' | 'pitch' | 'width' | 'depth' | 'wallThickness' | 'overhang' | 'deckThickness'> & Partial<Pick<RoofSegmentNode, 'gableOverhang' | 'buildUp' | 'eaveCut' | 'fasciaHeight' | 'fasciaDepth' | 'shingleThickness' | 'barrelRise' | 'barrelSegments'>>;
+/**
+ * The numbers a roof plane's eaves are cut from (`roofEaveProfile`): its reach and wall, its layers'
+ * structure and deck, its eave cut and fascia. Its rafters sit on the plate; a truss's top chord on
+ * its bottom chord at the heel. A plane without layers is taken as rafters under a 7/16 in sheet,
+ * as deep as its deck. `high`: a shed's high edge, rising outward, cut plumb.
+ */
+export declare function roofSegmentEaveInput(node: EaveSegment, edge?: 'eave' | 'high'): RoofEaveInput;
+/** A roof plane's eave (`roofSegmentEaveInput`, `roofEaveProfile`). */
+export declare function roofSegmentEaveProfile(node: EaveSegment, edge?: 'eave' | 'high'): RoofEaveProfile;
+export {};
+//# sourceMappingURL=roof-eave.d.ts.map

package/dist/lib/roof-eave.d.ts.map

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