@pascal-app/core 1.0.6 → 1.0.7

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

@@ -0,0 +1,346 @@
+import { isFloorUnderlay } from '../../agent-operations/furniture-kind.js';
+import { area, intersection } from '../../lib/polygon-boolean.js';
+import { getScaledDimensions } from '../../schema/index.js';
+import { m, nameOf, quote, unique } from './labels.js';
+import { obstaclesInBand, rayHit } from './obstacles.js';
+import { boxesMeet, isBed, ringBox, roomAt } from './pieces.js';
+/** The footprint's short side (frame included) that makes a class, m: a retailer's Australian mattress widths plus a frame of 10 to 20 cm. */
+export const BED_CLASS_FROM_M = [
+    ['king', 1.75],
+    ['queen', 1.5],
+    ['double', 1.2],
+    ['single', 0],
+];
+/** A bed of each class as a footprint with its frame and headboard (width, length), m. */
+const BED_FOOTPRINT_M = {
+    king: [1.95, 2.15],
+    queen: [1.65, 2.15],
+    double: [1.5, 2.1],
+    single: [1.1, 2.05],
+};
+/** A person gets by with this much on a side or at the foot (one unit of passage); UK M4(2) asks 0.75 m, the Scottish draft 0.80 m beside the bed. */
+export const BED_ACCESS_M = 0.6;
+/** The room's short side under which a bed is small for it, from a retailer's recommended minimum rooms (3.0 x 4.0 m queen, 3.2 x 4.2 m king), m. */
+export const BED_ROOM_SHORT_M = { queen: 3.0, king: 3.2 };
+const FEET_FROM_M = 0.03;
+const FEET_TO_M = 0.7;
+const RAY_MAX_M = 3;
+export const bedClassOf = (width) => BED_CLASS_FROM_M.find(([, from]) => width >= from)[0];
+const median = (values) => [...values].sort((a, b) => a - b)[Math.floor(values.length / 2)] ?? RAY_MAX_M;
+/** The smallest rectangle round an outline (180 directions): its centre, its axes, its long and short side. */
+function boundingRectangle(points) {
+    let best = null;
+    let bestArea = Number.POSITIVE_INFINITY;
+    for (let k = 0; k < 180; k++) {
+        const a = (k * Math.PI) / 180;
+        const c = Math.cos(a);
+        const s = Math.sin(a);
+        let u0 = Number.POSITIVE_INFINITY;
+        let u1 = Number.NEGATIVE_INFINITY;
+        let v0 = Number.POSITIVE_INFINITY;
+        let v1 = Number.NEGATIVE_INFINITY;
+        for (const [x, z] of points) {
+            const u = x * c + z * s;
+            const v = -x * s + z * c;
+            u0 = Math.min(u0, u);
+            u1 = Math.max(u1, u);
+            v0 = Math.min(v0, v);
+            v1 = Math.max(v1, v);
+        }
+        const size = (u1 - u0) * (v1 - v0);
+        if (size < bestArea) {
+            bestArea = size;
+            best = { u0, u1, v0, v1, c, s };
+        }
+    }
+    const r = best;
+    const du = r.u1 - r.u0;
+    const dv = r.v1 - r.v0;
+    const at = (u, v) => [u * r.c - v * r.s, u * r.s + v * r.c];
+    const longIsU = du >= dv;
+    return {
+        centre: at((r.u0 + r.u1) / 2, (r.v0 + r.v1) / 2),
+        long: longIsU ? [r.c, r.s] : [-r.s, r.c],
+        across: longIsU ? [-r.s, r.c] : [r.c, r.s],
+        length: Math.max(du, dv),
+        width: Math.min(du, dv),
+    };
+}
+const CLASS_WORDS = [
+    ['king', /king/i],
+    ['queen', /queen/i],
+    ['double', /double/i],
+    ['single', /single|twin/i],
+];
+/**
+ * A bed standing wider than long, bedside tables included, reads as lying across its room: its
+ * head-to-foot axis is the item's own z (a bed's length is never less than its width), whatever the
+ * box says. Null for any other piece, which keeps the smallest rectangle round its outline.
+ */
+function ownAxes(node, outline) {
+    if (node?.type !== 'item')
+        return null;
+    const [width, , depth] = getScaledDimensions(node);
+    if (!(width > depth + 0.05))
+        return null;
+    const angle = node.rotation[1];
+    const along = [Math.sin(angle), Math.cos(angle)];
+    const across = [Math.cos(angle), -Math.sin(angle)];
+    const us = outline.map(([x, z]) => x * across[0] + z * across[1]);
+    const vs = outline.map(([x, z]) => x * along[0] + z * along[1]);
+    const [u0, u1] = [Math.min(...us), Math.max(...us)];
+    const [v0, v1] = [Math.min(...vs), Math.max(...vs)];
+    const [u, v] = [(u0 + u1) / 2, (v0 + v1) / 2];
+    return {
+        centre: [u * across[0] + v * along[0], u * across[1] + v * along[1]],
+        long: along,
+        across,
+        length: v1 - v0,
+        width: u1 - u0,
+    };
+}
+/** The mattress's class: the width of the item's own bed part when its manifest has one, else a size its name states, else the footprint's width. */
+function classOfBed(node, name, rect) {
+    if (node?.type === 'item') {
+        const part = node.source?.manifest?.parts?.find((candidate) => candidate.type === 'bed');
+        if (part?.bounds)
+            return bedClassOf((part.bounds.max[0] - part.bounds.min[0]) * node.scale[0]);
+        const named = CLASS_WORDS.find(([, words]) => words.test(name));
+        if (named && rect.width > rect.length)
+            return named[0];
+    }
+    return bedClassOf(rect.width);
+}
+/** One bed's size class and free space, from its own prisms and those of its level (the bed itself may be a candidate that is not in the scene). */
+export function measureBedPrisms(nodes, levelId, bed, own, prisms) {
+    if (!own.length)
+        return null;
+    const floor = Math.min(...own.map((prism) => prism.z0));
+    const outline = own
+        .filter((prism) => prism.z0 < floor + 0.9)
+        .flatMap((prism) => prism.outer);
+    if (outline.length < 3)
+        return null;
+    const rect = ownAxes(nodes[bed.id], outline) ?? boundingRectangle(outline);
+    const band = { z0: floor + FEET_FROM_M, z1: floor + FEET_TO_M };
+    // what lies on or under the bed (bedding, a throw) is not an obstacle beside it
+    const overlapsBed = (prism) => own.some((piece) => boxesMeet(ringBox(piece.outer), ringBox(prism.outer)) &&
+        area(intersection({ outer: piece.outer, holes: piece.holes }, { outer: prism.outer, holes: prism.holes })) > 1e-4);
+    const others = obstaclesInBand(prisms, band, undefined, (prism) => prism.nodeId === bed.id || overlapsBed(prism));
+    const wallObstacles = obstaclesInBand(prisms.filter((prism) => prism.kind === 'wall'), band);
+    const ends = [
+        [
+            rect.centre[0] + (rect.long[0] * rect.length) / 2,
+            rect.centre[1] + (rect.long[1] * rect.length) / 2,
+        ],
+        [
+            rect.centre[0] - (rect.long[0] * rect.length) / 2,
+            rect.centre[1] - (rect.long[1] * rect.length) / 2,
+        ],
+    ];
+    const wallGap = (p) => Math.min(...wallObstacles.map((o) => rayDistance(o, p)), Number.POSITIVE_INFINITY);
+    const headFirst = wallGap(ends[0]) <= wallGap(ends[1]);
+    const head = headFirst ? ends[0] : ends[1];
+    const foot = headFirst ? ends[1] : ends[0];
+    const out2 = [foot[0] - head[0], foot[1] - head[1]];
+    const outLen = Math.hypot(out2[0], out2[1]) || 1;
+    const toFoot = [out2[0] / outLen, out2[1] / outLen];
+    const steps = Math.max(4, Math.round(rect.length / 0.05));
+    const along = (t) => [
+        foot[0] - toFoot[0] * rect.length * t,
+        foot[1] - toFoot[1] * rect.length * t,
+    ];
+    const sideRays = (sign) => {
+        const dir = [rect.across[0] * sign, rect.across[1] * sign];
+        const hits = [];
+        for (let i = 0; i <= Math.round(steps * 0.75); i++) {
+            const p = along(i / steps);
+            hits.push(rayHit([p[0] + dir[0] * (rect.width / 2), p[1] + dir[1] * (rect.width / 2)], dir, others, RAY_MAX_M));
+        }
+        return median(hits);
+    };
+    const footHits = [];
+    for (let i = 0; i <= 20; i++) {
+        const across = (i / 20 - 0.5) * rect.width;
+        footHits.push(rayHit([foot[0] + rect.across[0] * across, foot[1] + rect.across[1] * across], toFoot, others, RAY_MAX_M));
+    }
+    const room = roomAt(nodes, levelId, rect.centre);
+    const zone = room ? nodes[room.id] : null;
+    const bounds = zone ? ringBox(zone.polygon) : null;
+    return {
+        id: bed.id,
+        name: bed.name,
+        levelId,
+        room,
+        widthM: Math.round(rect.width * 100) / 100,
+        lengthM: Math.round(rect.length * 100) / 100,
+        sizeClass: classOfBed(nodes[bed.id], bed.name, rect),
+        left: Math.round(sideRays(1) * 100) / 100,
+        right: Math.round(sideRays(-1) * 100) / 100,
+        foot: Math.round(median(footHits) * 100) / 100,
+        roomShortSideM: bounds
+            ? Math.round(Math.min(bounds[2] - bounds[0], bounds[3] - bounds[1]) * 100) / 100
+            : null,
+        at: [Math.round(rect.centre[0] * 100) / 100, Math.round(rect.centre[1] * 100) / 100],
+    };
+}
+/** What leaves a bed tight: the foot under 0.60 m, no side at 0.60 m, a king with one. */
+export function bedTightness(bed) {
+    const sides = [bed.left, bed.right].filter((side) => side >= BED_ACCESS_M).length;
+    const reasons = [];
+    if (bed.foot < BED_ACCESS_M)
+        reasons.push(`${m(bed.foot)} m at its foot`);
+    if (sides === 0)
+        reasons.push(`no side with ${m(BED_ACCESS_M)} m (${m(bed.left)} and ${m(bed.right)} m)`);
+    else if (bed.sizeClass === 'king' && sides < 2)
+        reasons.push(`a king with ${m(Math.min(bed.left, bed.right))} m on one side`);
+    return reasons;
+}
+/** Every bed of the scene with its size class and the free space round it, measured on the real shapes of the feet band. */
+export function measureBeds(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])));
+        for (const node of Object.values(nodes)) {
+            if (!isBed(node))
+                continue;
+            const own = prisms.filter((prism) => prism.nodeId === node.id);
+            const bed = measureBedPrisms(nodes, level.levelId, { id: node.id, name: nameOf(nodes, node.id) }, own, prisms);
+            if (bed)
+                out.push(bed);
+        }
+    }
+    return out;
+}
+/** The distance from a point to an obstacle's outline. */
+function rayDistance(o, p) {
+    let best = Number.POSITIVE_INFINITY;
+    for (let k = 0; k < o.edges.length; k += 4) {
+        const ax = o.edges[k];
+        const az = o.edges[k + 1];
+        const ex = o.edges[k + 2] - ax;
+        const ez = o.edges[k + 3] - az;
+        const l2 = ex * ex + ez * ez;
+        const t = l2 ? Math.max(0, Math.min(1, ((p[0] - ax) * ex + (p[1] - az) * ez) / l2)) : 0;
+        best = Math.min(best, Math.hypot(p[0] - ax - ex * t, p[1] - az - ez * t));
+    }
+    return best;
+}
+/**
+ * A queen or a king bed's room, read the way a person would: free space at the foot, on each side,
+ * and the room against the size. Guides; never refuses. Tight: the foot under 0.60 m; a king with
+ * fewer than two sides at 0.60 m; a bed with no side at 0.60 m. Small for its size (information):
+ * the room's short side under a retailer's recommended minimum.
+ */
+export function bedIssues(nodes, shapes) {
+    const out = [];
+    for (const bed of measureBeds(nodes, shapes)) {
+        if (bed.sizeClass === 'single')
+            continue;
+        const reasons = bedTightness(bed);
+        const where = bed.room ? ` in ${quote(bed.room.name)}` : '';
+        const base = {
+            nodeIds: unique([bed.room?.id, bed.id]),
+            place: { room: bed.room?.name ?? '', roomId: bed.room?.id ?? bed.levelId, at: bed.at },
+            obstacles: [],
+            approximate: false,
+        };
+        if (reasons.length)
+            out.push({
+                ...base,
+                type: 'usage_bed_clearance',
+                message: `${quote(bed.name)} (a ${bed.sizeClass}, ${m(bed.widthM)} x ${m(bed.lengthM)} m)${where} leaves ${reasons.join(' and ')}: tight.`,
+                severity: 'warning',
+                valueM: Math.min(bed.foot, Math.max(bed.left, bed.right)),
+                thresholdM: BED_ACCESS_M,
+            });
+        const recommended = BED_ROOM_SHORT_M[bed.sizeClass];
+        if (recommended && bed.roomShortSideM !== null && bed.roomShortSideM < recommended)
+            out.push({
+                ...base,
+                type: 'usage_bed_clearance',
+                message: `${quote(bed.name)} is a ${bed.sizeClass}${where}, a room ${m(bed.roomShortSideM)} m on its short side: retailers recommend ${m(recommended)} m or more for a ${bed.sizeClass}.`,
+                severity: 'info',
+                valueM: bed.roomShortSideM,
+                thresholdM: recommended,
+            });
+    }
+    return out;
+}
+/**
+ * The largest bed class a room can take: one with its head on a wall, 0.60 m at its foot and on at
+ * least one side (two for a king), clear of every piece and wall. A pure read for placement.
+ */
+export function bedFit(nodes, shapes, zoneId) {
+    const zone = nodes[zoneId];
+    if (zone?.type !== 'zone')
+        return null;
+    const level = shapes.levels.find((l) => l.levelId === zone.parentId);
+    if (!level)
+        return null;
+    const polygon = zone.polygon;
+    const floorY = Math.min(...level.floors.map((f) => f.y), Number.POSITIVE_INFINITY);
+    const band = {
+        z0: (Number.isFinite(floorY) ? floorY : 0) + FEET_FROM_M,
+        z1: (Number.isFinite(floorY) ? floorY : 0) + FEET_TO_M,
+    };
+    const blockers = obstaclesInBand(level.prisms.filter((prism) => !(nodes[prism.nodeId]?.type === 'item' && isFloorUnderlay(nodes[prism.nodeId]))), band);
+    const centre = [
+        polygon.reduce((s, p) => s + p[0], 0) / polygon.length,
+        polygon.reduce((s, p) => s + p[1], 0) / polygon.length,
+    ];
+    for (const [cls] of BED_CLASS_FROM_M) {
+        const [width, length] = BED_FOOTPRINT_M[cls];
+        for (let edge = 0; edge < polygon.length; edge++) {
+            const a = polygon[edge];
+            const b = polygon[(edge + 1) % polygon.length];
+            const run = Math.hypot(b[0] - a[0], b[1] - a[1]);
+            if (run < width)
+                continue;
+            const along = [(b[0] - a[0]) / run, (b[1] - a[1]) / run];
+            let inward = [-along[1], along[0]];
+            if ((centre[0] - a[0]) * inward[0] + (centre[1] - a[1]) * inward[1] < 0)
+                inward = [-inward[0], -inward[1]];
+            const sidesNeeded = cls === 'king' ? 2 : 1;
+            for (let s = width / 2; s <= run - width / 2 + 1e-9; s += 0.1) {
+                // the bed against the wall (its back at the wall face: 8 cm off the room's edge), then the strips round it
+                const at = (u, v) => [
+                    a[0] + along[0] * (s + u) + inward[0] * (0.08 + v),
+                    a[1] + along[1] * (s + u) + inward[1] * (0.08 + v),
+                ];
+                const rect = (u0, u1, v0, v1) => [
+                    at(u0, v0),
+                    at(u1, v0),
+                    at(u1, v1),
+                    at(u0, v1),
+                ];
+                const free = (ring) => {
+                    const box = ringBox(ring);
+                    return !blockers.some((o) => boxesMeet(box, o.aabb) &&
+                        area(intersection(ring, { outer: o.prism.outer, holes: o.prism.holes })) > 0.005);
+                };
+                const inside = (ring) => ring.every((p) => pointIn(p, polygon));
+                const body = rect(-width / 2, width / 2, 0, length);
+                const foot = rect(-width / 2, width / 2, length, length + BED_ACCESS_M);
+                const left = rect(-width / 2 - BED_ACCESS_M, -width / 2, 0, length * 0.75);
+                const right = rect(width / 2, width / 2 + BED_ACCESS_M, 0, length * 0.75);
+                if (!(inside(body) && free(body) && inside(foot) && free(foot)))
+                    continue;
+                const openSides = [left, right].filter((r) => inside(r) && free(r)).length;
+                if (openSides >= sidesNeeded)
+                    return cls;
+            }
+        }
+    }
+    return null;
+}
+function pointIn(p, ring) {
+    let inside = false;
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+        const [xi, zi] = ring[i];
+        const [xj, zj] = ring[j];
+        if (zi > p[1] !== zj > p[1] && p[0] < ((xj - xi) * (p[1] - zi)) / (zj - zi) + xi)
+            inside = !inside;
+    }
+    return inside;
+}

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

