@pascal-app/core 1.0.6 → 1.0.7

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

@@ -0,0 +1,44 @@
+import { type Aabb, type Obstacle } from './obstacles.js';
+export type Grid = {
+    x0: number;
+    z0: number;
+    h: number;
+    W: number;
+    H: number;
+};
+export declare const cellX: (g: Grid, i: number) => number;
+export declare const cellZ: (g: Grid, j: number) => number;
+export declare const cellOf: (g: Grid, x: number, z: number) => number;
+export declare function makeGrid(domain: Aabb, h: number): Grid;
+/**
+ * A uniform bucket index over obstacle boxes. A query widens ring by ring around the point and
+ * stops when no farther bucket can hold a nearer obstacle, so the answer is exact.
+ */
+export declare class BucketIndex {
+    private readonly domain;
+    private readonly cell;
+    private readonly buckets;
+    private readonly stamp;
+    private pass;
+    private readonly nx;
+    private readonly nz;
+    constructor(obstacles: Obstacle[], domain: Aabb, cell?: number);
+    private range;
+    /** Signed distance to the nearest obstacle (negative inside) and which it is; `skipNode` leaves one node out. */
+    query(px: number, pz: number, skipNode?: string): {
+        d: number;
+        arg: number;
+    };
+}
+export type Baked = {
+    /** Signed distance to the nearest obstacle at every cell centre (negative inside one). */
+    F: Float32Array;
+    /** The nearest obstacle's index, -1 where there is none. */
+    A: Int32Array;
+};
+/**
+ * Bakes the clearance field in tiles: a tile tests only the obstacles that can still win in it
+ * (those within the tile's reach of the nearest one), which is exact, not an approximation.
+ */
+export declare function bakeGrid(g: Grid, obstacles: Obstacle[]): Baked;
+//# sourceMappingURL=field.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/field.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAoB,MAAM,aAAa,CAAA;AAExE,MAAM,MAAM,IAAI,GAAG;IACjB,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV,CAAA;AAED,eAAO,MAAM,KAAK,MAAO,IAAI,KAAK,MAAM,WAA2B,CAAA;AACnE,eAAO,MAAM,KAAK,MAAO,IAAI,KAAK,MAAM,WAA2B,CAAA;AACnE,eAAO,MAAM,MAAM,MAAO,IAAI,KAAK,MAAM,KAAK,MAAM,WAInD,CAAA;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAQtD;AAED;;;GAGG;AACH,qBAAa,WAAW;IASpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,IAAI;IATvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,IAAI,CAAI;IAChB,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAQ;IAC3B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAQ;IAE3B,YACE,SAAS,EAAE,QAAQ,EAAE,EACJ,MAAM,EAAE,IAAI,EACZ,IAAI,SAAM,EAW5B;IAED,OAAO,CAAC,KAAK;IAWb,iHAAiH;IACjH,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAoC3E;CACF;AAQD,MAAM,MAAM,KAAK,GAAG;IAClB,0FAA0F;IAC1F,CAAC,EAAE,YAAY,CAAA;IACf,4DAA4D;IAC5D,CAAC,EAAE,UAAU,CAAA;CACd,CAAA;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,KAAK,CA4C9D"}

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

