@pascal-app/core 1.0.3 → 1.0.5

package/dist/agent-operations/roof-footprint.js

@@ -0,0 +1,242 @@
+// The rectangles a roof is built from, one roof segment each: the footprint's wings, each as long
+// as it runs inside the footprint, so they overlap where they meet. The roof renders their union,
+// so a wing's hips meet the body's slopes in valleys; wings cut where they meet put a hip end each
+// side of the cut, a notch along the joint. Coordinates scaled from a plan carry float noise that
+// slices the footprint into hundreds of slivers, so the footprint is snapped first, balcony-thin
+// strips join their larger neighbour, and a pathological footprint falls back to its bounding box.
+/** Coordinates snap to 10 cm. */
+const snap = (value) => Math.round(value * 10) / 10;
+/** Parts thinner than this (balconies, slivers) get no roof of their own. */
+const MIN_PART = 1.5;
+const MAX_SEGMENTS = 24;
+/** A house has up to this many wings under hips; past it the roof is flat. */
+const MAX_HIP_WINGS = 6;
+/** A footprint longer than this is a block, not a house: its roof is flat. */
+const BLOCK_LENGTH = 30;
+function inside(polygon, x, z) {
+    let crossed = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const [ax, az] = polygon[i];
+        const [bx, bz] = polygon[j];
+        if (az > z !== bz > z && x < ((bx - ax) * (z - az)) / (bz - az) + ax)
+            crossed = !crossed;
+    }
+    return crossed;
+}
+/** The footprint is the union of its plates: where two slabs overlap, both cover it. */
+const insideAny = (polygons, x, z) => polygons.some((polygon) => inside(polygon, x, z));
+/**
+ * A strip of cells thinner than a part keeps only what its larger neighbour along the other axis
+ * also has: balconies drop out and the wings they stand on stay whole. Along z, then along x.
+ */
+function dropThinStrips(cells, xs, zs) {
+    const sweep = (rows, columns, at, set, size) => {
+        for (let r = 0; r < rows; r++) {
+            if (size(r) >= MIN_PART)
+                continue;
+            const neighbours = [r - 1, r + 1].filter((n) => n >= 0 && n < rows && size(n) >= MIN_PART);
+            const larger = neighbours.sort((a, b) => size(b) - size(a))[0];
+            if (larger === undefined)
+                continue;
+            for (let c = 0; c < columns; c++)
+                if (at(r, c) && !at(larger, c))
+                    set(r, c);
+        }
+    };
+    const nx = xs.length - 1;
+    const nz = zs.length - 1;
+    sweep(nz, nx, (j, i) => cells[i][j], (j, i) => {
+        cells[i][j] = false;
+    }, (j) => zs[j + 1] - zs[j]);
+    sweep(nx, nz, (i, j) => cells[i][j], (i, j) => {
+        cells[i][j] = false;
+    }, (i) => xs[i + 1] - xs[i]);
+}
+export function roofRectangles(polygons) {
+    const snapped = polygons.map((polygon) => polygon.map(([x, z]) => [snap(x), snap(z)]));
+    const all = snapped.flat();
+    const bounds = {
+        minX: Math.min(...all.map((point) => point[0])),
+        maxX: Math.max(...all.map((point) => point[0])),
+        minZ: Math.min(...all.map((point) => point[1])),
+        maxZ: Math.max(...all.map((point) => point[1])),
+    };
+    const xs = [...new Set(all.map((point) => point[0]))].sort((a, b) => a - b);
+    const zs = [...new Set(all.map((point) => point[1]))].sort((a, b) => a - b);
+    const nx = xs.length - 1;
+    const nz = zs.length - 1;
+    const cells = Array.from({ length: nx }, (_, i) => Array.from({ length: nz }, (_, j) => insideAny(snapped, (xs[i] + xs[i + 1]) / 2, (zs[j] + zs[j + 1]) / 2)));
+    dropThinStrips(cells, xs, zs);
+    // Inside cells counted from the corner, to test a rectangle in one step.
+    const count = Array.from({ length: nx + 1 }, () => new Array(nz + 1).fill(0));
+    for (let i = 0; i < nx; i++)
+        for (let j = 0; j < nz; j++)
+            count[i + 1][j + 1] =
+                (cells[i][j] ? 1 : 0) + count[i][j + 1] + count[i + 1][j] - count[i][j];
+    const filled = (i0, i1, j0, j1) => i0 >= 0 &&
+        j0 >= 0 &&
+        i1 <= nx &&
+        j1 <= nz &&
+        count[i1][j1] - count[i0][j1] - count[i1][j0] + count[i0][j0] === (i1 - i0) * (j1 - j0);
+    const wings = [];
+    for (let i0 = 0; i0 < nx; i0++)
+        for (let i1 = i0 + 1; i1 <= nx; i1++) {
+            if (!filled(i0, i1, 0, 0) && xs[i1] - xs[i0] < MIN_PART && i1 < nx)
+                continue;
+            for (let j0 = 0; j0 < nz; j0++)
+                for (let j1 = j0 + 1; j1 <= nz; j1++) {
+                    if (!filled(i0, i1, j0, j1))
+                        break;
+                    if (xs[i1] - xs[i0] < MIN_PART || zs[j1] - zs[j0] < MIN_PART)
+                        continue;
+                    const extends_ = filled(i0 - 1, i1, j0, j1) ||
+                        filled(i0, i1 + 1, j0, j1) ||
+                        filled(i0, i1, j0 - 1, j1) ||
+                        filled(i0, i1, j0, j1 + 1);
+                    if (!extends_)
+                        wings.push({ i0, i1, j0, j1 });
+                }
+        }
+    // Greedy: the wing covering most of what is left, the longer through the body on a tie, until
+    // what is left is smaller than a part.
+    const covered = cells.map((column) => column.map(() => false));
+    const area = (w) => (xs[w.i1] - xs[w.i0]) * (zs[w.j1] - zs[w.j0]);
+    const gain = (w) => {
+        let total = 0;
+        for (let i = w.i0; i < w.i1; i++)
+            for (let j = w.j0; j < w.j1; j++)
+                if (!covered[i][j])
+                    total += (xs[i + 1] - xs[i]) * (zs[j + 1] - zs[j]);
+        return total;
+    };
+    const rectangles = [];
+    while (rectangles.length <= MAX_SEGMENTS) {
+        let best = null;
+        let bestGain = 0;
+        for (const wing of wings) {
+            const g = gain(wing);
+            if (g > bestGain + 1e-9 ||
+                (best && Math.abs(g - bestGain) <= 1e-9 && area(wing) > area(best))) {
+                best = wing;
+                bestGain = g;
+            }
+        }
+        if (!best || bestGain < MIN_PART * MIN_PART)
+            break;
+        for (let i = best.i0; i < best.i1; i++)
+            for (let j = best.j0; j < best.j1; j++)
+                covered[i][j] = true;
+        rectangles.push({
+            minX: xs[best.i0],
+            maxX: xs[best.i1],
+            minZ: zs[best.j0],
+            maxZ: zs[best.j1],
+        });
+    }
+    // Outside the footprint within a rectangle on the grid: what a roof over it adds past the house.
+    const inside = Array.from({ length: nx + 1 }, () => new Array(nz + 1).fill(0));
+    for (let i = 0; i < nx; i++)
+        for (let j = 0; j < nz; j++)
+            inside[i + 1][j + 1] =
+                (cells[i][j] ? (xs[i + 1] - xs[i]) * (zs[j + 1] - zs[j]) : 0) +
+                    inside[i][j + 1] +
+                    inside[i + 1][j] -
+                    inside[i][j];
+    const at = (values, value) => values.indexOf(value);
+    const outside = (r) => {
+        const [i0, i1, j0, j1] = [at(xs, r.minX), at(xs, r.maxX), at(zs, r.minZ), at(zs, r.maxZ)];
+        const within = inside[i1][j1] - inside[i0][j1] - inside[i1][j0] + inside[i0][j0];
+        return (r.maxX - r.minX) * (r.maxZ - r.minZ) - within;
+    };
+    // Of a rectangle, how much the others cover: on the grid, cell by cell.
+    const coveredBy = (r, others) => {
+        let total = 0;
+        for (let i = at(xs, r.minX); i < at(xs, r.maxX); i++)
+            for (let j = at(zs, r.minZ); j < at(zs, r.maxZ); j++) {
+                const [cx, cz] = [(xs[i] + xs[i + 1]) / 2, (zs[j] + zs[j + 1]) / 2];
+                if (others.some((o) => cx > o.minX && cx < o.maxX && cz > o.minZ && cz < o.maxZ))
+                    total += (xs[i + 1] - xs[i]) * (zs[j + 1] - zs[j]);
+            }
+        return total;
+    };
+    const absorbed = mergeWings(rectangles, outside, coveredBy);
+    const chosen = absorbed.length === 0 || absorbed.length > MAX_SEGMENTS ? [bounds] : absorbed;
+    const long = Math.max(bounds.maxX - bounds.minX, bounds.maxZ - bounds.minZ);
+    const roofType = long > BLOCK_LENGTH || chosen.length > MAX_HIP_WINGS
+        ? 'flat'
+        : chosen.length === 1
+            ? 'gable'
+            : 'hip';
+    return { rectangles: chosen, roofType };
+}
+/**
+ * A merge may add roof outside the house up to this share of what the wing it takes in covered on
+ * its own: a jog's corners against its band, not a projection's notches against its own hip.
+ */
+const MERGE_SHARE = 0.5;
+/**
+ * A roof runs over a jog: two wings become their bounding rectangle when that adds little roof
+ * outside the house against what the wing taken in covered on its own (a strip along a jog, a band
+ * a few decimetres proud). A garage, a projection, a courtyard's arms cover more on their own than a
+ * merge would add outside, and keep their hips.
+ */
+function mergeWings(wings, outside, covered) {
+    const area = (r) => (r.maxX - r.minX) * (r.maxZ - r.minZ);
+    const union = (a, b) => ({
+        minX: Math.min(a.minX, b.minX),
+        maxX: Math.max(a.maxX, b.maxX),
+        minZ: Math.min(a.minZ, b.minZ),
+        maxZ: Math.max(a.maxZ, b.maxZ),
+    });
+    const contains = (a, b) => a.minX <= b.minX && a.maxX >= b.maxX && a.minZ <= b.minZ && a.maxZ >= b.maxZ;
+    let current = [...wings];
+    while (true) {
+        let best = null;
+        for (const keep of current)
+            for (const take of current) {
+                if (keep === take)
+                    continue;
+                // What the wing taken in covers that no other wing does.
+                const own = area(take) -
+                    covered(take, current.filter((r) => r !== take));
+                if (own <= 0)
+                    continue;
+                const grown = union(keep, take);
+                const ratio = (outside(grown) - outside(keep)) / own;
+                if (ratio <= MERGE_SHARE + 1e-9 && (!best || ratio < best.ratio))
+                    best = { keep, take, grown, ratio };
+            }
+        if (!best)
+            return current;
+        const { keep, take, grown } = best;
+        current = current
+            .map((r) => (r === keep ? grown : r))
+            .filter((r) => r === grown || (r !== take && !contains(grown, r)));
+    }
+}
+/**
+ * The frame a roof is swept in: the footprint's own axes, from its longest edge, so a rotated
+ * building gets whole wings, not a staircase of segments along the world axes. The rotation
+ * convention is a roof node's: local (x, z) → (x c + z s, -x s + z c).
+ */
+export function buildingFrame(polygons) {
+    let longest = { length: 0, dx: 1, dz: 0 };
+    for (const polygon of polygons)
+        for (let i = 0; i < polygon.length; i++) {
+            const [ax, az] = polygon[i];
+            const [bx, bz] = polygon[(i + 1) % polygon.length];
+            const length = Math.hypot(bx - ax, bz - az);
+            if (length > longest.length)
+                longest = { length, dx: bx - ax, dz: bz - az };
+        }
+    // The local x axis runs along the longest edge, turned to the nearest quarter of the world's.
+    const edge = Math.atan2(-longest.dz, longest.dx);
+    const angle = edge - Math.round(edge / (Math.PI / 2)) * (Math.PI / 2);
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return {
+        angle,
+        polygons: polygons.map((polygon) => polygon.map(([x, z]) => [x * c - z * s, x * s + z * c])),
+        toWorld: ([x, z]) => [x * c + z * s, -x * s + z * c],
+    };
+}

