@pascal-app/core 1.0.6 → 1.1.0

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

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

@@ -0,0 +1,160 @@
+import { isFloorUnderlay } from '../../agent-operations/furniture-kind.js';
+import { CODE_PROFILES, codeProfileOf, } from '../../building/code-profile.js';
+import { catalogueKey } from './catalogue.js';
+import { m, nameOf, quote, unique } from './labels.js';
+import { obstaclesInBand, rayHit } from './obstacles.js';
+import { roomAt } from './pieces.js';
+const TOILET = /toilet|water ?closet|(?:^|[^a-z])wc(?![a-z])/i;
+const BASIN = /basin|lavatory|vanity|bathroom[- ]sink|wash ?hand/i;
+const BASIN_WORD = /basin|lavatory|vanity|sink|wash ?hand/i;
+const SHOWER = /shower/i;
+/** The feet band: what a person's legs and a fixture's rim meet (m above the floor). */
+const BAND = { from: 0.05, to: 0.9 };
+const RAY_MAX_M = 1.5;
+/** Where along a fixture's depth, from its back, the sides are read. */
+const SIDE_SAMPLES = [0.25, 0.5, 0.75, 1];
+/** A lavatory this wide has more than one basin: its centre line is not a basin's. */
+const SINGLE_BASIN_MAX_M = 1.0;
+const kindOf = (item) => {
+    const text = `${item.name ?? ''} ${item.asset.name ?? ''} ${item.asset.id ?? ''} ${item.asset.category ?? ''}`;
+    const key = catalogueKey(item.asset.src ?? '');
+    if (key === 'system/toilet' || (TOILET.test(text) && !BASIN_WORD.test(text)))
+        return 'toilet';
+    if (key === 'system/shower-square' || SHOWER.test(text))
+        return 'shower';
+    if (key === 'system/bathroom-sink' || (BASIN.test(text) && !/kitchen/i.test(text)))
+        return 'lavatory';
+    return null;
+};
+const inchesText = (metres) => `${Math.round(metres / 0.0254)} in`;
+/**
+ * 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 function fixtureClearanceIssues(nodes, shapes) {
+    const profile = codeProfileOf(nodes);
+    const applied = profile ?? CODE_PROFILES['irc-2021'];
+    if (Object.keys(applied.thresholds).length === 0)
+        return [];
+    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 item of Object.values(nodes)) {
+            if (item.type !== 'item' || item.visible === false || item.parentId !== level.levelId)
+                continue;
+            const kind = kindOf(item);
+            if (!kind)
+                continue;
+            const own = prisms.filter((p) => p.nodeId === item.id);
+            if (!own.length)
+                continue;
+            const approximate = own.some((p) => p.shape === 'approx');
+            // the feet band stands on the fixture's own floor: a floor plate set off its storey's base is the fixture's floor
+            const floorY = Math.min(...own.map((p) => p.z0));
+            const band = { z0: floorY + BAND.from, z1: floorY + BAND.to };
+            const yaw = item.rotation?.[1] ?? 0;
+            const f = [Math.sin(yaw), Math.cos(yaw)];
+            const r = [Math.cos(yaw), -Math.sin(yaw)];
+            const points = own.flatMap((p) => p.outer);
+            const project = (u) => points.map((p) => p[0] * u[0] + p[1] * u[1]);
+            const [r0, r1] = [Math.min(...project(r)), Math.max(...project(r))];
+            const [f0, f1] = [Math.min(...project(f)), Math.max(...project(f))];
+            const at = (ur, uf) => [r[0] * ur + f[0] * uf, r[1] * ur + f[1] * uf];
+            const obstacles = obstaclesInBand(prisms, band, undefined, (p) => {
+                if (p.nodeId === item.id || p.kind === 'treatment')
+                    return true;
+                const owner = nodes[p.nodeId];
+                return owner?.type === 'item' && owner.parentId === item.id;
+            });
+            const middle = (r0 + r1) / 2;
+            const depth = f1 - f0;
+            const behind = rayHit(at(middle, f0 - 0.001), [-f[0], -f[1]], obstacles, 0.4);
+            const ahead = rayHit(at(middle, f1 + 0.001), f, obstacles, 0.4);
+            const turned = behind > ahead + 0.05 && ahead < 0.15;
+            const front = turned ? [-f[0], -f[1]] : f;
+            const edge = turned ? f0 - 0.001 : f1 + 0.001;
+            const measures = [];
+            if (kind === 'shower') {
+                let best = 0;
+                for (const [dir, e, u0, u1, across] of [
+                    [f, f1 + 0.001, r0, r1, true],
+                    [[-f[0], -f[1]], f0 - 0.001, r0, r1, true],
+                    [r, r1 + 0.001, f0, f1, false],
+                    [[-r[0], -r[1]], r0 - 0.001, f0, f1, false],
+                ]) {
+                    const clear = Math.min(...[0.25, 0.5, 0.75].map((s) => {
+                        const u = u0 + (u1 - u0) * s;
+                        return rayHit(across ? at(u, e) : at(e, u), dir, obstacles, RAY_MAX_M);
+                    }));
+                    best = Math.max(best, clear);
+                }
+                measures.push({
+                    id: 'showerFrontClear',
+                    label: 'in front of its best open side',
+                    value: best,
+                });
+            }
+            else {
+                const front0 = [-0.25, -0.125, 0, 0.125, 0.25].map((o) => rayHit(at(middle + o, edge), front, obstacles, RAY_MAX_M));
+                measures.push({
+                    id: kind === 'toilet' ? 'toiletFrontClear' : 'lavatoryFrontClear',
+                    label: 'in front',
+                    value: Math.min(...front0),
+                });
+                if (kind === 'toilet' || r1 - r0 <= SINGLE_BASIN_MAX_M) {
+                    let side = Number.POSITIVE_INFINITY;
+                    // not along the back edge: a ray grazing the wall behind the fixture is not a side obstruction
+                    for (const sign of [-1, 1])
+                        for (const share of SIDE_SAMPLES)
+                            side = Math.min(side, (r1 - r0) / 2 +
+                                rayHit(at(sign > 0 ? r1 + 0.001 : r0 - 0.001, f0 + depth * share), [r[0] * sign, r[1] * sign], obstacles, 0.6));
+                    measures.push({
+                        id: kind === 'toilet' ? 'toiletSideClear' : 'lavatorySideClear',
+                        label: 'from its centre to the nearest obstruction at the side',
+                        value: side,
+                    });
+                }
+            }
+            const room = roomAt(nodes, level.levelId, at(middle, (f0 + f1) / 2));
+            const name = nameOf(nodes, item.id);
+            for (const { id, label, value } of measures) {
+                const row = applied.thresholds[id];
+                if (!row || !(value < row.value - 0.005))
+                    continue;
+                const secondary = row.source === 'secondary source';
+                const best = id === 'showerFrontClear';
+                out.push({
+                    type: 'usage_fixture_clearance',
+                    message: `${quote(name)}${room ? ` in ${quote(room.name)}` : ''} has ${m(value)} m ${label}${best ? ', the best of its four sides (the model has no opening side)' : ''}; ${applied.label} (${row.section}${secondary ? ', secondary source' : ''}) asks ${m(row.value)} m (${inchesText(row.value)})${profile ? '' : ', and this project names no code'}.`,
+                    severity: profile ? 'warning' : 'info',
+                    nodeIds: unique([room?.id, item.id]),
+                    valueM: Math.round(value * 1000) / 1000,
+                    thresholdM: row.value,
+                    place: {
+                        room: room?.name ?? '',
+                        roomId: room?.id ?? level.levelId,
+                        at: at(middle, (f0 + f1) / 2),
+                    },
+                    obstacles: [],
+                    approximate,
+                    code: {
+                        profile: applied.id,
+                        cite: row.cite,
+                        source: row.source,
+                        byDefault: profile === null,
+                    },
+                });
+            }
+        }
+    }
+    return out;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Usage checks (passages, turning circles, pockets, wall objects, measured flow) are off until a
+ * host turns them on. Core reads no environment: the app and the servers set this once at start,
+ * from `PASCAL_SDF_CHECKS`.
+ */
+export declare function setSdfChecks(on: boolean): void;
+export declare const sdfChecksOn: () => boolean;
+/** What `PASCAL_SDF_CHECKS` (or its `NEXT_PUBLIC_` mirror) says: `1` or `true` turns the checks on, anything else, or nothing, leaves them off. */
+export declare const sdfChecksFromEnv: (value: string | undefined) => boolean;
+//# sourceMappingURL=flag.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flag.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/flag.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAE9C;AAED,eAAO,MAAM,WAAW,QAAO,OAAkB,CAAA;AAEjD,mJAAmJ;AACnJ,eAAO,MAAM,gBAAgB,UAAW,MAAM,GAAG,SAAS,KAAG,OACX,CAAA"}

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