@@ -0,0 +1,145 @@
+import { obstacleDistance } from './obstacles.js';
+export const cellX = (g, i) => g.x0 + (i + 0.5) * g.h;
+export const cellZ = (g, j) => g.z0 + (j + 0.5) * g.h;
+export const cellOf = (g, x, z) => {
+    const i = Math.floor((x - g.x0) / g.h);
+    const j = Math.floor((z - g.z0) / g.h);
+    return i < 0 || j < 0 || i >= g.W || j >= g.H ? -1 : j * g.W + i;
+};
+export function makeGrid(domain, h) {
+    return {
+        x0: domain[0],
+        z0: domain[1],
+        h,
+        W: Math.max(1, Math.round((domain[2] - domain[0]) / h)),
+        H: Math.max(1, Math.round((domain[3] - domain[1]) / h)),
+    };
+}
+/**
+ * A uniform bucket index over obstacle boxes. A query widens ring by ring around the point and
+ * stops when no farther bucket can hold a nearer obstacle, so the answer is exact.
+ */
+export class BucketIndex {
+    domain;
+    cell;
+    buckets;
+    stamp;
+    pass = 0;
+    nx;
+    nz;
+    constructor(obstacles, domain, cell = 0.5) {
+        this.domain = domain;
+        this.cell = cell;
+        this.nx = Math.max(1, Math.ceil((domain[2] - domain[0]) / cell));
+        this.nz = Math.max(1, Math.ceil((domain[3] - domain[1]) / cell));
+        this.buckets = Array.from({ length: this.nx * this.nz }, () => []);
+        this.stamp = new Uint32Array(obstacles.length);
+        for (const obstacle of obstacles) {
+            const [i0, j0, i1, j1] = this.range(obstacle.aabb);
+            for (let j = j0; j <= j1; j++)
+                for (let i = i0; i <= i1; i++)
+                    this.buckets[j * this.nx + i].push(obstacle);
+        }
+    }
+    range(a) {
+        const clamp = (v, n) => Math.max(0, Math.min(n - 1, v));
+        const c = this.cell;
+        return [
+            clamp(Math.floor((a[0] - this.domain[0]) / c), this.nx),
+            clamp(Math.floor((a[1] - this.domain[1]) / c), this.nz),
+            clamp(Math.floor((a[2] - this.domain[0]) / c), this.nx),
+            clamp(Math.floor((a[3] - this.domain[1]) / c), this.nz),
+        ];
+    }
+    /** Signed distance to the nearest obstacle (negative inside) and which it is; `skipNode` leaves one node out. */
+    query(px, pz, skipNode) {
+        let best = Number.POSITIVE_INFINITY;
+        let arg = -1;
+        const c = this.cell;
+        const bi = Math.max(0, Math.min(this.nx - 1, Math.floor((px - this.domain[0]) / c)));
+        const bj = Math.max(0, Math.min(this.nz - 1, Math.floor((pz - this.domain[1]) / c)));
+        const stamp = ++this.pass;
+        const reach = Math.max(this.nx, this.nz);
+        for (let r = 0; r <= reach; r++) {
+            for (let j = bj - r; j <= bj + r; j++) {
+                if (j < 0 || j >= this.nz)
+                    continue;
+                const edge = j === bj - r || j === bj + r;
+                for (let i = bi - r; i <= bi + r; i += edge ? 1 : 2 * r || 1) {
+                    if (i < 0 || i >= this.nx)
+                        continue;
+                    for (const obstacle of this.buckets[j * this.nx + i]) {
+                        if (this.stamp[obstacle.index] === stamp)
+                            continue;
+                        this.stamp[obstacle.index] = stamp;
+                        if (skipNode && obstacle.prism.nodeId === skipNode)
+                            continue;
+                        const v = obstacleDistance(obstacle, px, pz);
+                        if (v < best) {
+                            best = v;
+                            arg = obstacle.index;
+                        }
+                    }
+                }
+            }
+            // everything not seen yet lies wholly outside the block of buckets searched
+            const bound = Math.min(px - (this.domain[0] + (bi - r) * c), this.domain[0] + (bi + r + 1) * c - px, pz - (this.domain[1] + (bj - r) * c), this.domain[1] + (bj + r + 1) * c - pz);
+            if (best <= bound)
+                break;
+        }
+        return { d: best, arg };
+    }
+}
+const TILE = 16;
+function aabbDistance(x0, z0, x1, z1, a) {
+    return Math.hypot(Math.max(a[0] - x1, x0 - a[2], 0), Math.max(a[1] - z1, z0 - a[3], 0));
+}
+/**
+ * Bakes the clearance field in tiles: a tile tests only the obstacles that can still win in it
+ * (those within the tile's reach of the nearest one), which is exact, not an approximation.
+ */
+export function bakeGrid(g, obstacles) {
+    const F = new Float32Array(g.W * g.H).fill(Number.POSITIVE_INFINITY);
+    const A = new Int32Array(g.W * g.H).fill(-1);
+    if (obstacles.length === 0)
+        return { F, A };
+    const TW = Math.ceil(g.W / TILE);
+    const TH = Math.ceil(g.H / TILE);
+    for (let tj = 0; tj < TH; tj++)
+        for (let ti = 0; ti < TW; ti++) {
+            const i0 = ti * TILE;
+            const j0 = tj * TILE;
+            const i1 = Math.min(g.W, i0 + TILE) - 1;
+            const j1 = Math.min(g.H, j0 + TILE) - 1;
+            const x0 = cellX(g, i0);
+            const z0 = cellZ(g, j0);
+            const x1 = cellX(g, i1);
+            const z1 = cellZ(g, j1);
+            const mx = (x0 + x1) / 2;
+            const mz = (z0 + z1) / 2;
+            const radius = Math.hypot(x1 - x0, z1 - z0) / 2;
+            let bound = Number.POSITIVE_INFINITY;
+            for (const o of obstacles)
+                bound = Math.min(bound, obstacleDistance(o, mx, mz));
+            bound += radius;
+            const candidates = obstacles.filter((o) => aabbDistance(x0, z0, x1, z1, o.aabb) <= Math.max(bound, 0));
+            for (let j = j0; j <= j1; j++) {
+                const pz = cellZ(g, j);
+                for (let i = i0; i <= i1; i++) {
+                    const px = cellX(g, i);
+                    let best = Number.POSITIVE_INFINITY;
+                    let arg = -1;
+                    for (const o of candidates) {
+                        const v = obstacleDistance(o, px, pz);
+                        if (v < best) {
+                            best = v;
+                            arg = o.index;
+                        }
+                    }
+                    F[j * g.W + i] = best;
+                    A[j * g.W + i] = arg;
+                }
+            }
+        }
+    return { F, A };
+}

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