@@ -0,0 +1,28 @@
+import { type UsageIssue } from './findings.js';
+import type { Prism, UsageShapes } from './types.js';
+import type { Nodes } from './walls.js';
+/** How far in front of the glass a piece blocks the window: a curtain's depth (m). */
+export declare const WINDOW_BLOCK_M = 0.15;
+/** And the strip beyond it, read as information (m). */
+export declare const WINDOW_NEAR_M = 0.3;
+/** A piece blocks a window from this height above the sill: below it, a sideboard under the sill is fine (m). */
+export declare const WINDOW_ABOVE_SILL_M = 0.3;
+/** Of the window's width, a piece must cover this share to block it. */
+export declare const WINDOW_COVER = 0.25;
+/** A piece this deep in a curtain or blind envelope is in the curtains (m). */
+export declare const ENVELOPE_M = 0.05;
+export declare const isSetAtWindow: (text: string) => boolean;
+/**
+ * What stands in front of an opening. A window: a piece whose top is at least 30 cm above its sill,
+ * within 15 cm of the glass across a quarter of its width, blocks it (a low sideboard under the sill
+ * does not); within 30 cm it is information, unless it covers the whole glass, its width and up to its head,
+ * or is a curtain or blind that stands free (one hosted on the window is its treatment, read as its envelope); a piece 5 cm deep
+ * in its curtain or blind envelope is in the curtains. A door's swing is read by `doorSwingIssues`.
+ */
+export declare function blockedOpeningIssues(nodes: Nodes, shapes: UsageShapes, 
+/** A piece that is not in the scene (yet): only the windows it would stand in front of are read, on its level. */
+candidate?: {
+    levelId: string;
+    prisms: Prism[];
+}): UsageIssue[];
+//# sourceMappingURL=blocked.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blocked.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/blocked.ts"],"names":[],"mappings":"AAMA,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,YAAY,CAAA;AAYzD,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,sFAAsF;AACtF,eAAO,MAAM,cAAc,OAAO,CAAA;AAClC,wDAAwD;AACxD,eAAO,MAAM,aAAa,MAAM,CAAA;AAChC,iHAAiH;AACjH,eAAO,MAAM,mBAAmB,MAAM,CAAA;AACtC,wEAAwE;AACxE,eAAO,MAAM,YAAY,OAAO,CAAA;AAChC,+EAA+E;AAC/E,eAAO,MAAM,UAAU,OAAO,CAAA;AAQ9B,eAAO,MAAM,aAAa,SAAU,MAAM,KAAG,OAAmC,CAAA;AAqChF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,WAAW;AACnB,kHAAkH;AAClH,SAAS,CAAC,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,KAAK,EAAE,CAAA;CAAE,GAC/C,UAAU,EAAE,CA4Id"}

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

