@pascal-app/core 1.0.6 → 1.1.0

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

@@ -0,0 +1,187 @@
+import { isFloorUnderlay } from '../../agent-operations/furniture-kind.js';
+import { area, intersection } from '../../lib/polygon-boolean.js';
+import { cm, nameOf, quote, unique } from './labels.js';
+import { boxesMeet, hosts, isBed, isBuildingElement, isFoliage, isPiecePrism, itemText, narrowestExtent, ringBox, roomAt, } from './pieces.js';
+/** Two shapes that overlap by less than this are touching, not clashing (the outlines' own tolerance is 2 cm). */
+export const CLASH_INFO_M = 0.02;
+/** From this depth a clash is a warning; between the two it is information. */
+export const CLASH_WARNING_M = 0.08;
+/** An approximate shape needs a warning at a greater depth: its outline's own error is this order. */
+export const CLASH_APPROX_WARNING_M = 0.12;
+/** A clash smaller than this in plan is a sliver (m²). */
+export const CLASH_MIN_AREA_M2 = 0.002;
+/** A wall-fixed piece (a cabinet, a wall unit) may sink this far into a wall: it is scribed to it. */
+export const SCRIBE_M = 0.05;
+const MIN_HEIGHT_OVERLAP_M = 0.02;
+/** A piece this thin (a rug, a mat) is a covering, not something a piece stands in. */
+const FLAT_COVERING_M = 0.03;
+/** A chair tucked under its table overlaps it by up to this much (m). */
+const TUCKED_M = 0.15;
+const BUILT_IN = /oven|hob\b|cook ?top|cooker|stove|range|washing|washer|dryer|dishwasher|sink|fridge|refrigerator/i;
+const SEAT = /(?:^|[^a-z])(?:chair|stool)(?![a-z])/i;
+const TABLE = /(?:^|[^a-z])(?:table|desk)(?![a-z])/i;
+export const OBSTACLE_KINDS = new Set([
+    'wall',
+    'jamb',
+    'door-head',
+    'threshold',
+    'window-frame',
+    'sill',
+    'stair',
+    'stair-rail',
+    'guard',
+]);
+const WHAT = {
+    wall: 'the wall',
+    jamb: 'the frame of',
+    'door-head': 'the frame of',
+    threshold: 'the threshold of',
+    'window-frame': 'the frame of',
+    sill: 'the sill of',
+    stair: 'the stair',
+    'stair-rail': 'the railing of',
+    guard: 'the guard',
+};
+export function wallFixed(nodes, prism) {
+    if (prism.kind === 'cabinet' || prism.host)
+        return true;
+    const node = nodes[prism.nodeId];
+    const attach = node?.type === 'item' ? node.asset?.attachTo : undefined;
+    return attach === 'wall' || attach === 'wall-side';
+}
+/**
+ * How deep two prisms stand in each other, or null: the same node, a host and what it carries, a wall
+ * and what is fixed to it, a contact, a sliver, a column that runs up into the piece above it, and a
+ * wall-fixed piece scribed to its wall are not clashes.
+ */
+export function pairClash(nodes, a, b) {
+    if (a.nodeId === b.nodeId)
+        return null;
+    if (hosts(nodes, a.nodeId, b.nodeId) || hosts(nodes, b.nodeId, a.nodeId))
+        return null;
+    if (a.host?.wallId === b.nodeId || b.host?.wallId === a.nodeId)
+        return null;
+    const z0 = Math.max(a.z0, b.z0);
+    const z1 = Math.min(a.z1, b.z1);
+    if (z1 - z0 < MIN_HEIGHT_OVERLAP_M)
+        return null;
+    const meet = intersection({ outer: a.outer, holes: a.holes }, { outer: b.outer, holes: b.holes });
+    const size = area(meet);
+    if (size < CLASH_MIN_AREA_M2)
+        return null;
+    const depth = narrowestExtent(meet);
+    if (depth < CLASH_INFO_M)
+        return null;
+    // a column that runs up into the piece above it (a beam) is joined to it, not clashing
+    const column = a.kind === 'column' ? a : b.kind === 'column' ? b : null;
+    if (column && z1 >= column.z1 - 0.05)
+        return null;
+    if (b.kind === 'wall' && wallFixed(nodes, a) && depth <= SCRIBE_M)
+        return null;
+    if (Math.min(a.z1 - a.z0, b.z1 - b.z0) <= FLAT_COVERING_M)
+        return null;
+    // a cabinet run is drawn as its box; the oven, hob or machine built into it is inside it by design
+    for (const [run, other] of [
+        [a, b],
+        [b, a],
+    ])
+        if (run.kind === 'cabinet' &&
+            run.shape === 'approx' &&
+            BUILT_IN.test(itemText(nodes, other.nodeId)))
+            return null;
+    if (depth <= TUCKED_M)
+        for (const [seat, table] of [
+            [a, b],
+            [b, a],
+        ])
+            if (SEAT.test(itemText(nodes, seat.nodeId)) && TABLE.test(itemText(nodes, table.nodeId)))
+                return null;
+    const ring = meet[0].outer;
+    return {
+        depth,
+        area: size,
+        at: [
+            ring.reduce((sum, p) => sum + p[0], 0) / ring.length,
+            ring.reduce((sum, p) => sum + p[1], 0) / ring.length,
+        ],
+        zFrom: z0,
+        zTo: z1,
+    };
+}
+/**
+ * A piece of furniture or a fixture that stands inside something solid: another piece, a wall body, a
+ * door or window frame or sill, a stair or a guard (a curtain or a blind is read with its opening). Read on the real outlines, so a
+ * contact (under 2 cm), a piece resting on another, a rug, foliage, a building element (trim, soffit,
+ * pier, beam) and a wall-fixed piece scribed to its wall (5 cm) stay quiet. From 2 cm it is information,
+ * from 8 cm a warning, and from 12 cm for an approximate outline, still labeled as such.
+ */
+export function clashIssues(nodes, shapes) {
+    const out = [];
+    for (const level of shapes.levels) {
+        const prisms = level.prisms.filter((prism) => !(nodes[prism.nodeId]?.type === 'item' && isFloorUnderlay(nodes[prism.nodeId])));
+        const pieces = prisms.filter((prism) => isPiecePrism(prism) &&
+            !isFoliage(nodes, prism.nodeId) &&
+            !isBuildingElement(nodes, prism.nodeId));
+        const others = prisms.filter((prism) => (isPiecePrism(prism) || OBSTACLE_KINDS.has(prism.kind)) &&
+            !isFoliage(nodes, prism.nodeId) &&
+            !isBuildingElement(nodes, prism.nodeId));
+        const boxes = new Map();
+        const box = (prism) => {
+            const known = boxes.get(prism);
+            if (known)
+                return known;
+            const fresh = ringBox(prism.outer);
+            boxes.set(prism, fresh);
+            return fresh;
+        };
+        const found = new Map();
+        for (const a of pieces) {
+            for (const b of others) {
+                if (isPiecePrism(b) && b.nodeId < a.nodeId)
+                    continue;
+                if (!boxesMeet(box(a), box(b)))
+                    continue;
+                const clash = pairClash(nodes, a, b);
+                if (!clash)
+                    continue;
+                const key = `${a.nodeId}|${b.nodeId}|${b.kind}`;
+                const prior = found.get(key);
+                if (!prior || clash.depth > prior.depth)
+                    found.set(key, { a, b, ...clash });
+                else
+                    prior.area += clash.area;
+            }
+        }
+        for (const { a, b, depth, area: size, at } of found.values()) {
+            // a bed head against a window is a design choice, not a finding
+            if (isBed(nodes[a.nodeId]) && (b.kind === 'sill' || b.kind === 'window-frame'))
+                continue;
+            const approximate = a.shape === 'approx' || b.shape === 'approx';
+            const room = roomAt(nodes, level.levelId, at);
+            const who = quote(nameOf(nodes, a.nodeId));
+            const target = isPiecePrism(b)
+                ? `${quote(nameOf(nodes, b.nodeId))}`
+                : `${WHAT[b.kind] ?? 'the'} ${quote(nameOf(nodes, b.nodeId))}`;
+            const warnAt = approximate ? CLASH_APPROX_WARNING_M : CLASH_WARNING_M;
+            const severity = depth >= warnAt ? 'warning' : 'info';
+            out.push({
+                type: 'usage_clash',
+                message: `${who} ${isPiecePrism(b) ? 'overlaps' : 'stands'} ${cm(depth)} ${isPiecePrism(b) ? 'of' : 'into'} ${target}${room ? ` in ${quote(room.name)}` : ''}${size >= 0.1 || approximate ? ` (${[size >= 0.1 ? `${Math.round(size * 1e4)} cm² in plan` : '', approximate ? 'approximate shape' : ''].filter(Boolean).join(', ')})` : ''}.`,
+                severity,
+                nodeIds: unique([room?.id, a.nodeId, b.nodeId]),
+                valueM: Math.round(depth * 1000) / 1000,
+                thresholdM: warnAt,
+                place: { room: room?.name ?? '', roomId: room?.id ?? level.levelId, at },
+                obstacles: [a, b].map((prism) => ({
+                    nodeId: prism.nodeId,
+                    name: nameOf(nodes, prism.nodeId),
+                    kind: prism.kind,
+                    shape: prism.shape,
+                    movable: false,
+                })),
+                approximate,
+            });
+        }
+    }
+    return out;
+}

package/dist/spatial/usage-field/door-stairs.d.ts

@@ -0,0 +1,18 @@
+import type { UsageIssue } from './findings.js';
+import type { UsageShapes } from './types.js';
+import type { Nodes } from './walls.js';
+/**
+ * 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 declare function doorOverStairIssues(nodes: Nodes, shapes: UsageShapes): UsageIssue[];
+//# sourceMappingURL=door-stairs.d.ts.map

package/dist/spatial/usage-field/door-stairs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"door-stairs.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/door-stairs.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAY5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAC1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAyBpC;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,GAAG,UAAU,EAAE,CA2FnF"}

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"}