@@ -0,0 +1,76 @@
+import { type CodeProfileId, type ThresholdSource } from '../../building/code-profile.js';
+import { type MeasureOptions } from './measure.js';
+import type { Nodes } from './walls.js';
+/** Clear width of a path in a house: 0,90 m, the arrêté du 24 décembre 2015 art. 11 II (36 in is the IRC hall). */
+export declare const PASSAGE_M: 0.9;
+/** Clear width through an interior door: 32 in; the same arrêté art. 11 II asks 0,80 m nominal and 0,77 m clear. */
+export declare const DOOR_M: 0.8;
+/** Wheelchair turning space: 1.50 m (arrêté du 24 décembre 2015 art. 13; ADA 304.3). */
+export declare const TURNING_M: 1.5;
+/** One unit of passage: 0.60 m (a clearance of 0.30 m); a pocket smaller than this is not worth a finding. */
+export declare const POCKET_MIN_M2 = 0.36;
+/** A reading within this of its threshold is the threshold. */
+export declare const TOLERANCE_M = 0.005;
+/** Rooms whose passages are the same pinch: the same things bound it, a figure within this, a spot within `PLACE_AT_M`. */
+export declare const PLACE_WIDTH_M = 0.005;
+export type UsageObstacle = {
+    nodeId: string;
+    name: string;
+    kind: string;
+    shape: 'exact' | 'approx';
+    movable: boolean;
+};
+export type UsageIssue = {
+    type: 'usage_passage_narrow' | 'usage_turning_narrow' | 'usage_pocket' | 'usage_clash' | 'usage_opening_blocked' | 'usage_door_swing' | 'usage_entry_narrow' | 'usage_door_over_stair' | 'usage_fixture_clearance' | 'usage_bed_clearance';
+    message: string;
+    /** Use defects warn even on approximate shapes; measurements and unassigned code checks inform. */
+    severity: 'warning' | 'info';
+    nodeIds: string[];
+    valueM?: number;
+    valueM2?: number;
+    thresholdM?: number;
+    /** A door's free swing, and the 90 degrees it should have. */
+    valueDeg?: number;
+    thresholdDeg?: number;
+    /** For a finding that applies a code: which one, the section, whether its text was read, and whether the project named it or it is the default US IRC applied to a project that names none. */
+    code?: {
+        profile: CodeProfileId;
+        cite: string;
+        source: ThresholdSource;
+        byDefault: boolean;
+    };
+    place: {
+        room: string;
+        roomId: string;
+        at: [number, number];
+    };
+    obstacles: UsageObstacle[];
+    fromDoorId?: string;
+    /** A passage: every room the way through this place leads to, each with the best other exterior door when that reaches it more widely. */
+    serves?: {
+        room: string;
+        roomId: string;
+        alternative?: {
+            doorId: string;
+            widthM: number;
+        };
+    }[];
+    /** A doorway between its jambs: the door as drawn, where `valueM` is the clear width between the jambs. */
+    doorWidthM?: number;
+    /** The name of the door a passage was measured from (the ground floor's entrance), when there is one. */
+    fromDoor?: string;
+    /** What the model's answer says of the finding when the note carries the rest: a room entry's clause for a turning circle and a pocket, a passage's sentence without the entrance (`verify-scene-usage`). */
+    brief?: string;
+    /** A pocket that is the whole room's free floor: the room cannot be left by a 0.60 m unit at all. */
+    wholeRoom?: boolean;
+    approximate: boolean;
+};
+/**
+ * The usage findings of a scene: narrow passages (measured from the chosen entrance, one for each
+ * place that is narrow with the rooms it leads to, and the best other door as a fact), missing turning circles, floor a 0.60 m unit cannot get out of, wall
+ * objects that stand out into circulation, pieces inside something solid, what stands in front of a
+ * window or a door, a bed's room, a room's headroom and its ceiling. Every threshold is an indicator,
+ * not a compliance check.
+ */
+export declare function usageIssues(nodes: Nodes, options?: MeasureOptions): UsageIssue[];
+//# sourceMappingURL=findings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"findings.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/findings.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,eAAe,EAErB,MAAM,6BAA6B,CAAA;AASpC,OAAO,EACL,KAAK,cAAc,EAKpB,MAAM,WAAW,CAAA;AAGlB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC,mHAAmH;AACnH,eAAO,MAAM,SAAS,KAAiC,CAAA;AACvD,oHAAoH;AACpH,eAAO,MAAM,MAAM,KAAmC,CAAA;AACtD,wFAAwF;AACxF,eAAO,MAAM,SAAS,KAAiC,CAAA;AACvD,8GAA8G;AAC9G,eAAO,MAAM,aAAa,OAAO,CAAA;AACjC,+DAA+D;AAC/D,eAAO,MAAM,WAAW,QAAQ,CAAA;AAChC,2HAA2H;AAC3H,eAAO,MAAM,aAAa,QAAQ,CAAA;AAGlC,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,OAAO,GAAG,QAAQ,CAAA;IACzB,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EACA,sBAAsB,GACtB,sBAAsB,GACtB,cAAc,GACd,aAAa,GACb,uBAAuB,GACvB,kBAAkB,GAClB,oBAAoB,GACpB,uBAAuB,GACvB,yBAAyB,GACzB,qBAAqB,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,mGAAmG;IACnG,QAAQ,EAAE,SAAS,GAAG,MAAM,CAAA;IAC5B,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,+LAA+L;IAC/L,IAAI,CAAC,EAAE;QAAE,OAAO,EAAE,aAAa,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,eAAe,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,CAAA;IAC5F,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAA;IAC7D,SAAS,EAAE,aAAa,EAAE,CAAA;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,0IAA0I;IAC1I,MAAM,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,EAAE,CAAA;IAC7F,2GAA2G;IAC3G,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,yGAAyG;IACzG,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,6MAA6M;IAC7M,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,qGAAqG;IACrG,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,WAAW,EAAE,OAAO,CAAA;CACrB,CAAA;AAuND;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,GAAE,cAAmB,GAAG,UAAU,EAAE,CAiDpF"}

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