package/dist/agent-operations/roof-writes.d.ts

@@ -0,0 +1,20 @@
+import { AgentRefusal } from '../agent-tools/refusal.js';
+import type { NodeWrite, SceneNodes } from './types.js';
+/**
+ * Storey content aimed at a level serving as its building's roof level: the refusal, naming the
+ * storey it covers so one retry lands; null on a storey.
+ */
+export declare function roofLevelRefusal(nodes: SceneNodes, levelId: string, what: string): AgentRefusal | null;
+/** A level serving as its building's roof level holds roofs, not rooms: storey content is refused there. */
+export declare function refuseRoofLevel(nodes: SceneNodes, levelId: string, what: string): void;
+/**
+ * The rule on a write's operations, in their order, against the scene they write to: storey
+ * content created or moved onto a roof level (`roof_level`), a walled level declared the roof level
+ * (`roof_level_holds_storey`) and floor indexes putting a roof level under a storey
+ * (`roof_level_on_top`) are refused, naming the operation's index. A storey created at or above a
+ * roof level moves the roof levels up over it, and each roof the write puts on its walls' storey
+ * is seated (`planRoofSeats`): both appended to `ops` as operations of their own, so every index
+ * stays the model's. Returns a note per change.
+ */
+export declare function seatWrittenRoofs(ops: NodeWrite[], scene: SceneNodes): string[];
+//# sourceMappingURL=roof-writes.d.ts.map

