@pascal-app/core 1.0.6 → 1.1.0

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

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

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