@pascal-app/core 1.0.6 → 1.0.7

package/dist/spatial/usage-field/door-stairs.js

@@ -0,0 +1,129 @@
+import { CODE_PROFILES, codeProfileOf } from '../../building/code-profile.js';
+import { area, difference, intersection } from '../../lib/polygon-boolean.js';
+import { getLevelElevations } from '../../services/storey.js';
+import { resolveStairWalkingSurfaces, } from '../../systems/stair/stair-clearance.js';
+import { m, nameOf, quote, unique } from './labels.js';
+import { roomAt } from './pieces.js';
+import { doorFrame, FRAME_M, hingeOf, hungOf, leafDirection, SWEEP_STEP_DEG, swingDoors, } from './swings.js';
+/** A tread this far under the threshold or less is steps the leaf is read against; further down it is another storey's. */
+const BAND_M = 0.6;
+/** Less of the sweep than this over a tread is the leaf grazing its edge (m2). */
+const MIN_OVERLAP_M2 = 0.01;
+/** How far from the wall's centre line the room behind or ahead of a door is looked for (m). */
+const ROOM_PROBE_M = 0.4;
+/** A floor within this far above the door's own still carries it (a slab's finish). */
+const FLOOR_ABOVE_M = 0.25;
+/** The ground a leaf covers while it opens: a fan from the hinge, closed to 90 degrees, as long as the leaf. */
+function sweptFan(hinge, length, direction) {
+    const ring = [hinge];
+    for (let a = 0; a <= 90; a += SWEEP_STEP_DEG) {
+        const [dx, dz] = direction((a * Math.PI) / 180);
+        ring.push([hinge[0] + dx * length, hinge[1] + dz * length]);
+    }
+    return ring;
+}
+/**
+ * A door whose leaf swings over steps. Both texts the checks read say it: a floor or landing is not
+ * required at the top of an interior flight "provided that a door does not swing over the stairs"
+ * (R311.7.6), and a landing at an exterior door may be 7-3/4 in below the threshold, or a flight of two
+ * risers need no top landing, only where the door does not swing over it (R311.3.1, R311.3.2). So the
+ * leaf's sweep is read against the treads and landings of every stair that lie more than 1-1/2 in below
+ * the door's own floor; ground the door's level covers (a slab, a landing at the threshold) is not steps.
+ * The text says nothing of a door swinging over a flat landing: that is a design preference (Architect
+ * Pro's `door_over_landing` keeps both landings clear), not this check.
+ *
+ * It is a code's rule. With no `site.metadata.codeProfile` a finding is information that names the US
+ * IRC it used; with `irc-2021` it is a warning; a profile with no row for it reports nothing.
+ */
+export function doorOverStairIssues(nodes, shapes) {
+    const profile = codeProfileOf(nodes);
+    const applied = profile ?? CODE_PROFILES['irc-2021'];
+    const row = applied.thresholds.doorThresholdDrop;
+    if (!row)
+        return [];
+    const stairs = [];
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'stair')
+            continue;
+        try {
+            stairs.push({ stair: node, surfaces: resolveStairWalkingSurfaces(node, nodes) });
+        }
+        catch {
+            // a stair whose surfaces cannot be read (its detail is over budget) has nothing to sweep against
+        }
+    }
+    if (stairs.length === 0)
+        return [];
+    const elevations = getLevelElevations(nodes);
+    const out = [];
+    for (const level of shapes.levels) {
+        const baseY = elevations.get(level.levelId)?.baseY ?? 0;
+        const steps = stairs
+            .map(({ stair, surfaces }) => ({
+            stair,
+            surfaces: surfaces.filter((surface) => surface.top <= baseY - row.value && surface.top >= baseY - BAND_M),
+        }))
+            .filter(({ surfaces }) => surfaces.length > 0);
+        if (steps.length === 0)
+            continue;
+        const floors = shapes.levels
+            .flatMap((other) => other.floors)
+            .filter((floor) => floor.y >= baseY - row.value && floor.y <= baseY + FLOOR_ABOVE_M)
+            .map((floor) => ({ outer: floor.outer, holes: floor.holes }));
+        for (const door of swingDoors(nodes, level.levelId)) {
+            const hung = hungOf(door);
+            const frame = doorFrame(nodes, door);
+            const hinge = hingeOf(nodes, door, hung);
+            const fan = sweptFan(hinge, 2 * frame.half - FRAME_M, (theta) => leafDirection(frame, hung, theta));
+            // the room the door belongs to is the one behind the leaf; failing that, the one it swings into
+            const centre = [
+                frame.sx + frame.tx * frame.along,
+                frame.sz + frame.tz * frame.along,
+            ];
+            const beside = (side) => [
+                centre[0] + frame.nx * hung.swing * side * ROOM_PROBE_M,
+                centre[1] + frame.nz * hung.swing * side * ROOM_PROBE_M,
+            ];
+            const room = roomAt(nodes, level.levelId, beside(-1)) ?? roomAt(nodes, level.levelId, beside(1));
+            for (const { stair, surfaces } of steps) {
+                let over = 0;
+                let nearest = Number.NEGATIVE_INFINITY;
+                for (const surface of surfaces) {
+                    const swept = intersection(fan, surface.region);
+                    if (swept.length === 0)
+                        continue;
+                    const bare = area(floors.length ? difference(swept, floors) : swept);
+                    if (bare < MIN_OVERLAP_M2)
+                        continue;
+                    over += bare;
+                    nearest = Math.max(nearest, surface.top);
+                }
+                if (over === 0)
+                    continue;
+                const drop = baseY - nearest;
+                const name = nameOf(nodes, door.id);
+                const stairName = nameOf(nodes, stair.id);
+                out.push({
+                    type: 'usage_door_over_stair',
+                    message: `${quote(name)}${room ? ` in ${quote(room.name)}` : ''} swings over the steps of ${quote(stairName)}: its leaf passes over ${m(over)} m² of treads, the nearest ${m(drop)} m below the threshold, where ${applied.label} (${row.section}) wants a floor or landing for the leaf to open onto${profile ? '' : ', and this project names no code'}. Swing it the other way, hinge it on the other side, or give the stair a landing as deep as the door is wide.`,
+                    severity: profile ? 'warning' : 'info',
+                    nodeIds: unique([room?.id, door.id, stair.id]),
+                    valueM: Math.round(drop * 1000) / 1000,
+                    thresholdM: row.value,
+                    place: { room: room?.name ?? '', roomId: room?.id ?? level.levelId, at: hinge },
+                    obstacles: [
+                        { nodeId: stair.id, name: stairName, kind: 'stair', shape: 'exact', movable: false },
+                    ],
+                    approximate: false,
+                    code: {
+                        profile: applied.id,
+                        cite: row.cite,
+                        source: row.source,
+                        byDefault: profile === null,
+                    },
+                });
+            }
+        }
+    }
+    return out;
+}