@@ -0,0 +1,252 @@
+import { USAGE_INDICATORS, } from '../../building/code-profile.js';
+import { bedIssues } from './beds.js';
+import { blockedOpeningIssues } from './blocked.js';
+import { clashIssues } from './clash.js';
+import { doorOverStairIssues } from './door-stairs.js';
+import { entryIssues } from './entry-way.js';
+import { fixtureClearanceIssues } from './fixtures.js';
+import { m, nameOf, quote, unique } from './labels.js';
+import { measureUsage, } from './measure.js';
+import { usageShapes } from './shapes.js';
+import { doorSwingIssues } from './swings.js';
+/** Clear width of a path in a house: 0,90 m, the arrêté du 24 décembre 2015 art. 11 II (36 in is the IRC hall). */
+export const PASSAGE_M = USAGE_INDICATORS.passage.value;
+/** Clear width through an interior door: 32 in; the same arrêté art. 11 II asks 0,80 m nominal and 0,77 m clear. */
+export const DOOR_M = USAGE_INDICATORS.doorClear.value;
+/** Wheelchair turning space: 1.50 m (arrêté du 24 décembre 2015 art. 13; ADA 304.3). */
+export const TURNING_M = USAGE_INDICATORS.turning.value;
+/** One unit of passage: 0.60 m (a clearance of 0.30 m); a pocket smaller than this is not worth a finding. */
+export const POCKET_MIN_M2 = 0.36;
+/** A reading within this of its threshold is the threshold. */
+export const TOLERANCE_M = 0.005;
+/** Rooms whose passages are the same pinch: the same things bound it, a figure within this, a spot within `PLACE_AT_M`. */
+export const PLACE_WIDTH_M = 0.005;
+const PLACE_AT_M = 0.5;
+const MOVABLE = /chair|stool|bedside|night ?stand|ottoman|pouf/i;
+function describe(nodes, refs) {
+    return refs.map((ref) => {
+        const node = nodes[ref.nodeId];
+        const label = ref.kind === 'void'
+            ? 'stairwell opening'
+            : ref.kind === 'stair-rail'
+                ? `${nameOf(nodes, ref.nodeId)} railing`
+                : nameOf(nodes, ref.nodeId);
+        return {
+            nodeId: ref.nodeId,
+            name: label,
+            kind: ref.kind,
+            shape: ref.shape,
+            movable: node?.type === 'item' &&
+                MOVABLE.test(`${node.asset.id} ${node.asset.name}`),
+        };
+    });
+}
+/** The things a finding names, once each: the two parts of one door frame are that door, not two things. */
+const distinctOf = (items) => items.filter((item, at) => items.findIndex((o) => o.nodeId === item.nodeId) === at);
+/** The door whose two frame members are the pinch: it is passed through, not against. */
+const framedBy = (items) => {
+    const distinct = distinctOf(items);
+    return distinct.length === 1 && items.length >= 2 && distinct[0].kind === 'jamb'
+        ? distinct[0]
+        : null;
+};
+function between(items) {
+    const distinct = distinctOf(items);
+    if (distinct.length >= 2)
+        return ` between ${quote(distinct[0].name)} and ${quote(distinct[1].name)}`;
+    if (distinct.length === 1)
+        return ` against ${quote(distinct[0].name)}`;
+    return '';
+}
+const beside = (items) => {
+    const distinct = distinctOf(items);
+    return distinct.length ? `, beside ${distinct.map((item) => quote(item.name)).join(' and ')}` : '';
+};
+const listOf = (names) => names.length < 2
+    ? (names[0] ?? '')
+    : `${names.slice(0, -1).join(', ')} and ${names[names.length - 1]}`;
+/** The room's narrow passage, with what bounds it and the limit it is read against; null when it is not narrow. */
+function narrowPassage(nodes, room) {
+    const passage = room.passage;
+    if (!passage)
+        return null;
+    const sides = describe(nodes, passage.by);
+    // a pinch between two door-frame members is a doorway, and a doorway needs 0.80 m, not 0.90 m
+    const doorway = passage.by.some((o) => o.kind === 'jamb');
+    const limit = doorway ? DOOR_M : PASSAGE_M;
+    return passage.width < limit - TOLERANCE_M ? { room, passage, sides, limit, doorway } : null;
+}
+const sameStuff = (a, b) => {
+    const ids = (items) => [...new Set(items.map((o) => o.nodeId))].sort().join('|');
+    return ids(a) === ids(b);
+};
+/**
+ * One finding for each place a way is narrow, however many rooms it leads to: the rooms whose
+ * narrowest point is the same pinch (the same things bound it, the same width, the same spot) are
+ * its `serves`, each with the best other exterior door when that reaches it more widely.
+ */
+function passageIssues(nodes, rooms) {
+    const places = [];
+    for (const room of rooms) {
+        const narrow = narrowPassage(nodes, room);
+        if (!narrow)
+            continue;
+        const place = places.find(([first]) => {
+            const a = first.passage;
+            const b = narrow.passage;
+            return (sameStuff(first.sides, narrow.sides) &&
+                Math.abs(a.width - b.width) <= PLACE_WIDTH_M &&
+                Math.hypot(a.at[0] - b.at[0], a.at[1] - b.at[1]) <= PLACE_AT_M);
+        });
+        if (place)
+            place.push(narrow);
+        else
+            places.push([narrow]);
+    }
+    return places.map((members) => passageIssue(nodes, members));
+}
+function passageIssue(nodes, members) {
+    const narrowest = members.reduce((best, n) => (n.passage.width < best.passage.width ? n : best));
+    const { passage, sides, limit, doorway } = narrowest;
+    const door = passage.fromDoorId ? nameOf(nodes, passage.fromDoorId) : null;
+    const approximate = passage.by.some((o) => o.shape === 'approx');
+    const target = (room) => room.kind === 'stair-foot'
+        ? `the foot of ${quote(room.name.replace(/^Foot of /, ''))}`
+        : quote(room.name);
+    // the best other exterior door, said once when it is the same for every room and by room when it is not
+    const first = members[0].room.alternative;
+    const shared = first &&
+        members.every(({ room }) => room.alternative?.doorId === first.doorId && room.alternative.width === first.width)
+        ? first
+        : null;
+    const alternativeOf = (alternative) => `${m(alternative.width)} m from ${quote(nameOf(nodes, alternative.doorId))}`;
+    const targets = listOf(members.map(({ room }) => !shared && room.alternative
+        ? `${target(room)} (${alternativeOf(room.alternative)})`
+        : target(room)));
+    // a doorway is read between its jambs; the door as drawn is said beside it
+    const frame = framedBy(sides);
+    const drawn = frame ? nodes[frame.nodeId]?.width : undefined;
+    const clause = `${frame
+        ? `${m(passage.width)} m clear between the jambs of ${quote(frame.name)}${typeof drawn === 'number' ? `, a ${m(drawn)} m door` : ''}`
+        : `${m(passage.width)} m${between(sides)}`}${shared ? `; ${alternativeOf(shared)}` : ''}`;
+    const sentence = `${targets}: ${clause}`;
+    // a leaf drawn at least the doorway's 0.80 m is a standard door: what it leaves is information
+    const standardLeaf = typeof drawn === 'number' && drawn >= DOOR_M - TOLERANCE_M ? drawn : null;
+    const tail = standardLeaf === null
+        ? ` (below ${m(limit)} m${doorway ? ', a doorway' : ''}).`
+        : ` (a ${m(standardLeaf)} m door leaf: the frame leaves ${m(passage.width)} m clear).`;
+    const lead = members[0].room;
+    return {
+        type: 'usage_passage_narrow',
+        message: `Narrow passage to ${sentence}${door ? `, measured from ${quote(door)}` : ''}${tail}`,
+        brief: `Passage to ${sentence}${tail}`,
+        ...(door ? { fromDoor: door } : {}),
+        severity: standardLeaf === null ? 'warning' : 'info',
+        nodeIds: unique([
+            ...members.map(({ room }) => (room.roomId.startsWith('zone_') ? room.roomId : undefined)),
+            ...sides.map((s) => s.nodeId),
+        ]),
+        valueM: passage.width,
+        thresholdM: limit,
+        ...(typeof drawn === 'number' ? { doorWidthM: drawn } : {}),
+        place: { room: lead.name, roomId: lead.roomId, at: passage.at },
+        obstacles: sides,
+        ...(passage.fromDoorId ? { fromDoorId: passage.fromDoorId } : {}),
+        serves: members.map(({ room }) => ({
+            room: room.name,
+            roomId: room.roomId,
+            ...(room.alternative
+                ? { alternative: { doorId: room.alternative.doorId, widthM: room.alternative.width } }
+                : {}),
+        })),
+        approximate,
+    };
+}
+function turningIssue(room) {
+    const turning = room.turning;
+    if (!turning || !(turning.diameter < TURNING_M - TOLERANCE_M))
+        return null;
+    return {
+        type: 'usage_turning_narrow',
+        message: `No ${m(TURNING_M)} m turning circle in ${quote(room.name)}: largest ${m(turning.diameter)} m.`,
+        brief: `no ${m(TURNING_M)} m turning circle, largest ${m(turning.diameter)} m`,
+        // A turning circle measures the room, not a defect of a piece: it informs, exact outline or not.
+        severity: 'info',
+        nodeIds: [room.roomId],
+        valueM: turning.diameter,
+        thresholdM: TURNING_M,
+        place: { room: room.name, roomId: room.roomId, at: turning.at },
+        obstacles: [],
+        approximate: turning.approximate,
+    };
+}
+function pocketIssue(nodes, room, from) {
+    const pocket = room.pocket;
+    if (!(pocket.isolatedM2 >= POCKET_MIN_M2) || !pocket.at)
+        return null;
+    const around = describe(nodes, pocket.by);
+    const approximate = pocket.by.some((o) => o.shape === 'approx');
+    const brief = pocket.whole
+        ? `no 0.60 m way out from ${from} (${m(pocket.isolatedM2)} m²)`
+        : `${m(pocket.isolatedM2)} m² of floor with no 0.60 m way out${beside(around)}`;
+    return {
+        type: 'usage_pocket',
+        message: `${quote(room.name)}: ${brief}.`,
+        brief,
+        ...(pocket.whole ? { wholeRoom: true } : {}),
+        severity: 'warning',
+        nodeIds: unique([room.roomId, ...around.map((o) => o.nodeId)]),
+        valueM2: pocket.isolatedM2,
+        place: { room: room.name, roomId: room.roomId, at: pocket.at },
+        obstacles: around,
+        approximate,
+    };
+}
+/**
+ * The usage findings of a scene: narrow passages (measured from the chosen entrance, one for each
+ * place that is narrow with the rooms it leads to, and the best other door as a fact), missing turning circles, floor a 0.60 m unit cannot get out of, wall
+ * objects that stand out into circulation, pieces inside something solid, what stands in front of a
+ * window or a door, a bed's room, a room's headroom and its ceiling. Every threshold is an indicator,
+ * not a compliance check.
+ */
+export function usageIssues(nodes, options = {}) {
+    const shapes = usageShapes(nodes);
+    const measure = measureUsage(nodes, shapes, options);
+    const issues = [];
+    for (const group of measure.groups) {
+        const from = group.source.kind === 'door' ? 'the entrance' : 'the stair arrival';
+        const rooms = group.rooms;
+        const stuck = rooms.filter((room) => room.kind === 'room' && room.pocket.freeM2 > 0);
+        // a whole floor cut off from where it is entered is one finding, not one per room
+        const wholeFloor = stuck.length > 1 && stuck.every((room) => room.pocket.whole) && group.source.kind !== 'none';
+        if (wholeFloor) {
+            const level = nodes[group.levelId];
+            const area = stuck.reduce((sum, room) => sum + room.pocket.isolatedM2, 0);
+            issues.push({
+                type: 'usage_pocket',
+                message: `${quote(String(level?.name ?? `Level ${level?.level ?? ''}`))}: no 0.60 m way out from ${from} (${m(area)} m²).`,
+                brief: `no 0.60 m way out from ${from} (${m(area)} m²)`,
+                wholeRoom: true,
+                severity: 'warning',
+                nodeIds: unique([group.levelId, ...stuck.map((room) => room.roomId)]),
+                valueM2: Math.round(area * 1000) / 1000,
+                place: { room: String(level?.name ?? 'Level'), roomId: group.levelId, at: stuck[0].at },
+                obstacles: [],
+                approximate: false,
+            });
+        }
+        issues.push(...passageIssues(nodes, rooms));
+        for (const room of rooms) {
+            const turning = turningIssue(room);
+            if (turning)
+                issues.push(turning);
+            if (!wholeFloor) {
+                const pocket = pocketIssue(nodes, room, from);
+                if (pocket)
+                    issues.push(pocket);
+            }
+        }
+    }
+    issues.push(...clashIssues(nodes, shapes), ...blockedOpeningIssues(nodes, shapes), ...doorSwingIssues(nodes, shapes), ...entryIssues(nodes, shapes), ...doorOverStairIssues(nodes, shapes), ...fixtureClearanceIssues(nodes, shapes), ...bedIssues(nodes, shapes));
+    return issues;
+}

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