@@ -0,0 +1,12 @@
+let enabled = false;
+/**
+ * Usage checks (passages, turning circles, pockets, wall objects, measured flow) are off until a
+ * host turns them on. Core reads no environment: the app and the servers set this once at start,
+ * from `PASCAL_SDF_CHECKS`.
+ */
+export function setSdfChecks(on) {
+    enabled = on;
+}
+export const sdfChecksOn = () => enabled;
+/** What `PASCAL_SDF_CHECKS` (or its `NEXT_PUBLIC_` mirror) says: `1` or `true` turns the checks on, anything else, or nothing, leaves them off. */
+export const sdfChecksFromEnv = (value) => value === '1' || value?.toLowerCase() === 'true';

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

@@ -0,0 +1,13 @@
+import type { FloorRegion, Skipped } from './types.js';
+import type { Nodes } from './walls.js';
+/**
+ * The floor a person stands on, level by level: each slab's walking surface less the floor openings
+ * and lift shafts cut through it, at the height the circulation graph reads (`floorsOf`), so the
+ * usage checks and the circulation report stand on the same floor. A slab draped over terrain is one
+ * flat height here and is marked approximate; a recessed slab (a pool) is not a floor.
+ */
+export declare function levelFloors(nodes: Nodes): {
+    floors: Map<string, FloorRegion[]>;
+    skipped: Skipped[];
+};
+//# sourceMappingURL=floors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floors.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/floors.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpC;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG;IACzC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,CAAA;IAClC,OAAO,EAAE,OAAO,EAAE,CAAA;CACnB,CA2BA"}

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