package/dist/spatial/usage-field/entry-way.d.ts

@@ -0,0 +1,14 @@
+import { type UsageIssue } from './findings.js';
+import type { UsageShapes } from './types.js';
+import { type Nodes } from './walls.js';
+/**
+ * What closes off part of a room: from each entrance of a room (a doorway, or an open edge to the room
+ * beside it) the widest way to the room's open floor, with the pieces of furniture standing where they
+ * are. A way under a passage's width that a piece bounds is a finding that names the piece, the room and
+ * what is on the other side of the pinch. A leaf swinging open is `doorSwingIssues`'s, a doorway's own
+ * width and the walls' are the passage measure's: only a free-standing piece is named. What is built to
+ * stand there stays quiet: a kitchen run or anything on a wall, a fixture, built-in joinery, foliage, a
+ * building element, a rug, a piece on another piece. A room narrower than a passage is judged on its doorway only.
+ */
+export declare function entryIssues(nodes: Nodes, shapes: UsageShapes): UsageIssue[];
+//# sourceMappingURL=entry-way.d.ts.map

package/dist/spatial/usage-field/entry-way.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-way.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/entry-way.ts"],"names":[],"mappings":"AAQA,OAAO,EAAqB,KAAK,UAAU,EAAE,MAAM,YAAY,CAAA;AAY/D,OAAO,KAAK,EAAe,WAAW,EAAE,MAAM,SAAS,CAAA;AACvD,OAAO,EAAc,KAAK,KAAK,EAAE,MAAM,SAAS,CAAA;AA4HhD;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,GAAG,UAAU,EAAE,CA2G3E"}