@@ -0,0 +1,18 @@
+import type { UsageIssue } from './findings.js';
+import type { UsageShapes } from './types.js';
+import type { Nodes } from './walls.js';
+/**
+ * Bathroom fixture clearances: a toilet's centre to the nearest obstruction on each side and its clear
+ * space in front, a lavatory's front (and, for a single basin, its side), a shower's clear space at its
+ * best open side. Read on the exact outlines of the feet band. The fixture's front is its +Z, checked
+ * against the wall behind it (a fixture whose back is free and whose +Z meets a wall is read the other
+ * way round); a shower has no opening side in the model, so the best of its four sides is read, which is
+ * as good as the opening can be.
+ *
+ * These are a code's numbers. With no `site.metadata.codeProfile` the scene has no jurisdiction, and a
+ * finding is information that names the US IRC it used; with `irc-2021` set it is a warning. A profile
+ * with no row for it (the Australian NCC, France hold none of the bathroom figures) reports nothing.
+ * Approximate fixture outlines remain labeled as such without downgrading a clearance defect.
+ */
+export declare function fixtureClearanceIssues(nodes: Nodes, shapes: UsageShapes): UsageIssue[];
+//# sourceMappingURL=fixtures.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/fixtures.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAI5C,OAAO,KAAK,EAAS,WAAW,EAAE,MAAM,SAAS,CAAA;AACjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AA6BpC;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,GAAG,UAAU,EAAE,CAiItF"}