@@ -0,0 +1,36 @@
+import { floorsOf } from '../../agent-operations/circulation-spaces.js';
+import { difference } from '../../lib/polygon-boolean.js';
+/**
+ * The floor a person stands on, level by level: each slab's walking surface less the floor openings
+ * and lift shafts cut through it, at the height the circulation graph reads (`floorsOf`), so the
+ * usage checks and the circulation report stand on the same floor. A slab draped over terrain is one
+ * flat height here and is marked approximate; a recessed slab (a pool) is not a floor.
+ */
+export function levelFloors(nodes) {
+    const floors = new Map();
+    const skipped = [];
+    for (const floor of floorsOf(nodes).floors) {
+        const cuts = [...floor.voids, ...floor.shafts].map((ring) => ({ outer: ring, holes: [] }));
+        const regions = [];
+        for (const slab of floor.slabs) {
+            const source = nodes[slab.id];
+            if (source?.type === 'slab' && source.recessed) {
+                skipped.push({ nodeId: slab.id, why: 'a recessed slab is not a floor to stand on' });
+                continue;
+            }
+            const pieces = difference({ outer: slab.polygon, holes: slab.holes }, cuts);
+            for (const [index, piece] of pieces.entries())
+                regions.push({
+                    id: `${slab.id}#floor${pieces.length > 1 ? `.${index}` : ''}`,
+                    nodeId: slab.id,
+                    outer: piece.outer,
+                    holes: piece.holes,
+                    y: slab.elevation,
+                    outdoor: slab.outdoor,
+                    shape: 'exact',
+                });
+        }
+        floors.set(floor.id, regions);
+    }
+    return { floors, skipped };
+}

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