package/dist/spatial/usage-field/entry-way.js

@@ -0,0 +1,219 @@
+import { floorsOf } from '../../agent-operations/circulation-spaces.js';
+import { isFloorUnderlay } from '../../agent-operations/furniture-kind.js';
+import { area, containsPoint, intersection } from '../../lib/polygon-boolean.js';
+import { getLevelElevations } from '../../services/storey.js';
+import { getWallThickness } from '../../systems/wall/wall-footprint.js';
+import { getWallLocalFaceZ } from '../../systems/wall/wall-frame.js';
+import { CLASH_INFO_M, CLASH_MIN_AREA_M2, wallFixed } from './clash.js';
+import { DOOR_M, PASSAGE_M } from './findings.js';
+import { m, nameOf, quote, unique } from './labels.js';
+import { doorwayRing } from './openings.js';
+import { boxesMeet, isBuildingElement, isFoliage, isPiecePrism, narrowestExtent, ringBox, } from './pieces.js';
+import { doorFrame, FIXTURE } from './swings.js';
+import { levelWalls } from './walls.js';
+import { wayIn } from './way-in.js';
+/** Where a doorway is looked at from: this far to either side of the wall's middle (m). */
+const SIDE_M = 0.3;
+/** A zone edge is sampled this often (m) to find where no wall stands on it. */
+const SAMPLE_M = 0.05;
+/** Joinery made for the room: a built-in robe or a fitted unit is where it was designed to be. */
+const BUILT_IN = /built[- ]?in|fitted|joinery/i;
+/** A wall stands on a zone edge when its middle line is within half its thickness and this much (m). */
+const SCRIBE_M = 0.02;
+/** An open edge is a passage of this half thickness across (m): a doorway's, a wall's half thickness and a centimetre. */
+const OPEN_HALF_M = 0.065;
+/** The segment's distance from a point. */
+function segmentDistance(p, a, b) {
+    const dx = b[0] - a[0];
+    const dz = b[1] - a[1];
+    const length2 = dx * dx + dz * dz;
+    const t = length2 < 1e-12
+        ? 0
+        : Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dz) / length2));
+    return Math.hypot(p[0] - (a[0] + dx * t), p[1] - (a[1] + dz * t));
+}
+/**
+ * The stretches of a zone's boundary with no wall on them, a doorway's width or more: where the room is
+ * open to the one beside it. A ring across each, a wall's thickness deep, is the way in.
+ */
+function openEntrances(walls, zone, zones, self) {
+    const out = [];
+    const covered = (p) => walls.some((wall) => segmentDistance(p, wall.start, wall.end) <=
+        getWallThickness(wall) / 2 + SCRIBE_M);
+    for (const [i, a] of zone.polygon.entries()) {
+        const b = zone.polygon[(i + 1) % zone.polygon.length];
+        const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        if (length < DOOR_M)
+            continue;
+        const tx = (b[0] - a[0]) / length;
+        const tz = (b[1] - a[1]) / length;
+        const steps = Math.ceil(length / SAMPLE_M);
+        let from = -1;
+        const close = (last) => {
+            const s0 = (from * length) / steps;
+            const s1 = (last * length) / steps;
+            if (from >= 0 && s1 - s0 >= DOOR_M) {
+                const p0 = [a[0] + tx * s0, a[1] + tz * s0];
+                const p1 = [a[0] + tx * s1, a[1] + tz * s1];
+                const mid = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2];
+                // a room beyond: the opening is a way between two rooms, not a gap in the outline
+                const beyond = [1, -1].some((side) => {
+                    const q = [mid[0] - tz * side * SIDE_M, mid[1] + tx * side * SIDE_M];
+                    return (!containsPoint([{ outer: zone.polygon, holes: zone.holes }], q) &&
+                        zones.some((z) => z.id !== self && containsPoint([{ outer: z.polygon, holes: z.holes }], q)));
+                });
+                if (beyond)
+                    out.push({
+                        ring: [
+                            [p0[0] - tz * OPEN_HALF_M, p0[1] + tx * OPEN_HALF_M],
+                            [p1[0] - tz * OPEN_HALF_M, p1[1] + tx * OPEN_HALF_M],
+                            [p1[0] + tz * OPEN_HALF_M, p1[1] - tx * OPEN_HALF_M],
+                            [p0[0] + tz * OPEN_HALF_M, p0[1] - tx * OPEN_HALF_M],
+                        ],
+                        at: mid,
+                    });
+            }
+            from = -1;
+        };
+        for (let s = 0; s <= steps; s++) {
+            const p = [a[0] + (tx * s * length) / steps, a[1] + (tz * s * length) / steps];
+            if (covered(p)) {
+                if (from >= 0)
+                    close(s - 1);
+            }
+            else if (from < 0)
+                from = s;
+        }
+        if (from >= 0)
+            close(steps);
+    }
+    return out;
+}
+/** The doors of a level that lead into a zone: a doorway of any kind but a vehicle's whose one side, and only one, is in the zone. */
+function doorEntrances(nodes, doors, zone) {
+    const out = [];
+    for (const door of doors) {
+        const f = doorFrame(nodes, door);
+        const across = (getWallLocalFaceZ(f.wall, 'a') + getWallLocalFaceZ(f.wall, 'b')) / 2;
+        const side = (sign) => [
+            f.sx + f.tx * f.along + f.nx * (across + sign * SIDE_M),
+            f.sz + f.tz * f.along + f.nz * (across + sign * SIDE_M),
+        ];
+        const inside = [1, -1].filter((sign) => containsPoint([{ outer: zone.polygon, holes: zone.holes }], side(sign)));
+        if (inside.length !== 1)
+            continue;
+        const ring = doorwayRing(f.wall, door);
+        if (!ring)
+            continue;
+        out.push({
+            ring,
+            at: [f.sx + f.tx * f.along + f.nx * across, f.sz + f.tz * f.along + f.nz * across],
+            door,
+        });
+    }
+    return out;
+}
+/**
+ * What closes off part of a room: from each entrance of a room (a doorway, or an open edge to the room
+ * beside it) the widest way to the room's open floor, with the pieces of furniture standing where they
+ * are. A way under a passage's width that a piece bounds is a finding that names the piece, the room and
+ * what is on the other side of the pinch. A leaf swinging open is `doorSwingIssues`'s, a doorway's own
+ * width and the walls' are the passage measure's: only a free-standing piece is named. What is built to
+ * stand there stays quiet: a kitchen run or anything on a wall, a fixture, built-in joinery, foliage, a
+ * building element, a rug, a piece on another piece. A room narrower than a passage is judged on its doorway only.
+ */
+export function entryIssues(nodes, shapes) {
+    const out = [];
+    const floors = floorsOf(nodes).floors;
+    const elevations = getLevelElevations(nodes);
+    for (const level of shapes.levels) {
+        const floor = floors.find((f) => f.id === level.levelId);
+        if (!floor)
+            continue;
+        const baseY = elevations.get(level.levelId)?.baseY ?? 0;
+        const isUnderlay = (prism) => nodes[prism.nodeId]?.type === 'item' && isFloorUnderlay(nodes[prism.nodeId]);
+        const standing = (prism) => {
+            const node = nodes[prism.nodeId];
+            return ((prism.kind === 'item' || prism.kind === 'shelf') &&
+                isPiecePrism(prism) &&
+                !wallFixed(nodes, prism) &&
+                !isUnderlay(prism) &&
+                !isFoliage(nodes, prism.nodeId) &&
+                !isBuildingElement(nodes, prism.nodeId) &&
+                !FIXTURE.test(nameOf(nodes, prism.nodeId)) &&
+                !BUILT_IN.test(nameOf(nodes, prism.nodeId)) &&
+                nodes[node?.parentId ?? '']?.type !== 'item');
+        };
+        const named = new Set(level.prisms.filter(standing).map((prism) => prism.id));
+        if (named.size === 0)
+            continue;
+        const namedPrisms = level.prisms.filter((prism) => named.has(prism.id));
+        const walls = levelWalls(nodes, level.levelId);
+        const wallIds = new Set(walls.map((wall) => wall.id));
+        const doors = Object.values(nodes).filter((node) => node.type === 'door' &&
+            node.visible !== false &&
+            !String(node.doorType).startsWith('garage') &&
+            wallIds.has(node.parentId ?? ''));
+        const zones = floor.zones.filter((zone) => !zone.outdoor);
+        const found = new Map();
+        for (const zone of zones) {
+            if (narrowestExtent([{ outer: zone.polygon }]) < PASSAGE_M)
+                continue;
+            const zoneBox = ringBox(zone.polygon);
+            // a piece is in the room when it stands a contact's depth inside it: one against the wall on the other side is that room's
+            const here = new Set(namedPrisms
+                .filter((prism) => {
+                if (!boxesMeet(ringBox(prism.outer), zoneBox))
+                    return false;
+                const meet = intersection({ outer: prism.outer, holes: prism.holes }, { outer: zone.polygon, holes: zone.holes });
+                return area(meet) >= CLASH_MIN_AREA_M2 && narrowestExtent(meet) >= CLASH_INFO_M;
+            })
+                .map((prism) => prism.id));
+            if (here.size === 0)
+                continue;
+            const room = { id: zone.id, name: nameOf(nodes, zone.id) };
+            const entrances = [
+                ...doorEntrances(nodes, doors, zone),
+                ...openEntrances(walls, zone, zones, zone.id),
+            ];
+            for (const entrance of entrances) {
+                const way = wayIn(shapes, level, zone, entrance.ring, entrance.at, baseY, isUnderlay, (prism) => here.has(prism.id));
+                if (!way)
+                    continue;
+                const subject = way.by.find((o) => here.has(o.prism.id));
+                const other = way.by.find((o) => o !== subject);
+                const approximate = way.by.some((o) => o.prism.shape === 'approx');
+                const key = `${zone.id}|${subject.prism.nodeId}`;
+                if ((found.get(key)?.width ?? Number.POSITIVE_INFINITY) <= way.width)
+                    continue;
+                found.set(key, {
+                    width: way.width,
+                    issue: {
+                        type: 'usage_entry_narrow',
+                        message: `${quote(nameOf(nodes, subject.prism.nodeId))} leaves ${m(way.width)} m to enter ${quote(room.name)}, ${other ? `between it and ${quote(nameOf(nodes, other.prism.nodeId))}` : 'against it'} (below ${m(PASSAGE_M)} m).`,
+                        severity: 'warning',
+                        nodeIds: unique([
+                            room.id,
+                            subject.prism.nodeId,
+                            other?.prism.nodeId,
+                            entrance.door?.id,
+                        ]),
+                        valueM: way.width,
+                        thresholdM: PASSAGE_M,
+                        place: { room: room.name, roomId: room.id, at: way.at },
+                        obstacles: way.by.map((o) => ({
+                            nodeId: o.prism.nodeId,
+                            name: nameOf(nodes, o.prism.nodeId),
+                            kind: o.prism.kind,
+                            shape: o.prism.shape,
+                            movable: false,
+                        })),
+                        approximate,
+                    },
+                });
+            }
+        }
+        out.push(...[...found.values()].map(({ issue }) => issue));
+    }
+    return out;
+}