package/dist/agent-operations/roof-writes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-writes.d.ts","sourceRoot":"","sources":["../../src/agent-operations/roof-writes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAU,MAAM,wBAAwB,CAAA;AAc7D,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AA2BpD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,YAAY,GAAG,IAAI,CAKrB;AAED,4GAA4G;AAC5G,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAG/E;AASD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CA0I9E"}

package/dist/agent-operations/roof-writes.js

@@ -0,0 +1,165 @@
+import { AgentRefusal, refuse } from '../agent-tools/refusal.js';
+import { getLevelDisplayName } from '../lib/level-name.js';
+import { parseNode } from '../schema/index.js';
+import { isRoofGeometry, isRoofLevel, isStoreyContent, liftRoofLevels, roofLevelOrderBreach, servesAsRoofLevel, storeyOf, } from '../services/roof-level.js';
+import { planRoofSeats } from '../services/roof-move.js';
+import { applySceneWrites } from './apply-changes.js';
+/**
+ * The roof-level rule on writes that name every node and parent themselves (apply_patch,
+ * update_node, a saved graph): a roof written on the storey whose walls carry it goes to the level
+ * above, said in a note; what the rule cannot place is refused, naming what would work.
+ */
+const nameOf = (nodes, id) => {
+    const node = nodes[id];
+    return node?.type === 'level' ? `${getLevelDisplayName(node)} (${id})` : id;
+};
+function onRoofLevel(nodes, levelId, what, details = {}) {
+    const storeyId = storeyOf(nodes, levelId);
+    return new AgentRefusal('roof_level', `${nameOf(nodes, levelId)} is a roof level, not a storey: ${what} belongs on a storey${storeyId === levelId ? '' : `, such as ${nameOf(nodes, storeyId)}, the one it covers`}. Add a storey with add_level if the building needs one.`, { ...details, levelId, storeyId });
+}
+/**
+ * Storey content aimed at a level serving as its building's roof level: the refusal, naming the
+ * storey it covers so one retry lands; null on a storey.
+ */
+export function roofLevelRefusal(nodes, levelId, what) {
+    const level = nodes[levelId];
+    return level?.type === 'level' && servesAsRoofLevel(nodes, level)
+        ? onRoofLevel(nodes, levelId, what)
+        : null;
+}
+/** A level serving as its building's roof level holds roofs, not rooms: storey content is refused there. */
+export function refuseRoofLevel(nodes, levelId, what) {
+    const refusal = roofLevelRefusal(nodes, levelId, what);
+    if (refusal)
+        throw refusal;
+}
+const roleOf = (write) => write.op === 'create'
+    ? write.node.metadata?.role
+    : write.op === 'update'
+        ? write.data.metadata?.role
+        : undefined;
+/**
+ * The rule on a write's operations, in their order, against the scene they write to: storey
+ * content created or moved onto a roof level (`roof_level`), a walled level declared the roof level
+ * (`roof_level_holds_storey`) and floor indexes putting a roof level under a storey
+ * (`roof_level_on_top`) are refused, naming the operation's index. A storey created at or above a
+ * roof level moves the roof levels up over it, and each roof the write puts on its walls' storey
+ * is seated (`planRoofSeats`): both appended to `ops` as operations of their own, so every index
+ * stays the model's. Returns a note per change.
+ */
+export function seatWrittenRoofs(ops, scene) {
+    // Parsed as the store creates them, so a level written without `children` gets its list.
+    const writes = ops.map((write) => {
+        if (write.op !== 'create')
+            return write;
+        const parsed = parseNode(write.node);
+        return { ...write, node: parsed.success ? parsed.data : write.node };
+    });
+    const after = applySceneWrites(scene, writes);
+    writes.forEach((write, index) => {
+        const placed = write.op === 'create'
+            ? {
+                id: write.node.id,
+                type: write.node.type,
+                parentId: write.parentId ?? write.node.parentId,
+                metadata: after[write.node.id]?.metadata,
+            }
+            : write.op === 'update' &&
+                (typeof write.data.parentId === 'string' ||
+                    (isRoofGeometry(scene[write.id]) && !isRoofGeometry(after[write.id])))
+                ? after[write.id]
+                : null;
+        if (!placed?.parentId || !isStoreyContent(placed.type, placed.metadata))
+            return;
+        // A retained assembly's separately addressed children still belong to its level.
+        let parentId = placed.parentId;
+        let retainedRoofAncestor = false;
+        const seen = new Set();
+        while (after[parentId]?.type === 'item' && !seen.has(parentId)) {
+            seen.add(parentId);
+            retainedRoofAncestor ||= isRoofGeometry(after[parentId]);
+            const next = after[parentId]?.parentId;
+            if (!next)
+                break;
+            parentId = next;
+        }
+        if (!retainedRoofAncestor)
+            parentId = placed.parentId;
+        const prior = scene[parentId];
+        const what = `a ${placed.type}`;
+        if (isRoofLevel(after[parentId]))
+            throw onRoofLevel(after, parentId, what, { index, id: placed.id });
+        if (prior?.type === 'level' && servesAsRoofLevel(scene, prior))
+            throw onRoofLevel(scene, parentId, what, { index, id: placed.id });
+    });
+    writes.forEach((write, index) => {
+        const id = write.op === 'create' ? write.node.id : write.op === 'update' ? write.id : null;
+        const level = id ? after[id] : undefined;
+        if (!id || roleOf(write) !== 'roof' || isRoofLevel(scene[id]) || level?.type !== 'level')
+            return;
+        const held = [
+            ...new Set(level.children
+                .map((child) => after[child])
+                .filter((child) => isStoreyContent(child?.type, child?.metadata))
+                .map((child) => child.type)),
+        ];
+        if (held.length)
+            refuse('roof_level_holds_storey', `${nameOf(after, id)} holds ${held.map((type) => `a ${type}`).join(', ')}, a storey's content, so it cannot be declared the roof level: a roof level holds roofs only. create_roof puts a roof over a storey on the level the rule gives it.`, { index, id, levelId: id });
+    });
+    const floors = new Map(writes.flatMap((write) => write.op === 'update' &&
+        typeof write.data.level === 'number' &&
+        scene[write.id]?.type === 'level'
+        ? [[write.id, write.data.level]]
+        : []));
+    const breach = floors.size ? roofLevelOrderBreach(scene, floors) : null;
+    if (breach) {
+        const index = writes.findIndex((write) => write.op === 'update' &&
+            floors.has(write.id) &&
+            (write.id === breach.roofId || write.id === breach.storeyId));
+        refuse('roof_level_on_top', `This write puts ${nameOf(after, breach.roofId)}, the roof level, under the storey ${nameOf(after, breach.storeyId)}: a building's roof level stays above its storeys. Keep its floor index over theirs; a new storey goes under it (add_level).`, {
+            index,
+            id: writes[index].id,
+            levelId: breach.roofId,
+            storeyId: breach.storeyId,
+        });
+    }
+    const notes = [];
+    const appended = [];
+    // A storey created at or above a roof level, or a roof level created at or under a storey: the
+    // building's roof levels go up over its storeys.
+    const buildings = new Set(writes.flatMap((write) => write.op === 'create' && write.node.type === 'level' ? [after[write.node.id]?.parentId] : []));
+    for (const buildingId of buildings) {
+        if (!buildingId)
+            continue;
+        for (const { id, data } of liftRoofLevels(scene, after, buildingId)) {
+            appended.push({ op: 'update', id, data });
+            notes.push(`${nameOf(after, id)} moved up to floor index ${data.level}: a building's roof level stays above its storeys.`);
+        }
+    }
+    const seat = planRoofSeats(scene, applySceneWrites(after, appended));
+    if (seat) {
+        const moved = new Map(seat.changes.update.map(({ id, data }) => [id, data.parentId]));
+        // A parent the write creates listing a roof the seat moves would list it twice.
+        for (const write of ops) {
+            if (write.op !== 'create')
+                continue;
+            const children = write.node.children;
+            if (!Array.isArray(children))
+                continue;
+            const kept = children.filter((id) => {
+                const to = moved.get(id);
+                return to === undefined || to === write.node.id;
+            });
+            if (kept.length !== children.length)
+                write.node = { ...write.node, children: kept };
+        }
+        appended.push(...seat.changes.create.map(({ node, parentId }) => ({
+            op: 'create',
+            node,
+            ...(parentId ? { parentId } : {}),
+        })), ...seat.changes.update.map(({ id, data }) => ({ op: 'update', id, data })));
+        notes.push(...seat.notes);
+    }
+    ops.push(...appended);
+    return notes;
+}

