@pascal-app/core 1.0.5 → 1.0.7

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

@@ -0,0 +1,354 @@
+import { cellOf, cellX, cellZ } from './field.js';
+/** A binary min-heap on a numeric key. */
+class Heap {
+    keys = [];
+    values = [];
+    get size() {
+        return this.keys.length;
+    }
+    push(key, value) {
+        const keys = this.keys;
+        const values = this.values;
+        let i = keys.length;
+        keys.push(key);
+        values.push(value);
+        while (i > 0) {
+            const parent = (i - 1) >> 1;
+            if (keys[i] >= keys[parent])
+                break;
+            [keys[i], keys[parent]] = [keys[parent], keys[i]];
+            [values[i], values[parent]] = [values[parent], values[i]];
+            i = parent;
+        }
+    }
+    pop() {
+        const keys = this.keys;
+        const values = this.values;
+        const top = [keys[0], values[0]];
+        const lastKey = keys.pop();
+        const lastValue = values.pop();
+        if (keys.length) {
+            keys[0] = lastKey;
+            values[0] = lastValue;
+            let i = 0;
+            for (;;) {
+                const l = 2 * i + 1;
+                const r = l + 1;
+                let m = i;
+                if (l < keys.length && keys[l] < keys[m])
+                    m = l;
+                if (r < keys.length && keys[r] < keys[m])
+                    m = r;
+                if (m === i)
+                    break;
+                [keys[i], keys[m]] = [keys[m], keys[i]];
+                [values[i], values[m]] = [values[m], values[i]];
+                i = m;
+            }
+        }
+        return top;
+    }
+}
+const FOUR = [
+    [1, 0],
+    [-1, 0],
+    [0, 1],
+    [0, -1],
+];
+/**
+ * The widest path (maximin) from the source cells over cells where `inside` holds and the clearance
+ * is positive, 4-neighbour. `B[c]` is the best bottleneck, the least clearance along the widest path
+ * to `c`; `P[c]` the cell before it.
+ */
+export function widestPath(g, F, inside, sources) {
+    const B = new Float64Array(g.W * g.H).fill(Number.NEGATIVE_INFINITY);
+    const P = new Int32Array(g.W * g.H).fill(-1);
+    const done = new Uint8Array(g.W * g.H);
+    const heap = new Heap();
+    // a max-heap on the bottleneck, as a min-heap on its negative
+    for (const s of sources)
+        if (F[s] > 0 && inside[s]) {
+            B[s] = F[s];
+            heap.push(-F[s], s);
+        }
+    while (heap.size) {
+        const [negative, c] = heap.pop();
+        if (done[c])
+            continue;
+        done[c] = 1;
+        const b = -negative;
+        const i = c % g.W;
+        const j = (c / g.W) | 0;
+        for (const [di, dj] of FOUR) {
+            const ii = i + di;
+            const jj = j + dj;
+            if (ii < 0 || jj < 0 || ii >= g.W || jj >= g.H)
+                continue;
+            const n = jj * g.W + ii;
+            if (!inside[n] || F[n] <= 0 || done[n])
+                continue;
+            const nb = Math.min(b, F[n]);
+            if (nb > B[n]) {
+                B[n] = nb;
+                P[n] = c;
+                heap.push(-nb, n);
+            }
+        }
+    }
+    return { B, P };
+}
+/** The cells of the widest path from its source to `c`, in order, and the index of its narrowest. */
+export function pathTo(P, F, c) {
+    const cells = [];
+    for (let k = c; k >= 0; k = P[k])
+        cells.push(k);
+    cells.reverse();
+    let narrowest = 0;
+    for (let k = 1; k < cells.length; k++)
+        if (F[cells[k]] < F[cells[narrowest]])
+            narrowest = k;
+    return { cells, narrowest };
+}
+/** The 16 moves of a grid walk; those that cross cells need those cells passable too, so no corner cuts a wall. */
+const MOVES = (() => {
+    const seen = new Set();
+    const moves = [];
+    const add = (di, dj) => {
+        const key = `${di},${dj}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        const via = [];
+        if (Math.abs(di) === 1 && Math.abs(dj) === 1)
+            via.push([di, 0], [0, dj]);
+        if (Math.abs(di) === 2)
+            via.push([Math.sign(di), 0], [Math.sign(di), dj]);
+        if (Math.abs(dj) === 2)
+            via.push([0, Math.sign(dj)], [di, Math.sign(dj)]);
+        moves.push({ di, dj, length: Math.hypot(di, dj), via });
+    };
+    for (const [a, b] of [
+        [1, 0],
+        [1, 1],
+        [2, 1],
+        [1, 2],
+    ])
+        for (const sx of [1, -1])
+            for (const sz of [1, -1])
+                add(a * sx, b * sz);
+    add(0, 1);
+    add(0, -1);
+    return moves;
+})();
+/** Grid Dijkstra over the passable cells, 16 neighbours: the travel distance in metres, Infinity where unreached. */
+export function travel(g, pass, sources) {
+    const D = new Float64Array(g.W * g.H).fill(Number.POSITIVE_INFINITY);
+    const heap = new Heap();
+    for (const s of sources)
+        if (pass[s]) {
+            D[s] = 0;
+            heap.push(0, s);
+        }
+    while (heap.size) {
+        const [d, c] = heap.pop();
+        if (d > D[c])
+            continue;
+        const i = c % g.W;
+        const j = (c / g.W) | 0;
+        for (const m of MOVES) {
+            const ii = i + m.di;
+            const jj = j + m.dj;
+            if (ii < 0 || jj < 0 || ii >= g.W || jj >= g.H)
+                continue;
+            const n = jj * g.W + ii;
+            if (!pass[n])
+                continue;
+            let open = true;
+            for (const [vi, vj] of m.via)
+                if (!pass[(j + vj) * g.W + (i + vi)]) {
+                    open = false;
+                    break;
+                }
+            if (!open)
+                continue;
+            const next = d + m.length * g.h;
+            if (next < D[n]) {
+                D[n] = next;
+                heap.push(next, n);
+            }
+        }
+    }
+    return D;
+}
+/** A fine grid (the coarse step divided by `fine`) of side 2R around path cell `k`, with its source and target cells. */
+function windowAround(g, cells, k, isSource, isTarget, R, fine) {
+    const cx = (c) => cellX(g, c % g.W);
+    const cz = (c) => cellZ(g, (c / g.W) | 0);
+    const X = cx(cells[k]);
+    const Z = cz(cells[k]);
+    const step = g.h / fine;
+    const n = Math.round((2 * R) / step);
+    const fx = (i) => X - R + (i + 0.5) * step;
+    const fz = (j) => Z - R + (j + 0.5) * step;
+    const far = (c) => Math.hypot(cx(c) - X, cz(c) - Z) > 0.75 * R;
+    let before = -1;
+    let after = -1;
+    for (let q = k; q >= 0; q--)
+        if (far(cells[q])) {
+            before = cells[q];
+            break;
+        }
+    for (let q = k; q < cells.length; q++)
+        if (far(cells[q])) {
+            after = cells[q];
+            break;
+        }
+    const near = (c, i, j) => Math.hypot(fx(i) - cx(c), fz(j) - cz(c)) <= g.h / 2;
+    const sources = [];
+    const targets = [];
+    for (let j = 0; j < n; j++)
+        for (let i = 0; i < n; i++) {
+            const coarse = Math.floor((fz(j) - g.z0) / g.h) * g.W + Math.floor((fx(i) - g.x0) / g.h);
+            if (before >= 0 ? near(before, i, j) : isSource(coarse))
+                sources.push(j * n + i);
+            if (after >= 0 ? near(after, i, j) : isTarget(fx(i), fz(j)))
+                targets.push(j * n + i);
+        }
+    return { x0: X - R, z0: Z - R, n, step, sources, targets };
+}
+/**
+ * The widest path inside one window, on the exact clearance of its fine cells: the best bottleneck
+ * and where it pinches. Only fine cells that could still limit the path are asked exactly; where
+ * the grid says the clearance is `slack` above the coarse bottleneck, it cannot be the bottleneck.
+ */
+function solveWindow(w, index, g, F, limit) {
+    const field = new Float32Array(w.n * w.n);
+    // a fine cell's coarse cell is off its centre by at most this
+    const reach = Math.SQRT1_2 * g.h;
+    for (let j = 0; j < w.n; j++)
+        for (let i = 0; i < w.n; i++) {
+            const x = w.x0 + (i + 0.5) * w.step;
+            const z = w.z0 + (j + 0.5) * w.step;
+            const coarse = cellOf(g, x, z);
+            field[j * w.n + i] =
+                coarse >= 0 && F[coarse] - reach > limit ? F[coarse] : index.query(x, z).d;
+        }
+    const fine = { W: w.n, H: w.n, h: w.step, x0: w.x0, z0: w.z0 };
+    const { B } = widestPath(fine, field, new Uint8Array(w.n * w.n).fill(1), w.sources);
+    let best = Number.NEGATIVE_INFINITY;
+    for (const c of w.targets)
+        if (B[c] > best)
+            best = B[c];
+    let at = [w.x0 + w.n * w.step * 0.5, w.z0 + w.n * w.step * 0.5];
+    let nearest = Number.POSITIVE_INFINITY;
+    for (let c = 0; c < B.length; c++) {
+        const gap = Math.abs(field[c] - best);
+        if (Math.abs(B[c] - best) < 1e-6 && gap < nearest) {
+            nearest = gap;
+            at = [w.x0 + ((c % w.n) + 0.5) * w.step, w.z0 + (((c / w.n) | 0) + 0.5) * w.step];
+        }
+    }
+    return { d: best, at };
+}
+/**
+ * The passage along a coarse widest path, to the millimetre. The grid says where the path pinches,
+ * to within half a cell; this re-solves the widest path on a grid ten times finer, with exact
+ * clearances, in a window around every path cell that is within one cell of the coarse bottleneck
+ * (centres at least `spacing` apart), and takes the narrowest result. The passage is twice that
+ * clearance.
+ */
+export function refinePassage(g, F, index, path, isSource, isTarget, { R = 0.3, step = 0.005, spacing = 0.2, cache, roomKey = '', } = {}) {
+    const { cells } = path;
+    const coarse = F[cells[path.narrowest]];
+    const threshold = coarse + g.h;
+    const fine = Math.max(1, Math.round(g.h / step));
+    const centres = [];
+    const at = (k) => [
+        cellX(g, cells[k] % g.W),
+        cellZ(g, (cells[k] / g.W) | 0),
+    ];
+    for (let k = 0; k < cells.length; k++) {
+        if (F[cells[k]] > threshold)
+            continue;
+        const [x, z] = at(k);
+        if (centres.every((m) => Math.hypot(at(m)[0] - x, at(m)[1] - z) > spacing))
+            centres.push(k);
+    }
+    let best = null;
+    for (const k of centres) {
+        // a window whose path leaves it the same way for any room is shared between rooms
+        const [x, z] = at(k);
+        const leaves = cells
+            .slice(k)
+            .some((q) => Math.hypot(cellX(g, q % g.W) - x, cellZ(g, (q / g.W) | 0) - z) > 0.75 * R);
+        const key = `${cells[k]}${leaves ? '' : `|${roomKey}`}`;
+        let result = cache?.get(key);
+        if (!result) {
+            result = solveWindow(windowAround(g, cells, k, isSource, isTarget, R, fine), index, g, F, coarse + 2 * g.h);
+            cache?.set(key, result);
+        }
+        if (!best || result.d < best.d)
+            best = result;
+    }
+    if (!best) {
+        const c = cells[path.narrowest];
+        best = { d: F[c], at: [cellX(g, c % g.W), cellZ(g, (c / g.W) | 0)] };
+    }
+    return { width: 2 * best.d, at: best.at, windows: centres.length };
+}
+const EIGHT = [
+    [1, 0],
+    [-1, 0],
+    [0, 1],
+    [0, -1],
+    [1, 1],
+    [1, -1],
+    [-1, 1],
+    [-1, -1],
+];
+/**
+ * The shortest way from one cell to another over the passable cells, 8 neighbours, no corner cut
+ * through a blocked cell (A*). The cells in order, or null when there is no way.
+ */
+export function shortestRoute(g, pass, from, to) {
+    if (!pass[from] || !pass[to])
+        return null;
+    const cost = new Float64Array(g.W * g.H).fill(Number.POSITIVE_INFINITY);
+    const parent = new Int32Array(g.W * g.H).fill(-1);
+    const tx = to % g.W;
+    const tz = (to / g.W) | 0;
+    const heuristic = (c) => Math.hypot((c % g.W) - tx, ((c / g.W) | 0) - tz);
+    const heap = new Heap();
+    cost[from] = 0;
+    heap.push(heuristic(from), from);
+    while (heap.size) {
+        const [, c] = heap.pop();
+        if (c === to)
+            break;
+        const i = c % g.W;
+        const j = (c / g.W) | 0;
+        for (const [di, dj] of EIGHT) {
+            const ii = i + di;
+            const jj = j + dj;
+            if (ii < 0 || jj < 0 || ii >= g.W || jj >= g.H)
+                continue;
+            const n = jj * g.W + ii;
+            if (!pass[n])
+                continue;
+            if (di !== 0 && dj !== 0 && !(pass[j * g.W + ii] && pass[jj * g.W + i]))
+                continue;
+            const next = cost[c] + Math.hypot(di, dj);
+            if (next < cost[n]) {
+                cost[n] = next;
+                parent[n] = c;
+                heap.push(next + heuristic(n), n);
+            }
+        }
+    }
+    if (parent[to] < 0 && from !== to)
+        return null;
+    const route = [];
+    for (let c = to; c >= 0; c = parent[c])
+        route.push(c);
+    return route.reverse();
+}

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

@@ -0,0 +1,27 @@
+import { type Ring } from '../../lib/polygon-boolean.js';
+import type { AnyNode, ItemNode } from '../../schema/index.js';
+import type { Prism } from './types.js';
+import type { Nodes } from './walls.js';
+export declare const isPiecePrism: (prism: Prism) => boolean;
+export declare const textOf: (node: ItemNode) => string;
+export declare const isFoliageItem: (node: ItemNode) => boolean;
+export declare const isBuildingElementItem: (node: ItemNode) => boolean;
+/** What an item is called and filed under, or '' for a node that is not an item (a candidate not in the scene yet is passed as the item itself). */
+export declare function itemText(nodes: Nodes, nodeId: string): string;
+export declare function isFoliage(nodes: Nodes, nodeId: string): boolean;
+export declare function isBuildingElement(nodes: Nodes, nodeId: string): boolean;
+export declare const isBed: (node: AnyNode | undefined) => node is ItemNode;
+/** Whether `ancestor` hosts `nodeId`, however many items deep (a lamp on a table on a rug). */
+export declare function hosts(nodes: Nodes, ancestor: string, nodeId: string): boolean;
+/** The narrowest extent of some polygons, over 36 directions: how deep one shape sits in another. */
+export declare function narrowestExtent(polygons: readonly {
+    outer: Ring;
+}[]): number;
+export declare const ringBox: (ring: Ring) => [number, number, number, number];
+export declare const boxesMeet: (a: readonly number[], b: readonly number[], pad?: number) => boolean;
+/** The room (zone) of a level that holds a point: the smallest when rooms overlap. */
+export declare function roomAt(nodes: Nodes, levelId: string, point: [number, number]): {
+    id: string;
+    name: string;
+} | null;
+//# sourceMappingURL=pieces.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pieces.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/pieces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,IAAI,EAAE,MAAM,2BAA2B,CAAA;AACpE,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAY,MAAM,cAAc,CAAA;AAC/D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AACpC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAIpC,eAAO,MAAM,YAAY,UAAW,KAAK,KAAG,OAAsC,CAAA;AAQlF,eAAO,MAAM,MAAM,SAAU,QAAQ,WACyC,CAAA;AAE9E,eAAO,MAAM,aAAa,SAAU,QAAQ,KAAG,OAAqC,CAAA;AAEpF,eAAO,MAAM,qBAAqB,SAAU,QAAQ,KAAG,OAClB,CAAA;AAErC,oJAAoJ;AACpJ,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAG7D;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAG/D;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAGvE;AAED,eAAO,MAAM,KAAK,SAAU,OAAO,GAAG,SAAS,KAAG,IAAI,IAAI,QACD,CAAA;AAEzD,+FAA+F;AAC/F,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAO7E;AAED,qGAAqG;AACrG,wBAAgB,eAAe,CAAC,QAAQ,EAAE,SAAS;IAAE,KAAK,EAAE,IAAI,CAAA;CAAE,EAAE,GAAG,MAAM,CAkB5E;AAED,eAAO,MAAM,OAAO,SAAU,IAAI,KAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAYnE,CAAA;AAED,eAAO,MAAM,SAAS,MAAO,SAAS,MAAM,EAAE,KAAK,SAAS,MAAM,EAAE,mBAAY,OACa,CAAA;AAE7F,sFAAsF;AACtF,wBAAgB,MAAM,CACpB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GACtB;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAmBrC"}

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

@@ -0,0 +1,89 @@
+import { containsPoint } from '../../lib/polygon-boolean.js';
+/** What a person puts in a room and walks around: items, cabinets, columns, shelves. */
+const PIECE_KINDS = new Set(['item', 'cabinet', 'column', 'shelf']);
+export const isPiecePrism = (prism) => PIECE_KINDS.has(prism.kind);
+/** Foliage is a cloud of leaves: its bounds overlap by design, and it stands in front of walls. */
+const FOLIAGE = /plant|palm|foliage|tree|shrub|hedge|grass|fern|flower|bouquet|vase of|landscape/i;
+/** Items that are part of the building (trim, soffits, cladding, piers, guards, beams, lights): they meet walls by design. */
+const BUILDING_ELEMENT = /trim|fascia|soffit|cladding|cornice|surround|portal|railing|balustrade|guard|pier|beam|post\b|column|canopy|pergola|awning|downlight|light/i;
+export const textOf = (node) => `${node.name ?? ''} ${node.asset?.name ?? ''} ${node.asset?.category ?? ''}`;
+export const isFoliageItem = (node) => FOLIAGE.test(textOf(node));
+export const isBuildingElementItem = (node) => BUILDING_ELEMENT.test(textOf(node));
+/** What an item is called and filed under, or '' for a node that is not an item (a candidate not in the scene yet is passed as the item itself). */
+export function itemText(nodes, nodeId) {
+    const node = nodes[nodeId];
+    return node?.type === 'item' ? textOf(node) : '';
+}
+export function isFoliage(nodes, nodeId) {
+    const node = nodes[nodeId];
+    return node?.type === 'item' && isFoliageItem(node);
+}
+export function isBuildingElement(nodes, nodeId) {
+    const node = nodes[nodeId];
+    return node?.type === 'item' && isBuildingElementItem(node);
+}
+export const isBed = (node) => node?.type === 'item' && node.asset?.category === 'bed';
+/** Whether `ancestor` hosts `nodeId`, however many items deep (a lamp on a table on a rug). */
+export function hosts(nodes, ancestor, nodeId) {
+    let at = nodes[nodeId];
+    for (let depth = 0; at && depth < 24; depth++) {
+        if (at.id === ancestor)
+            return at.id !== nodeId;
+        at = at.parentId ? nodes[at.parentId] : undefined;
+    }
+    return false;
+}
+/** The narrowest extent of some polygons, over 36 directions: how deep one shape sits in another. */
+export function narrowestExtent(polygons) {
+    const points = polygons.flatMap((polygon) => polygon.outer);
+    if (points.length < 3)
+        return 0;
+    let narrowest = Number.POSITIVE_INFINITY;
+    for (let k = 0; k < 36; k++) {
+        const angle = (k * Math.PI) / 36;
+        const c = Math.cos(angle);
+        const s = Math.sin(angle);
+        let low = Number.POSITIVE_INFINITY;
+        let high = Number.NEGATIVE_INFINITY;
+        for (const [x, z] of points) {
+            const t = x * c + z * s;
+            low = Math.min(low, t);
+            high = Math.max(high, t);
+        }
+        narrowest = Math.min(narrowest, high - low);
+    }
+    return narrowest;
+}
+export const ringBox = (ring) => {
+    let x0 = Number.POSITIVE_INFINITY;
+    let z0 = Number.POSITIVE_INFINITY;
+    let x1 = Number.NEGATIVE_INFINITY;
+    let z1 = Number.NEGATIVE_INFINITY;
+    for (const [x, z] of ring) {
+        x0 = Math.min(x0, x);
+        z0 = Math.min(z0, z);
+        x1 = Math.max(x1, x);
+        z1 = Math.max(z1, z);
+    }
+    return [x0, z0, x1, z1];
+};
+export const boxesMeet = (a, b, pad = 0) => !(a[2] + pad < b[0] || b[2] + pad < a[0] || a[3] + pad < b[1] || b[3] + pad < a[1]);
+/** The room (zone) of a level that holds a point: the smallest when rooms overlap. */
+export function roomAt(nodes, levelId, point) {
+    let best = null;
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'zone' || node.parentId !== levelId)
+            continue;
+        const zone = node;
+        if (!containsPoint([{ outer: zone.polygon, holes: (zone.holes ?? []) }], point))
+            continue;
+        const ring = zone.polygon;
+        const size = Math.abs(ring.reduce((sum, p, i) => {
+            const q = ring[(i + 1) % ring.length];
+            return sum + (p[0] * q[1] - q[0] * p[1]);
+        }, 0) / 2);
+        if (!best || size < best.size)
+            best = { id: zone.id, name: String(zone.name ?? zone.id), size };
+    }
+    return best ? { id: best.id, name: best.name } : null;
+}

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

@@ -0,0 +1,18 @@
+import type { UsageShapes } from './types.js';
+import { type Nodes } from './walls.js';
+export { sdfChecksOn, setSdfChecks } from './flag.js';
+export type { FloorRegion, LevelShapes, Prism, PrismKind, Skipped, UsageShapes } from './types.js';
+/**
+ * What a person walks around, level by level, as prisms in the building's frame: plan polygons in
+ * metres between two absolute heights. Walls, their trims, door and window frames and sills, stairs
+ * and their guards, and the floor itself. A stair is filed under the level it starts from, but its
+ * prisms rise through the levels above, so a query reads the prisms of a whole building by height,
+ * not one level's list.
+ *
+ * Items stand on the floor, on the item that hosts them, or on a wall, each as its script's stored
+ * outline or a box. Pure: it reads the node record and the helpers the renderers read, and builds no meshes. A node
+ * whose shape cannot be read is named in `skipped`; one that is drawn only roughly is named in
+ * `approximate`; kinds not shaped yet are counted in `unshaped`.
+ */
+export declare function usageShapes(nodes: Nodes): UsageShapes;
+//# sourceMappingURL=shapes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shapes.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/shapes.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAA+B,WAAW,EAAE,MAAM,SAAS,CAAA;AACvE,OAAO,EAAc,KAAK,KAAK,EAAyB,MAAM,SAAS,CAAA;AAEvE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAClD,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAQ/F;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,WAAW,CAkErD"}

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

@@ -0,0 +1,92 @@
+import { getLevelElevations } from '../../services/storey.js';
+import { boxBodies } from './boxes.js';
+import { fenceBodies } from './fences.js';
+import { levelFloors } from './floors.js';
+import { itemBodies } from './items.js';
+import { openingBodies } from './openings.js';
+import { stairBodies } from './stairs.js';
+import { levelWalls, wallBodies, wallTrims } from './walls.js';
+export { sdfChecksOn, setSdfChecks } from './flag.js';
+/** Kinds that stand in a room and are not shaped yet; counted so a finding can say what it did not see. */
+const NOT_SHAPED_YET = ['elevator', 'ramp', 'chimney', 'rock'];
+const lifted = (prisms, dy) => dy === 0 ? prisms : prisms.map((prism) => ({ ...prism, z0: prism.z0 + dy, z1: prism.z1 + dy }));
+/**
+ * What a person walks around, level by level, as prisms in the building's frame: plan polygons in
+ * metres between two absolute heights. Walls, their trims, door and window frames and sills, stairs
+ * and their guards, and the floor itself. A stair is filed under the level it starts from, but its
+ * prisms rise through the levels above, so a query reads the prisms of a whole building by height,
+ * not one level's list.
+ *
+ * Items stand on the floor, on the item that hosts them, or on a wall, each as its script's stored
+ * outline or a box. Pure: it reads the node record and the helpers the renderers read, and builds no meshes. A node
+ * whose shape cannot be read is named in `skipped`; one that is drawn only roughly is named in
+ * `approximate`; kinds not shaped yet are counted in `unshaped`.
+ */
+export function usageShapes(nodes) {
+    const elevations = getLevelElevations(nodes);
+    const { floors, skipped: floorSkips } = levelFloors(nodes);
+    const skipped = [...floorSkips];
+    const byLevel = new Map();
+    const level = (levelId) => {
+        let shapes = byLevel.get(levelId);
+        if (!shapes) {
+            shapes = { levelId, prisms: [], floors: floors.get(levelId) ?? [] };
+            byLevel.set(levelId, shapes);
+        }
+        return shapes;
+    };
+    const levelIds = Object.values(nodes)
+        .filter((node) => node.type === 'level')
+        .map((node) => node.id)
+        .sort();
+    for (const levelId of levelIds) {
+        const baseY = elevations.get(levelId)?.baseY ?? 0;
+        const walls = levelWalls(nodes, levelId);
+        const trims = wallTrims(nodes, levelId, walls);
+        for (const wallId of trims.skipped)
+            skipped.push({ nodeId: wallId, why: 'a curved wall: its trim is not drawn here' });
+        level(levelId).prisms.push(...lifted([
+            ...wallBodies(nodes, levelId, walls),
+            ...trims.prisms,
+            ...openingBodies(nodes, levelId, walls),
+        ], baseY));
+    }
+    const { stairs, skipped: stairSkips, handrails } = stairBodies(nodes);
+    skipped.push(...stairSkips);
+    for (const stair of stairs) {
+        if (!stair.levelId) {
+            skipped.push({ nodeId: stair.stairId, why: 'a stair on no level' });
+            continue;
+        }
+        level(stair.levelId).prisms.push(...stair.prisms);
+    }
+    const items = itemBodies(nodes);
+    skipped.push(...items.skipped);
+    for (const item of items.items)
+        if (item.levelId)
+            level(item.levelId).prisms.push(...item.prisms);
+    const boxes = boxBodies(nodes);
+    skipped.push(...boxes.skipped);
+    for (const box of boxes.nodes)
+        if (box.levelId)
+            level(box.levelId).prisms.push(...box.prisms);
+    const fences = fenceBodies(nodes);
+    skipped.push(...fences.skipped);
+    for (const fence of fences.fences)
+        if (fence.levelId)
+            level(fence.levelId).prisms.push(...fence.prisms);
+    const unshaped = { ...items.unshaped };
+    for (const node of Object.values(nodes))
+        if (NOT_SHAPED_YET.includes(node.type))
+            unshaped[node.type] = (unshaped[node.type] ?? 0) + 1;
+    if (handrails)
+        unshaped['stair handrail'] = handrails;
+    const levels = levelIds.map((levelId) => level(levelId));
+    const approximate = [
+        ...new Set([
+            ...levels.flatMap((l) => l.prisms.filter((p) => p.shape === 'approx').map((p) => p.nodeId)),
+            ...levels.flatMap((l) => l.floors.filter((f) => f.shape === 'approx').map((f) => f.nodeId)),
+        ]),
+    ].sort();
+    return { levels, approximate, unshaped, skipped };
+}

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

@@ -0,0 +1,23 @@
+import type { Prism, Skipped } from './types.js';
+import type { Nodes } from './walls.js';
+/**
+ * A sloped member (a soffit, a rail, a glass pane) is cut into slices that rise this much each, so
+ * its prism height stays within this of the member's own at any point along it.
+ */
+export declare const SLOPE_STEP_M = 0.05;
+export type StairShapes = {
+    stairId: string;
+    levelId: string | null;
+    prisms: Prism[];
+};
+/**
+ * Every stair's treads, landings and guards as prisms in absolute building metres, each filed under
+ * the level the stair starts from. A stair the resolvers refuse (their detail budgets) is named in
+ * `skipped` and leaves the others alone; the independent handrail is not drawn here and is counted.
+ */
+export declare function stairBodies(nodes: Nodes): {
+    stairs: StairShapes[];
+    skipped: Skipped[];
+    handrails: number;
+};
+//# sourceMappingURL=stairs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stairs.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/stairs.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,KAAK,EAAQ,OAAO,EAAE,MAAM,SAAS,CAAA;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC;;;GAGG;AACH,eAAO,MAAM,YAAY,OAAO,CAAA;AAOhC,MAAM,MAAM,WAAW,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,KAAK,EAAE,CAAA;CAAE,CAAA;AA8ItF;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG;IACzC,MAAM,EAAE,WAAW,EAAE,CAAA;IACrB,OAAO,EAAE,OAAO,EAAE,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;CAClB,CAsBA"}