package/dist/spatial/usage-field/fences.d.ts

@@ -0,0 +1,18 @@
+import type { Prism, Skipped } from './types.js';
+import type { Nodes } from './walls.js';
+export type FencePrisms = {
+    fenceId: string;
+    levelId: string | null;
+    prisms: Prism[];
+};
+/**
+ * A deck guard with nothing cut into it is read part by part (`guardPrisms`). Every other fence is
+ * a strip along its centreline, as wide as its thicker of thickness and post, from its support to
+ * its height, with a gate or an open passage taken out of it; the infill is not drawn (a picket
+ * fence is solid to a person) and the height does not follow terrain, so it is approximate.
+ */
+export declare function fenceBodies(nodes: Nodes): {
+    fences: FencePrisms[];
+    skipped: Skipped[];
+};
+//# sourceMappingURL=fences.d.ts.map

package/dist/spatial/usage-field/fences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fences.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/fences.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,KAAK,EAAQ,OAAO,EAAE,MAAM,SAAS,CAAA;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAsBpC,MAAM,MAAM,WAAW,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,KAAK,EAAE,CAAA;CAAE,CAAA;AA6KtF;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG;IAAE,MAAM,EAAE,WAAW,EAAE,CAAC;IAAC,OAAO,EAAE,OAAO,EAAE,CAAA;CAAE,CA0FvF"}