@@ -0,0 +1,7 @@
+export { catalogueKey } from './catalogue.js';
+export { type UsageIssue, usageIssues } from './findings.js';
+export { sdfChecksFromEnv, sdfChecksOn, setSdfChecks } from './flag.js';
+export { measureUsage, type UsageMeasure } from './measure.js';
+export { usageShapes } from './shapes.js';
+export type { FloorRegion, LevelShapes, Prism, PrismKind, Skipped, UsageShapes } from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,KAAK,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACzD,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AACpE,OAAO,EAAE,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,WAAW,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AACtC,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA"}

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

@@ -0,0 +1,5 @@
+export { catalogueKey } from './catalogue.js';
+export { usageIssues } from './findings.js';
+export { sdfChecksFromEnv, sdfChecksOn, setSdfChecks } from './flag.js';
+export { measureUsage } from './measure.js';
+export { usageShapes } from './shapes.js';

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

@@ -0,0 +1,38 @@
+import type { AnyNode, ItemNode } from '../../schema/index.js';
+import { getLevelElevations } from '../../services/storey.js';
+import { type SupportCache } from './support.js';
+import type { Prism, Skipped } from './types.js';
+import type { Nodes } from './walls.js';
+/** A stored shape no looser than this is read as the build's own outline. */
+export declare const EXACT_SHAPE_TOLERANCE_M = 0.02;
+export type ItemShapes = {
+    itemId: string;
+    levelId: string | null;
+    prisms: Prism[];
+};
+export type ItemContext = {
+    nodes: Nodes;
+    byId: Map<string, AnyNode>;
+    elevations: ReturnType<typeof getLevelElevations>;
+    supportCache: SupportCache;
+};
+export declare const itemContext: (nodes: Nodes) => ItemContext;
+/** One item as prisms in absolute building metres; or `unshaped` with what it is hosted by, or `skipped` with why. */
+export declare function itemShapesOf(item: ItemNode, { nodes, byId, elevations, supportCache }: ItemContext): {
+    shapes: ItemShapes;
+} | {
+    unshaped: string;
+} | {
+    skipped: Skipped;
+};
+/**
+ * Every item as prisms in absolute building metres, filed under its level. An item stands on the
+ * floor under it, on the item that hosts it, or on a wall; one hosted by a ceiling, a roof or a block
+ * is counted in `unshaped`. Its outline is its script's stored shape when it has one, else a box.
+ */
+export declare function itemBodies(nodes: Nodes): {
+    items: ItemShapes[];
+    skipped: Skipped[];
+    unshaped: Record<string, number>;
+};
+//# sourceMappingURL=items.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"items.d.ts","sourceRoot":"","sources":["../../../src/spatial/usage-field/items.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAiB,QAAQ,EAAY,MAAM,cAAc,CAAA;AAE9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAQ1D,OAAO,EAAwB,KAAK,YAAY,EAAE,MAAM,WAAW,CAAA;AACnE,OAAO,KAAK,EAAE,KAAK,EAAQ,OAAO,EAAE,MAAM,SAAS,CAAA;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAKpC,6EAA6E;AAC7E,eAAO,MAAM,uBAAuB,OAAO,CAAA;AAG3C,MAAM,MAAM,UAAU,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,MAAM,EAAE,KAAK,EAAE,CAAA;CAAE,CAAA;AAuLpF,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC1B,UAAU,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAA;IACjD,YAAY,EAAE,YAAY,CAAA;CAC3B,CAAA;AAED,eAAO,MAAM,WAAW,UAAW,KAAK,KAAG,WAKzC,CAAA;AAEF,sHAAsH;AACtH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,QAAQ,EACd,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,EAAE,WAAW,GACrD;IAAE,MAAM,EAAE,UAAU,CAAA;CAAE,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CA8DtE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG;IACxC,KAAK,EAAE,UAAU,EAAE,CAAA;IACnB,OAAO,EAAE,OAAO,EAAE,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACjC,CAaA"}