@@ -0,0 +1,185 @@
+import { isFloorUnderlay } from '../../agent-operations/furniture-kind.js';
+import { resolveLevelId } from '../../lib/node-ancestry.js';
+import { area, intersection } from '../../lib/polygon-boolean.js';
+import { getLevelElevations } from '../../services/storey.js';
+import { getWallLocalFaceZ } from '../../systems/wall/wall-frame.js';
+import { TOLERANCE_M } from './findings.js';
+import { cm, nameOf, quote, unique } from './labels.js';
+import { boxesMeet, isBed, isFoliage, isPiecePrism, itemText, narrowestExtent, ringBox, roomAt, } from './pieces.js';
+/** How far in front of the glass a piece blocks the window: a curtain's depth (m). */
+export const WINDOW_BLOCK_M = 0.15;
+/** And the strip beyond it, read as information (m). */
+export const WINDOW_NEAR_M = 0.3;
+/** A piece blocks a window from this height above the sill: below it, a sideboard under the sill is fine (m). */
+export const WINDOW_ABOVE_SILL_M = 0.3;
+/** Of the window's width, a piece must cover this share to block it. */
+export const WINDOW_COVER = 0.25;
+/** A piece this deep in a curtain or blind envelope is in the curtains (m). */
+export const ENVELOPE_M = 0.05;
+const MIN_AREA_M2 = 0.01;
+/** What is set at a window by design: a shower, a bath or a tub (its glass or rim is no curtain), a bedside piece or a lamp (its top is a shade, not a wall). */
+const SET_AT_WINDOW = /shower|bath|(?:^|[^a-z])tub(?![a-z])|bedside|night ?stand|(?:^|[^a-z])lamp(?![a-z])/i;
+/** What hangs at a window: a free piece named for one is a window treatment that was never put on the window. */
+const CURTAIN = /curtain|drape|blind|shutter|sheer|pelmet|valance/i;
+export const isSetAtWindow = (text) => SET_AT_WINDOW.test(text);
+const point = (frame, along, out) => {
+    const [sx, sz] = frame.wall.start;
+    return [
+        sx + frame.tx * along + frame.nx * (frame.faceZ + frame.sign * out),
+        sz + frame.tz * along + frame.nz * (frame.faceZ + frame.sign * out),
+    ];
+};
+function roomSides(wall) {
+    const [sx, sz] = wall.start;
+    const [ex, ez] = wall.end;
+    const length = Math.hypot(ex - sx, ez - sz);
+    if (length < 1e-6)
+        return [];
+    const tx = (ex - sx) / length;
+    const tz = (ez - sz) / length;
+    const base = { wall, tx, tz, nx: -tz, nz: tx };
+    const sides = [];
+    // the faces a wall calls exterior are not a room's: a partition (both faces interior) is judged on both
+    if (wall.frontSide !== 'exterior')
+        sides.push({ ...base, faceZ: getWallLocalFaceZ(wall, 'a'), sign: 1 });
+    if (wall.backSide !== 'exterior')
+        sides.push({ ...base, faceZ: getWallLocalFaceZ(wall, 'b'), sign: -1 });
+    return sides;
+}
+/**
+ * What stands in front of an opening. A window: a piece whose top is at least 30 cm above its sill,
+ * within 15 cm of the glass across a quarter of its width, blocks it (a low sideboard under the sill
+ * does not); within 30 cm it is information, unless it covers the whole glass, its width and up to its head,
+ * or is a curtain or blind that stands free (one hosted on the window is its treatment, read as its envelope); a piece 5 cm deep
+ * in its curtain or blind envelope is in the curtains. A door's swing is read by `doorSwingIssues`.
+ */
+export function blockedOpeningIssues(nodes, shapes, 
+/** A piece that is not in the scene (yet): only the windows it would stand in front of are read, on its level. */
+candidate) {
+    const out = [];
+    // a piece of several bands, or a window with two panes, is one finding: the worst reading of each pair
+    const worst = new Map();
+    const keep = (key, issue, rank) => {
+        const known = worst.get(key);
+        if (!known || rank > known.rank)
+            worst.set(key, { issue, rank });
+    };
+    const elevations = getLevelElevations(nodes);
+    for (const level of shapes.levels) {
+        if (candidate && level.levelId !== candidate.levelId)
+            continue;
+        const baseY = elevations.get(level.levelId)?.baseY ?? 0;
+        const prisms = level.prisms.filter((prism) => !(nodes[prism.nodeId]?.type === 'item' && isFloorUnderlay(nodes[prism.nodeId])));
+        const pieces = candidate
+            ? candidate.prisms
+            : prisms.filter((prism) => isPiecePrism(prism) && !isFoliage(nodes, prism.nodeId));
+        const pieceBoxes = new Map(pieces.map((prism) => [prism, ringBox(prism.outer)]));
+        for (const node of Object.values(nodes)) {
+            if ((node.type !== 'window' && node.type !== 'door') || node.visible === false)
+                continue;
+            const opening = node;
+            const wall = nodes[opening.parentId ?? ''];
+            if (wall?.type !== 'wall' || resolveLevelId(wall, nodes) !== level.levelId)
+                continue;
+            const half = (opening.width ?? 0.9) / 2;
+            const along = opening.position[0];
+            const frames = prisms.filter((prism) => prism.nodeId === opening.id &&
+                (prism.kind === 'window-frame' || prism.kind === 'jamb' || prism.kind === 'door-head'));
+            const glazed = frames.filter((prism) => prism.kind !== 'sill');
+            const head = frames.length ? Math.max(...frames.map((prism) => prism.z1)) : baseY + 2.1;
+            const sill = opening.type === 'door'
+                ? baseY
+                : glazed.length
+                    ? Math.min(...glazed.map((prism) => prism.z0))
+                    : baseY + opening.position[1] - (opening.height ?? 1.2) / 2;
+            for (const frame of roomSides(wall)) {
+                const label = quote(nameOf(nodes, opening.id));
+                const middle = point(frame, along, 0.4);
+                const room = roomAt(nodes, level.levelId, middle);
+                if (opening.type === 'window') {
+                    const zone = [
+                        point(frame, along - half, 0),
+                        point(frame, along + half, 0),
+                        point(frame, along + half, WINDOW_NEAR_M),
+                        point(frame, along - half, WINDOW_NEAR_M),
+                    ];
+                    const zoneBox = ringBox(zone);
+                    const envelopes = prisms.filter((prism) => prism.kind === 'treatment' && prism.nodeId === opening.id);
+                    for (const piece of pieces) {
+                        if (piece.z1 < sill + WINDOW_ABOVE_SILL_M || piece.z0 > head)
+                            continue;
+                        if (piece.host?.wallId === wall.id)
+                            continue;
+                        if (isSetAtWindow(itemText(nodes, piece.nodeId)))
+                            continue;
+                        // a bed head against a window is a design choice, not a finding
+                        if (isBed(nodes[piece.nodeId]))
+                            continue;
+                        if (!boxesMeet(pieceBoxes.get(piece), zoneBox))
+                            continue;
+                        const meet = intersection({ outer: piece.outer, holes: piece.holes }, zone);
+                        if (area(meet) < MIN_AREA_M2)
+                            continue;
+                        let nearest = Number.POSITIVE_INFINITY;
+                        let low = Number.POSITIVE_INFINITY;
+                        let high = Number.NEGATIVE_INFINITY;
+                        for (const part of meet)
+                            for (const [x, z] of part.outer) {
+                                const [sx, sz] = wall.start;
+                                nearest = Math.min(nearest, ((x - sx) * frame.nx + (z - sz) * frame.nz - frame.faceZ) * frame.sign);
+                                const u = (x - sx) * frame.tx + (z - sz) * frame.tz;
+                                low = Math.min(low, u);
+                                high = Math.max(high, u);
+                            }
+                        const cover = Math.max(0, Math.min(high, along + half) - Math.max(low, along - half)) / (2 * half);
+                        if (cover < WINDOW_COVER)
+                            continue;
+                        nearest = Math.max(0, nearest);
+                        const who = quote(nameOf(nodes, piece.nodeId));
+                        const tall = piece.z1 - sill >= WINDOW_ABOVE_SILL_M;
+                        const warning = tall && nearest <= WINDOW_BLOCK_M;
+                        // past a curtain's depth, a piece not hosted on the window still shuts it when it is a curtain or blind, or covers all of the glass (its width, and up to its head)
+                        const shuts = tall &&
+                            nearest > WINDOW_BLOCK_M &&
+                            (CURTAIN.test(itemText(nodes, piece.nodeId)) ||
+                                (cover >= 1 - TOLERANCE_M / (2 * half) && piece.z1 >= head - TOLERANCE_M));
+                        const deepIn = envelopes.reduce((deepest, envelope) => {
+                            if (Math.min(piece.z1, envelope.z1) - Math.max(piece.z0, envelope.z0) < 0.02)
+                                return deepest;
+                            const inside = intersection({ outer: piece.outer, holes: piece.holes }, { outer: envelope.outer, holes: envelope.holes });
+                            return area(inside) < MIN_AREA_M2
+                                ? deepest
+                                : Math.max(deepest, narrowestExtent(inside));
+                        }, 0);
+                        const inCurtains = deepIn >= ENVELOPE_M;
+                        const approximate = piece.shape === 'approx' ||
+                            (inCurtains && envelopes.some((e) => e.shape === 'approx'));
+                        keep(`${opening.id}|${frame.sign}|${piece.nodeId}`, {
+                            type: 'usage_opening_blocked',
+                            message: inCurtains
+                                ? `${who} stands ${cm(deepIn)} deep in the curtains or blinds of ${label}${room ? ` in ${quote(room.name)}` : ''} (the window is covered over ${Math.round(cover * 100)} % of its width).`
+                                : `${who} stands ${cm(nearest)} from the glass of ${label}${room ? ` in ${quote(room.name)}` : ''}, ${Math.round((piece.z1 - sill) * 100)} cm above its sill, over ${Math.round(cover * 100)} % of its width${shuts ? ', and is not hosted on the window' : ''}.`,
+                            severity: warning || shuts || inCurtains ? 'warning' : 'info',
+                            nodeIds: unique([room?.id, opening.id, piece.nodeId]),
+                            valueM: Math.round((inCurtains ? deepIn : nearest) * 1000) / 1000,
+                            thresholdM: inCurtains ? ENVELOPE_M : shuts ? WINDOW_NEAR_M : WINDOW_BLOCK_M,
+                            place: { room: room?.name ?? '', roomId: room?.id ?? level.levelId, at: middle },
+                            obstacles: [
+                                {
+                                    nodeId: piece.nodeId,
+                                    name: nameOf(nodes, piece.nodeId),
+                                    kind: piece.kind,
+                                    shape: piece.shape,
+                                    movable: false,
+                                },
+                            ],
+                            approximate,
+                        }, (warning || shuts || inCurtains ? 100 : 0) + (inCurtains ? deepIn : 1 - nearest));
+                    }
+                }
+            }
+        }
+    }
+    out.push(...[...worst.values()].map(({ issue }) => issue));
+    return out;
+}

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