package/dist/spatial/usage-field/fences.js

@@ -0,0 +1,253 @@
+import { resolveLevelId } from '../../lib/node-ancestry.js';
+import { getLevelElevations } from '../../services/storey.js';
+import { sampleFenceCenterline } from '../../systems/fence/fence-centerline.js';
+import { isSplineFence } from '../../systems/fence/fence-spline.js';
+import { fenceBlockCorners, fenceBlockSegments, fenceMiter, layoutGuardFence, } from '../../systems/fence/guard-layout.js';
+import { isCurvedWall } from '../../systems/wall/wall-curve.js';
+import { floorUnder, isHidden } from './support.js';
+/** Samples of a straight stretch carry no information: drop points less than 2 mm off the line around them. */
+function thinned(points) {
+    const kept = [points[0]];
+    for (let i = 1; i < points.length - 1; i++) {
+        const a = kept.at(-1);
+        const c = points[i + 1];
+        const dx = c[0] - a[0];
+        const dz = c[1] - a[1];
+        const length = Math.hypot(dx, dz);
+        const off = length < 1e-9
+            ? 0
+            : Math.abs((points[i][0] - a[0]) * dz - (points[i][1] - a[1]) * dx) / length;
+        if (off > 0.002)
+            kept.push(points[i]);
+    }
+    kept.push(points.at(-1));
+    return kept;
+}
+/** A fence's span between arc lengths `from` and `to`, as the centreline points inside it. */
+function span(points, lengths, from, to) {
+    const at = (s) => {
+        for (let i = 1; i < points.length; i++)
+            if (s <= lengths[i] || i === points.length - 1) {
+                const run = lengths[i] - lengths[i - 1];
+                const t = run > 1e-9
+                    ? (Math.min(Math.max(s, lengths[i - 1]), lengths[i]) - lengths[i - 1]) / run
+                    : 0;
+                return [
+                    points[i - 1][0] + (points[i][0] - points[i - 1][0]) * t,
+                    points[i - 1][1] + (points[i][1] - points[i - 1][1]) * t,
+                ];
+            }
+        return points[0];
+    };
+    const inside = points.filter((_, i) => lengths[i] > from + 1e-9 && lengths[i] < to - 1e-9);
+    return [at(from), ...inside, at(to)];
+}
+/** The longest a run of a curved guard is drawn straight: the renderer's own. */
+const CURVE_SEGMENT_M = 0.18;
+/** The footprint of a box `w` x `d` centred on (x, z) and turned `rotationY` about the vertical axis, as the renderer turns it. */
+function box(x, z, w, d, rotationY) {
+    const cos = Math.cos(rotationY);
+    const sin = Math.sin(rotationY);
+    return [
+        [-w / 2, -d / 2],
+        [w / 2, -d / 2],
+        [w / 2, d / 2],
+        [-w / 2, d / 2],
+    ].map(([cx, cz]) => [x + cx * cos + cz * sin, z - cx * sin + cz * cos]);
+}
+/** The fences that share an end with this one, by end, as the renderer finds them for its corner mitres. */
+function cornerNeighbors(fence, nodes) {
+    const found = {};
+    for (const sibling of Object.values(nodes)) {
+        if (sibling.type !== 'fence' || sibling.id === fence.id || sibling.parentId !== fence.parentId)
+            continue;
+        if (sibling.visible === false)
+            continue;
+        for (const endpoint of ['start', 'end']) {
+            const point = fence[endpoint];
+            if ([sibling.start, sibling.end].some((other) => Math.hypot(point[0] - other[0], point[1] - other[1]) < 0.001) &&
+                !found[endpoint])
+                found[endpoint] = sibling;
+        }
+    }
+    return found;
+}
+/**
+ * A deck guard as the renderer builds it (`layoutGuardFence`, the same layout its meshes come from):
+ * every post, the cap rail and top rail, the bottom rail, and the infill, with the cap and rails
+ * mitred where a fence meets another. The infill is taken as one solid strip: balusters, cables and
+ * boards stand a hand apart and nothing a person carries goes between them. A pyramid post cap is
+ * drawn as its base.
+ */
+function guardPrisms(fence, neighbors, z0) {
+    const layout = layoutGuardFence(fence);
+    const prisms = [];
+    const straight = !isSplineFence(fence) && !isCurvedWall(fence);
+    // a straight fence stands at one lift (the support at its start); a curved one follows the terrain
+    const follows = straight
+        ? undefined
+        : 'a curved guard follows the terrain: its heights are read at its start';
+    const common = { nodeId: fence.id, kind: 'guard', holes: [] };
+    const add = (id, y0, y1, outer, approx) => {
+        if (y1 - y0 > 1e-4)
+            prisms.push({
+                id: `${fence.id}#${id}`,
+                ...common,
+                z0: z0 + y0,
+                z1: z0 + y1,
+                outer,
+                ...(approx || follows
+                    ? { shape: 'approx', why: approx ?? follows }
+                    : { shape: 'exact' }),
+            });
+    };
+    for (const [i, post] of layout.posts.entries()) {
+        const [x, y, z] = post.position;
+        const [w, h, d] = post.scale;
+        if (post.shape === 'pyramid')
+            add(`post.${i}`, y - h / 2, y + h / 2, box(x, z, w * Math.SQRT1_2, d * Math.SQRT1_2, post.rotationY), 'a pyramid post cap, drawn as its base');
+        else
+            add(`post.${i}`, y - h / 2, y + h / 2, box(x, z, w, d, post.rotationY));
+    }
+    // a run is one quad on a straight fence and a quad per short segment on a curved one
+    const run = (name, block, mitre) => {
+        const segments = straight
+            ? [[block.startT, block.endT]]
+            : fenceBlockSegments(fence, block.startT, block.endT, CURVE_SEGMENT_M);
+        for (const [k, [a, b]] of segments.entries()) {
+            const [startOuter, startInner, endOuter, endInner] = fenceBlockCorners(fence, a, b, block.depth);
+            const corners = { startOuter, startInner, endOuter, endInner };
+            if (mitre)
+                for (const endpoint of ['start', 'end']) {
+                    const neighbor = neighbors[endpoint];
+                    if (!neighbor ||
+                        Math.abs((endpoint === 'start' ? a : b) - (endpoint === 'start' ? 0 : 1)) > 1e-5)
+                        continue;
+                    for (const { side, reach, ux, uz } of fenceMiter(fence, endpoint, neighbor, block.depth) ?? []) {
+                        const key = `${endpoint}${side === 1 ? 'Outer' : 'Inner'}`;
+                        corners[key] = [corners[key][0] + ux * reach, corners[key][1] + uz * reach];
+                    }
+                }
+            add(`${name}.${k}`, block.centerY - block.height / 2, block.centerY + block.height / 2, [
+                corners.startOuter,
+                corners.endOuter,
+                corners.endInner,
+                corners.startInner,
+            ]);
+        }
+    };
+    for (const [i, block] of layout.rail.entries())
+        run(`rail.${i}`, block, true);
+    for (const [i, block] of layout.base.entries())
+        run(`base.${i}`, block, true);
+    // the infill: one strip, as high as the infill is, as deep as its pieces are
+    const infill = layout.infill;
+    if (infill.length) {
+        const y0 = Math.min(...infill.map((b) => b.centerY - b.height / 2));
+        const y1 = Math.max(...infill.map((b) => b.centerY + b.height / 2));
+        const first = infill[0];
+        run('infill', {
+            startT: 0,
+            endT: 1,
+            centerY: (y0 + y1) / 2,
+            height: y1 - y0,
+            depth: first.depth,
+            split: true,
+        }, false);
+    }
+    return prisms;
+}
+/**
+ * A deck guard with nothing cut into it is read part by part (`guardPrisms`). Every other fence is
+ * a strip along its centreline, as wide as its thicker of thickness and post, from its support to
+ * its height, with a gate or an open passage taken out of it; the infill is not drawn (a picket
+ * fence is solid to a person) and the height does not follow terrain, so it is approximate.
+ */
+export function fenceBodies(nodes) {
+    const out = [];
+    const skipped = [];
+    const elevations = getLevelElevations(nodes);
+    const support = new Map();
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'fence' || isHidden(node, nodes))
+            continue;
+        const fence = node;
+        try {
+            const points = thinned(sampleFenceCenterline(fence).map((p) => [p.x, p.y]));
+            if (points.length < 2)
+                continue;
+            const lengths = [0];
+            for (let i = 1; i < points.length; i++)
+                lengths.push(lengths[i - 1] +
+                    Math.hypot(points[i][0] - points[i - 1][0], points[i][1] - points[i - 1][1]));
+            const total = lengths.at(-1);
+            const gaps = (fence.children ?? [])
+                .map((id) => nodes[id])
+                .flatMap((child) => child?.type === 'fence-gate' || child?.type === 'fence-opening'
+                ? [[child.center - child.width / 2, child.center + child.width / 2]]
+                : [])
+                .sort((a, b) => a[0] - b[0]);
+            const spans = [];
+            let from = 0;
+            for (const [start, end] of gaps) {
+                if (start > from)
+                    spans.push([from, Math.min(start, total)]);
+                from = Math.max(from, end);
+            }
+            if (from < total)
+                spans.push([from, total]);
+            const levelId = resolveLevelId(fence, nodes);
+            const baseY = elevations.get(levelId)?.baseY ?? 0;
+            const floor = floorUnder(fence, {
+                position: [points[0][0], 0, points[0][1]],
+                dimensions: [fence.thickness, fence.height, fence.thickness],
+                rotation: [0, 0, 0],
+            }, nodes, levelId, support);
+            const half = Math.max(fence.thickness, fence.postSize) / 2;
+            const z0 = baseY + floor + (fence.supportOffset ?? 0);
+            const prisms = [];
+            // a guard with nothing cut into it is read part by part; any other fence is a strip
+            if (fence.style === 'guard' && !fence.children?.length) {
+                prisms.push(...guardPrisms(fence, cornerNeighbors(fence, nodes), z0));
+            }
+            else {
+                for (const [index, [a, b]] of spans.entries()) {
+                    const run = span(points, lengths, a, b);
+                    for (let i = 1; i < run.length; i++) {
+                        const [px, pz] = run[i - 1];
+                        const [qx, qz] = run[i];
+                        const length = Math.hypot(qx - px, qz - pz);
+                        if (length < 1e-6)
+                            continue;
+                        const nx = ((pz - qz) / length) * half;
+                        const nz = ((qx - px) / length) * half;
+                        prisms.push({
+                            id: `${fence.id}#fence.${index}.${i}`,
+                            nodeId: fence.id,
+                            kind: 'other',
+                            z0,
+                            z1: z0 + fence.height,
+                            outer: [
+                                [px + nx, pz + nz],
+                                [qx + nx, qz + nz],
+                                [qx - nx, qz - nz],
+                                [px - nx, pz - nz],
+                            ],
+                            holes: [],
+                            shape: 'approx',
+                            why: 'a fence as a strip along its centreline',
+                        });
+                    }
+                }
+            }
+            out.push({ fenceId: fence.id, levelId, prisms });
+        }
+        catch (error) {
+            skipped.push({
+                nodeId: fence.id,
+                why: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return { fences: out, skipped };
+}