package/dist/agent-operations/room-findings.d.ts

@@ -0,0 +1,54 @@
+import type { SceneNodes } from './types.js';
+/** A space the walls and separators enclose, where a finding about it places it. */
+type SpacePlace = {
+    levelId: string;
+    /** The space's floor area, m². */
+    area: number;
+    /** A point inside the space, in plan [x, z]. */
+    at: [number, number];
+    wallIds: string[];
+};
+/**
+ * A level's rooms against the spaces its walls and separators enclose (the editor's detected
+ * spaces): a space no zone covers, a space several zones split, a room the walls do not close, a
+ * room with no name.
+ */
+export type RoomFinding = ({
+    type: 'space_no_room';
+    message: string;
+} & SpacePlace) | ({
+    type: 'space_many_rooms';
+    message: string;
+    zoneIds: string[];
+} & SpacePlace) | {
+    type: 'room_not_enclosed';
+    message: string;
+    /** On a zone left generic: a room still missing a wall, or a courtyard. */
+    severity?: 'info';
+    levelId: string;
+    zoneId: string;
+} | {
+    type: 'room_unnamed';
+    message: string;
+    severity: 'info';
+    levelId: string;
+    zoneId: string;
+};
+/**
+ * A room is a zone with `spaceRole: 'room'`, or a generic one walls of a room's height bound along
+ * most of its outline, which may be a room drawn before its last wall (no reconcile could adopt
+ * it) or a courtyard, so what is found on it is info; a zone garden walls bound, or no walls (an
+ * analysis area), is no room. Every space the walls enclose wants one zone over it (any zone: a drawn one is
+ * adopted as the room on load): none, or several rooms lying in it (the reconciler's "Room N"
+ * beside a zone drawn over it, a plan's rooms split by lines no wall draws), is a finding. Every
+ * room wants walls or separators closing around it, and a name. A terrace closes with separators,
+ * so it is enclosed; a room a person declared open (`enclosureStatus: 'open'` on a room the walls
+ * never derived) needs no walls; an automatic room the reconciler opened when its walls stopped
+ * closing it does.
+ */
+export declare function roomFindings(nodes: SceneNodes, levelId: string, levelName: string): {
+    spaces: number;
+    issues: RoomFinding[];
+};
+export {};
+//# sourceMappingURL=room-findings.d.ts.map