@@ -0,0 +1,17 @@
+import type { Prism, Skipped } from './types.js';
+import type { Nodes } from './walls.js';
+export type NodePrisms = {
+    nodeId: string;
+    levelId: string | null;
+    prisms: Prism[];
+};
+/**
+ * Cabinets, shelves, columns, furniture and the like as the footprint boxes their `floorPlaced`
+ * capability declares, on the floor under them. Every one is approximate: a plinth, a handle, a
+ * round shaft or a mitred end is not in a box.
+ */
+export declare function boxBodies(nodes: Nodes): {
+    nodes: NodePrisms[];
+    skipped: Skipped[];
+};
+//# sourceMappingURL=boxes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boxes.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/boxes.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,KAAK,EAAmB,OAAO,EAAE,MAAM,SAAS,CAAA;AAC9D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAapC,MAAM,MAAM,UAAU,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,KAAK,EAAE,CAAA;CAAE,CAAA;AAKpF;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG;IAAE,KAAK,EAAE,UAAU,EAAE,CAAC;IAAC,OAAO,EAAE,OAAO,EAAE,CAAA;CAAE,CA+DnF"}

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

@@ -0,0 +1,82 @@
+import { floorPlacedOf } from '../../hooks/spatial-grid/built-in-floor-placed.js';
+import { getFloorPlacedFootprints } from '../../hooks/spatial-grid/floor-placed-footprints.js';
+import { resolveLevelId } from '../../lib/node-ancestry.js';
+import { getLevelElevations } from '../../services/storey.js';
+import { floorUnder, isHidden } from './support.js';
+/** The standing kinds read as the box the editor itself keeps them off each other by. */
+const BOX_KINDS = {
+    cabinet: 'cabinet',
+    'cabinet-module': 'cabinet',
+    shelf: 'shelf',
+    column: 'column',
+    block: 'other',
+    'hvac-equipment': 'other',
+    'procedural-item': 'other',
+};
+const yawOf = (rotation) => typeof rotation === 'number' ? rotation : Array.isArray(rotation) ? (rotation[1] ?? 0) : 0;
+/**
+ * Cabinets, shelves, columns, furniture and the like as the footprint boxes their `floorPlaced`
+ * capability declares, on the floor under them. Every one is approximate: a plinth, a handle, a
+ * round shaft or a mitred end is not in a box.
+ */
+export function boxBodies(nodes) {
+    const out = [];
+    const skipped = [];
+    const elevations = getLevelElevations(nodes);
+    const support = new Map();
+    for (const node of Object.values(nodes)) {
+        const kind = BOX_KINDS[node.type];
+        if (!kind || isHidden(node, nodes))
+            continue;
+        try {
+            const config = floorPlacedOf(node.type);
+            if (!config || (config.applies && !config.applies(node)))
+                continue;
+            const footprints = getFloorPlacedFootprints(config, node, { nodes });
+            if (footprints.length === 0)
+                continue;
+            const levelId = resolveLevelId(node, nodes);
+            const baseY = elevations.get(levelId)?.baseY ?? 0;
+            const first = footprints[0];
+            const origin = node.position ?? [0, 0, 0];
+            const floor = floorUnder(node, {
+                position: [first.position?.[0] ?? origin[0], 0, first.position?.[2] ?? origin[2]],
+                dimensions: first.dimensions,
+                rotation: first.rotation,
+            }, nodes, levelId, support);
+            const prisms = [];
+            for (const [index, footprint] of footprints.entries()) {
+                const [w, h, d] = footprint.dimensions;
+                if (!(h > 0) || !(w > 0) || !(d > 0))
+                    continue;
+                const at = footprint.position ?? origin;
+                const yaw = yawOf(footprint.rotation);
+                const cos = Math.cos(yaw);
+                const sin = Math.sin(yaw);
+                const ring = [
+                    [-w / 2, -d / 2],
+                    [w / 2, -d / 2],
+                    [w / 2, d / 2],
+                    [-w / 2, d / 2],
+                ].map(([x, z]) => [at[0] + x * cos + z * sin, at[2] - x * sin + z * cos]);
+                const z0 = baseY + floor + at[1];
+                prisms.push({
+                    id: `${node.id}#box${footprints.length > 1 ? `.${index}` : ''}`,
+                    nodeId: node.id,
+                    kind,
+                    z0,
+                    z1: z0 + h,
+                    outer: ring,
+                    holes: [],
+                    shape: 'approx',
+                    why: `a ${node.type} as its footprint box`,
+                });
+            }
+            out.push({ nodeId: node.id, levelId, prisms });
+        }
+        catch (error) {
+            skipped.push({ nodeId: node.id, why: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    return { nodes: out, skipped };
+}