@pascal-app/core 1.0.6 → 1.1.0

package/dist/services/roof-move.js

@@ -1,5 +1,6 @@
 import { applySceneChanges } from '../agent-operations/apply-changes.js';
 import { getLevelDisplayName } from '../lib/level-name.js';
+import { queryNodes } from '../runtime/node-queries.js';
 import { getActiveRoofHeight, parseNode, } from '../schema/index.js';
 import { resolveRoofElevation, roofWallTop } from '../systems/roof/roof-elevation.js';
 import { segmentBearing } from './roof-bearing.js';
@@ -152,12 +153,12 @@ function levelsBetween(elevations, storeyId, levelId) {
  * between, or whose level stands over another storey or other levels now, is left where it is.
  */
 export function roofsKeptOverStorey(before, after) {
-    const was = getLevelElevations(before);
-    const now = getLevelElevations(after);
-    const rise = (elevations, levelId, storeyId) => (elevations.get(levelId)?.baseY ?? 0) - (elevations.get(storeyId)?.baseY ?? 0);
+    // Read only once a roof stands over a storey: elevations read every level of the scene.
+    let elevations;
+    const rise = (of, levelId, storeyId) => (of.get(levelId)?.baseY ?? 0) - (of.get(storeyId)?.baseY ?? 0);
     const updates = [];
-    for (const roof of Object.values(after)) {
-        if (roof.type !== 'roof' || roof.support?.kind !== 'level' || !roof.parentId)
+    for (const roof of queryNodes(after, { type: 'roof' })) {
+        if (roof.support?.kind !== 'level' || !roof.parentId)
             continue;
         const prior = before[roof.id];
         if (prior?.type !== 'roof' ||
@@ -167,6 +168,11 @@ export function roofsKeptOverStorey(before, after) {
         const storeyId = coveredStoreyId(after, roof);
         if (!storeyId || storeyId === roof.parentId || coveredStoreyId(before, prior) !== storeyId)
             continue;
+        elevations ??= {
+            was: getLevelElevations(before),
+            now: getLevelElevations(after),
+        };
+        const { was, now } = elevations;
         // A level put in, taken out or reordered between them: the roof moves with its level (#1039).
         const between = levelsBetween(now, storeyId, roof.parentId);
         if (between !== levelsBetween(was, storeyId, roof.parentId))
@@ -215,8 +221,8 @@ function touched(before, after, roof) {
  */
 export function planRoofSeats(before, after) {
     const byStorey = new Map();
-    for (const node of Object.values(after)) {
-        if (node.type !== 'roof' || !node.parentId)
+    for (const node of queryNodes(after, { type: 'roof' })) {
+        if (!node.parentId)
             continue;
         if (!(touched(before, after, node) && isRoofOnStoreyWalls(after, node.id)))
             continue;

package/dist/services/storey.d.ts

@@ -119,7 +119,12 @@ export declare function getCoveringSlabUndersideAt(levelId: string, nodes: Recor
  * {@link DEFAULT_LEVEL_HEIGHT} when `levelId` doesn't resolve to a level.
  */
 export declare function getWallPlaneTop(wall: Pick<WallNode, 'start' | 'end'> & Partial<Pick<WallNode, 'thickness' | 'curveOffset'>>, levelId: string, nodes: Record<AnyNodeId, AnyNode>): number;
-export declare function getWallTop(wall: WallNode, levelId: string, nodes: Record<AnyNodeId, AnyNode>, electedBase: number): number;
+export declare function getWallTop(wall: WallNode, levelId: string, nodes: Record<AnyNodeId, AnyNode>, electedBase: number, t: number): number;
+/**
+ * The lowest point of {@link getWallTop} over arc-length stations `[left, right]`. A sloped top is
+ * linear along the chord (the frame the viewer slopes the extrusion in), so it is lowest at one end.
+ */
+export declare function getWallTopOver(wall: WallNode, levelId: string, nodes: Record<AnyNodeId, AnyNode>, electedBase: number, left: number, right: number): number;
 export declare function getWallCoveringSlabUnderside(wall: Pick<WallNode, 'start' | 'end'> & Partial<Pick<WallNode, 'thickness' | 'curveOffset'>>, levelId: string, nodes: Record<AnyNodeId, AnyNode>): number | null;
 export declare function getWallCoveringSlabs(wall: Pick<WallNode, 'start' | 'end'> & Partial<Pick<WallNode, 'thickness' | 'curveOffset'>>, levelId: string, nodes: Record<AnyNodeId, AnyNode>): Array<{
     slab: SlabNode;

package/dist/services/storey.d.ts.map

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

package/dist/services/storey.js

@@ -1,8 +1,10 @@
 import { footprintLift } from '../lib/floor-foundation-datum.js';
-import { levelConstructionDisplacements } from '../lib/floor-foundation-stack.js';
+import { levelConstructionDisplacements, upperStoreyFootprints, } from '../lib/floor-foundation-stack.js';
 import { area, intersection } from '../lib/polygon-boolean.js';
 import { isSiteFlatwork } from '../lib/site-flatwork.js';
+import { queryNodes } from '../runtime/node-queries.js';
 import { pointInPolygon, pointOnPolygonBoundary, wallOverlapsSlabFootprint, } from '../systems/slab/slab-support.js';
+import { getWallChordFractionAt } from '../systems/wall/wall-curve.js';
 import { resolveWallTop } from '../systems/wall/wall-top.js';
 import { DEFAULT_LEVEL_HEIGHT } from './level-height.js';
 /**
@@ -51,7 +53,7 @@ export function getLevelElevations(nodes) {
     if (hit)
         return hit;
     const elevations = new Map(getAuthoredLevelElevations(nodes));
-    if (Object.values(nodes).some((node) => node.type === 'slab' && node.plateRole === 'base'))
+    if (queryNodes(nodes, { type: 'slab' }).some((node) => node.type === 'slab' && node.plateRole === 'base'))
         for (const [id, lift] of levelConstructionDisplacements(nodes)) {
             const entry = elevations.get(id);
             if (lift)
@@ -64,12 +66,9 @@ export function getAuthoredLevelElevations(nodes) {
     const memoized = authoredElevationMemo.get(nodes);
     if (memoized)
         return memoized;
-    const buildings = Object.values(nodes).filter((node) => node?.type === 'building');
+    const buildings = queryNodes(nodes, { type: 'building' });
     const entries = [];
-    for (const node of Object.values(nodes)) {
-        if (node?.type !== 'level')
-            continue;
-        const level = node;
+    for (const level of queryNodes(nodes, { type: 'level' })) {
         entries.push({
             levelId: level.id,
             baseElevation: level.baseElevation ?? 0,
@@ -325,13 +324,20 @@ function resolveCoveringSlabContext(levelId, nodes) {
         : []);
     const authoredHeight = resolveLevelFloorToFloorHeight(levelId, getAuthoredLevelElevations(nodes)) ??
         getStoredLevelHeight(level);
+    // A plate carrying the storey above rises to that storey's floor: when a
+    // neighbouring plate's foundation lifted the storey, this plate's walls grow
+    // taller to meet it instead of stopping short. A plate with nothing above
+    // keeps its own storey height.
+    const carriesStoreyAbove = new Set((aboveId ? (upperStoreyFootprints(nodes).get(aboveId) ?? []) : []).map((base) => base.id));
     const context = {
         floorToFloorHeight,
         planeHeight: authoredHeight,
         slabs,
         footprintPlanes: footprints.map(({ slab, lift }) => ({
             slab,
-            top: authoredHeight + lift,
+            top: carriesStoreyAbove.has(slab.id)
+                ? Math.max(authoredHeight + lift, floorToFloorHeight)
+                : authoredHeight + lift,
         })),
     };
     memo.set(levelId, { sources, context });
@@ -422,10 +428,18 @@ export function getCoveringSlabUndersideAt(levelId, nodes, x, z) {
 export function getWallPlaneTop(wall, levelId, nodes) {
     return wallPlaneTop(wall, resolveCoveringSlabContext(levelId, nodes));
 }
-export function getWallTop(wall, levelId, nodes, electedBase) {
+export function getWallTop(wall, levelId, nodes, electedBase, t) {
     const level = nodes[levelId];
     const authoredStoreyHeight = level?.type === 'level' ? (level.height ?? null) : null;
-    return resolveWallTop(wall, getWallPlaneTop(wall, levelId, nodes), electedBase, authoredStoreyHeight);
+    return resolveWallTop(wall, getWallPlaneTop(wall, levelId, nodes), electedBase, authoredStoreyHeight, t);
+}
+/**
+ * The lowest point of {@link getWallTop} over arc-length stations `[left, right]`. A sloped top is
+ * linear along the chord (the frame the viewer slopes the extrusion in), so it is lowest at one end.
+ */
+export function getWallTopOver(wall, levelId, nodes, electedBase, left, right) {
+    const at = (station) => getWallTop(wall, levelId, nodes, electedBase, getWallChordFractionAt(wall, station));
+    return Math.min(at(left), at(right));
 }
 export function getWallCoveringSlabUnderside(wall, levelId, nodes) {
     const undersides = getWallCoveringSlabs(wall, levelId, nodes).map(({ underside }) => underside);

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

@@ -0,0 +1,51 @@
+import type { UsageIssue } from './findings.js';
+import type { Prism, UsageShapes } from './types.js';
+import type { Nodes } from './walls.js';
+export type BedClass = 'single' | 'double' | 'queen' | 'king';
+/** 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 declare const BED_CLASS_FROM_M: [BedClass, number][];
+/** 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 declare 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 declare const BED_ROOM_SHORT_M: Partial<Record<BedClass, number>>;
+export type BedMeasure = {
+    id: string;
+    name: string;
+    levelId: string;
+    room: {
+        id: string;
+        name: string;
+    } | null;
+    widthM: number;
+    lengthM: number;
+    sizeClass: BedClass;
+    /** Free space beside the bed (median over the foot-ward three quarters of its sides) and at its foot, m. */
+    left: number;
+    right: number;
+    foot: number;
+    roomShortSideM: number | null;
+    at: [number, number];
+};
+export declare const bedClassOf: (width: number) => BedClass;
+/** 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 declare function measureBedPrisms(nodes: Nodes, levelId: string, bed: {
+    id: string;
+    name: string;
+}, own: Prism[], prisms: Prism[]): BedMeasure | null;
+/** What leaves a bed tight: the foot under 0.60 m, no side at 0.60 m, a king with one. */
+export declare function bedTightness(bed: BedMeasure): string[];
+/** 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 declare function measureBeds(nodes: Nodes, shapes: UsageShapes): BedMeasure[];
+/**
+ * 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 declare function bedIssues(nodes: Nodes, shapes: UsageShapes): UsageIssue[];
+/**
+ * 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 declare function bedFit(nodes: Nodes, shapes: UsageShapes, zoneId: string): BedClass | null;
+//# sourceMappingURL=beds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"beds.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/beds.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAI5C,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAA;AAC7D,8IAA8I;AAC9I,eAAO,MAAM,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,EAKhD,CAAA;AAQD,sJAAsJ;AACtJ,eAAO,MAAM,YAAY,MAAM,CAAA;AAC/B,qJAAqJ;AACrJ,eAAO,MAAM,gBAAgB,EAAE,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAA6B,CAAA;AAK5F,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IACzC,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,QAAQ,CAAA;IACnB,4GAA4G;IAC5G,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACrB,CAAA;AAED,eAAO,MAAM,UAAU,UAAW,MAAM,KAAG,QACa,CAAA;AA2FxD,oJAAoJ;AACpJ,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EACf,GAAG,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EACjC,GAAG,EAAE,KAAK,EAAE,EACZ,MAAM,EAAE,KAAK,EAAE,GACd,UAAU,GAAG,IAAI,CAqGnB;AAED,0FAA0F;AAC1F,wBAAgB,YAAY,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,EAAE,CAStD;AAED,4HAA4H;AAC5H,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,GAAG,UAAU,EAAE,CAqB3E;AAiBD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,GAAG,UAAU,EAAE,CAiCzE;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAkEzF"}

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