package/dist/agent-operations/room-findings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-findings.d.ts","sourceRoot":"","sources":["../../src/agent-operations/room-findings.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,oFAAoF;AACpF,KAAK,UAAU,GAAG;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,gDAAgD;IAChD,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpB,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,WAAW,GACnB,CAAC;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,UAAU,CAAC,GACzD,CAAC;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,UAAU,CAAC,GAC/E;IACE,IAAI,EAAE,mBAAmB,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACf,GACD;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AA6EhG;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,EAAE,CAAA;CAAE,CAmF3C"}

package/dist/agent-operations/room-findings.js

@@ -0,0 +1,143 @@
+import { area, intersection, union } from '../lib/polygon-boolean.js';
+import { polygonInteriorPoint } from '../lib/polygon-label.js';
+import { distanceToSegment } from '../lib/room-topology-index.js';
+import { detectSpacesForLevel } from '../lib/space-detection.js';
+import { nodesOnLevel } from './scene-queries.js';
+/** No name, or the bare word an older scene or a blank name leaves: "Room", "Zone". */
+const PLACEHOLDER_NAME = /^\s*(room|zone)?\s*$/i;
+/** A space is covered, a room enclosed, a zone in a space, and a zone walled like a room, past half. */
+const HALF = 0.5;
+/** How far past a wall's face its outline may run and still be walled, m. */
+const ALONG_WALL = 0.1;
+/** The step a zone's outline is sampled at to see how much of it walls run along, m. */
+const OUTLINE_STEP = 0.25;
+/** A wall that bounds a room stands at least this high, m; a garden wall is lower. */
+const ROOM_WALL_HEIGHT = 2;
+const round = (value) => Math.round(value * 100) / 100;
+function shapeOf(outer, holes = []) {
+    const polygon = { outer, holes };
+    const xs = outer.map(([x]) => x);
+    const zs = outer.map(([, z]) => z);
+    return {
+        polygon,
+        box: [Math.min(...xs), Math.min(...zs), Math.max(...xs), Math.max(...zs)],
+        area: area([polygon]),
+    };
+}
+const overlap = (a, b) => a.box[0] < b.box[2] && b.box[0] < a.box[2] && a.box[1] < b.box[3] && b.box[1] < a.box[3];
+/** How much of `part` the shapes cover, 0 to 1; only the shapes whose boxes meet it are joined. */
+function covered(part, cover) {
+    if (part.area <= 0)
+        return 0;
+    const near = cover.filter((shape) => overlap(part, shape));
+    if (near.length === 0)
+        return 0;
+    const joined = near.length === 1 ? near[0].polygon : union(near.map((shape) => shape.polygon));
+    return area(intersection(part.polygon, joined)) / part.area;
+}
+/** How much of a zone's outline runs along a wall, 0 to 1: a zone mostly walled is meant as a room. */
+function walled(zone, walls) {
+    const ring = zone.polygon;
+    let along = 0;
+    let samples = 0;
+    ring.forEach((start, i) => {
+        const end = ring[(i + 1) % ring.length];
+        const steps = Math.max(1, Math.ceil(Math.hypot(end[0] - start[0], end[1] - start[1]) / OUTLINE_STEP));
+        for (let k = 0; k < steps; k++) {
+            const t = (k + 0.5) / steps;
+            const point = [
+                start[0] + (end[0] - start[0]) * t,
+                start[1] + (end[1] - start[1]) * t,
+            ];
+            samples++;
+            if (walls.some((wall) => distanceToSegment(point, wall.start, wall.end) <=
+                (wall.thickness ?? 0.2) / 2 + ALONG_WALL))
+                along++;
+        }
+    });
+    return samples > 0 ? along / samples : 0;
+}
+const label = (zone) => PLACEHOLDER_NAME.test(zone.name) ? zone.id : `"${zone.name}" (${zone.id})`;
+/**
+ * A room is a zone with `spaceRole: 'room'`, or a generic one walls of a room's height bound along
+ * most of its outline, which may be a room drawn before its last wall (no reconcile could adopt
+ * it) or a courtyard, so what is found on it is info; a zone garden walls bound, or no walls (an
+ * analysis area), is no room. Every space the walls enclose wants one zone over it (any zone: a drawn one is
+ * adopted as the room on load): none, or several rooms lying in it (the reconciler's "Room N"
+ * beside a zone drawn over it, a plan's rooms split by lines no wall draws), is a finding. Every
+ * room wants walls or separators closing around it, and a name. A terrace closes with separators,
+ * so it is enclosed; a room a person declared open (`enclosureStatus: 'open'` on a room the walls
+ * never derived) needs no walls; an automatic room the reconciler opened when its walls stopped
+ * closing it does.
+ */
+export function roomFindings(nodes, levelId, levelName) {
+    const onLevel = nodesOnLevel(nodes, levelId);
+    const walls = onLevel.filter((node) => node.type === 'wall');
+    const boundaries = onLevel.filter((node) => node.type === 'wall' || node.type === 'separator');
+    const zones = onLevel.filter((node) => node.type === 'zone' && node.polygon.length >= 3);
+    const { spaces } = detectSpacesForLevel(levelId, boundaries);
+    const spaceShapes = spaces.map((space) => shapeOf(space.polygon, space.holes));
+    const zoneShapes = zones.map((zone) => shapeOf(zone.polygon, zone.holes));
+    // A wall with no height of its own stands as high as its storey.
+    const roomWalls = walls.filter((wall) => (wall.height ?? ROOM_WALL_HEIGHT) >= ROOM_WALL_HEIGHT);
+    const rooms = zones.map((zone) => zone.spaceRole === 'room' || walled(zone, roomWalls) >= HALF);
+    const issues = [];
+    spaces.forEach((space, index) => {
+        const shape = spaceShapes[index];
+        // A mezzanine stands over its room, and a zone no room (an analysis area) lies in it: neither
+        // splits the space.
+        const inside = zones.filter((zone, z) => rooms[z] && zone.floor?.support !== 'open' && covered(zoneShapes[z], [shape]) >= HALF);
+        const noRoom = covered(shape, zoneShapes) < HALF;
+        if (!noRoom && inside.length < 2)
+            return;
+        const spaceArea = round(shape.area);
+        const [x, z] = polygonInteriorPoint(space, true).map(round);
+        const place = {
+            levelId,
+            area: spaceArea,
+            at: [x, z],
+            wallIds: space.wallIds,
+        };
+        const where = `On ${levelName}, walls ${space.wallIds.join(', ')} enclose a ${spaceArea.toFixed(1)} m² space at (${x.toFixed(2)}, ${z.toFixed(2)})`;
+        issues.push(noRoom
+            ? { type: 'space_no_room', message: `${where} with no room over it.`, ...place }
+            : {
+                type: 'space_many_rooms',
+                message: `${where} with ${inside.length} rooms over it and no wall between them: ${inside.map(label).join(', ')}. Keep one room per space: name the space's room (create_room over the whole space names it) and delete the others, or divide the space with a wall or separator.`,
+                ...place,
+                zoneIds: inside.map((zone) => zone.id),
+            });
+    });
+    zones.forEach((zone, index) => {
+        if (!rooms[index])
+            return;
+        const room = zone.spaceRole === 'room';
+        const unnamed = PLACEHOLDER_NAME.test(zone.name);
+        const declaredOpen = zone.enclosureStatus === 'open' && !zone.autoFromWalls;
+        const opened = zone.enclosureStatus === 'open' && zone.autoFromWalls;
+        if (!declaredOpen && (opened || covered(zoneShapes[index], spaceShapes) < HALF))
+            issues.push(room
+                ? {
+                    type: 'room_not_enclosed',
+                    message: `Room ${label(zone)} on ${levelName}: its walls do not close around it.`,
+                    levelId,
+                    zoneId: zone.id,
+                }
+                : {
+                    type: 'room_not_enclosed',
+                    message: `Zone ${label(zone)} on ${levelName}: walls run along most of it and do not close around it, a room missing a wall or a courtyard.`,
+                    severity: 'info',
+                    levelId,
+                    zoneId: zone.id,
+                });
+        if (unnamed)
+            issues.push({
+                type: 'room_unnamed',
+                message: `Room ${zone.id} on ${levelName} has no name${zone.name.trim() ? ` but "${zone.name.trim()}"` : ''}.`,
+                severity: 'info',
+                levelId,
+                zoneId: zone.id,
+            });
+    });
+    return { spaces: spaces.length, issues };
+}

package/dist/agent-operations/room-floor-script.d.ts

@@ -0,0 +1,23 @@
+import { type FloorScriptInputs } from '../lib/floor-script.js';
+import { type CompiledGeometryScript } from '../schema/index.js';
+import type { AgentOperation } from './types.js';
+export type SetRoomFloorScriptInput = {
+    zoneId: string;
+    /** The module compiled for `inputs` (`floorScriptInputs` of the room, read before compiling). */
+    compiled: CompiledGeometryScript;
+    inputs: FloorScriptInputs;
+} | {
+    zoneId: string;
+    remove: true;
+};
+/**
+ * `setRoomFloorScript`: a room's floor finish built by a three.js module, or the module taken off.
+ * The host reads the room's floor (`floorScriptInputs`), compiles the module for it (geometry-script
+ * `inputs`: the module reads `params.polygon`, `params.holes`, `params.elevation`, in level
+ * coordinates) and stores the artifacts; this writes the result on the zone, with the key of the
+ * floor it was built for. When the structure re-derives the room's floor the script is stale and
+ * `refreshFinishScripts` runs it again. The script owns the floor's colours: paint on that floor is
+ * refused while it is there.
+ */
+export declare const setRoomFloorScript: AgentOperation<SetRoomFloorScriptInput>;
+//# sourceMappingURL=room-floor-script.d.ts.map

package/dist/agent-operations/room-floor-script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-floor-script.d.ts","sourceRoot":"","sources":["../../src/agent-operations/room-floor-script.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,iBAAiB,EAAwC,MAAM,qBAAqB,CAAA;AAElG,OAAO,EAAE,KAAK,sBAAsB,EAAkC,MAAM,WAAW,CAAA;AACvF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,MAAM,MAAM,uBAAuB,GAC/B;IACE,MAAM,EAAE,MAAM,CAAA;IACd,iGAAiG;IACjG,QAAQ,EAAE,sBAAsB,CAAA;IAChC,MAAM,EAAE,iBAAiB,CAAA;CAC1B,GACD;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAA;AAIpC;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,uBAAuB,CAsDtE,CAAA"}