@pascal-app/core 1.0.4 → 1.0.5

package/dist/agent-operations/project-files.d.ts

@@ -0,0 +1,9 @@
+import { type ProjectFileToolName } from '../agent-tools/project-files.js';
+export type ProjectFileToolExecutor = (request: {
+    name: ProjectFileToolName;
+    projectId?: string;
+    input: Record<string, unknown>;
+    signal?: AbortSignal;
+}) => Promise<unknown>;
+export declare function executeProjectFileTool(name: string, raw: unknown, execute: ProjectFileToolExecutor, signal?: AbortSignal): Promise<unknown>;
+//# sourceMappingURL=project-files.d.ts.map

package/dist/agent-operations/project-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-files.d.ts","sourceRoot":"","sources":["../../src/agent-operations/project-files.ts"],"names":[],"mappings":"AACA,OAAO,EAA+B,KAAK,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AAGpG,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,EAAE;IAC9C,IAAI,EAAE,mBAAmB,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAEtB,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE,uBAAuB,EAChC,MAAM,CAAC,EAAE,WAAW,oBA0BrB"}

package/dist/agent-operations/project-files.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { PROJECT_FILE_TOOL_CONTRACTS } from '../agent-tools/project-files.js';
+import { AgentRefusal } from '../agent-tools/refusal.js';
+export async function executeProjectFileTool(name, raw, execute, signal) {
+    const contract = PROJECT_FILE_TOOL_CONTRACTS.find((tool) => tool.name === name);
+    if (!contract)
+        throw new AgentRefusal('unknown_file_tool', 'This project file tool is not available.');
+    const parsed = z.object(contract.input).strict().safeParse(raw);
+    if (!parsed.success)
+        throw new AgentRefusal('invalid_file_input', 'Invalid project file input.', {
+            issues: parsed.error.issues,
+        });
+    const { projectId, ...input } = parsed.data;
+    if (name === 'upload_project_file') {
+        const valid = input.phase === 'text'
+            ? typeof input.content === 'string'
+            : typeof input.size === 'number' &&
+                (input.phase === 'prepare' ||
+                    (typeof input.fileId === 'string' && typeof input.storageKey === 'string'));
+        if (!valid)
+            throw new AgentRefusal('invalid_file_input', 'Text uploads need content; prepare needs size; complete needs size, fileId and storageKey.');
+    }
+    signal?.throwIfAborted();
+    return execute({ name: contract.name, projectId, input, signal });
+}

package/dist/agent-operations/record-made.d.ts

@@ -0,0 +1,18 @@
+import { type SessionKeep, type SessionRecord } from './scene-checkpoint.js';
+import type { SceneNodes } from './types.js';
+/** What a surface lends the recorder: its scene and the session record it keeps. */
+export type MadeRecorderHost = {
+    getNodes: () => SceneNodes;
+    readSession: () => SessionRecord;
+    keep: (keep: SessionKeep) => void;
+};
+/**
+ * Runs a call and keeps what it made in the agent's session: every node in the scene after it that
+ * was not before, whichever way the call wrote it (a tool of its own, a patch, a shell). Writers that
+ * report their own creations (`applyAgentOutcome`) say the same, and a node is made once.
+ *
+ * The session's first call also takes `start`, before anything is written. A call that replaces the
+ * scene (a load, a clear) begins another session, and what it lays down is not the agent's.
+ */
+export declare function recordMade<Result>(host: MadeRecorderHost, run: () => Promise<Result>): Promise<Result>;
+//# sourceMappingURL=record-made.d.ts.map

package/dist/agent-operations/record-made.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-made.d.ts","sourceRoot":"","sources":["../../src/agent-operations/record-made.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,oFAAoF;AACpF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,MAAM,UAAU,CAAA;IAC1B,WAAW,EAAE,MAAM,aAAa,CAAA;IAChC,IAAI,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAA;CAClC,CAAA;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAAC,MAAM,EACrC,IAAI,EAAE,gBAAgB,EACtB,GAAG,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GACzB,OAAO,CAAC,MAAM,CAAC,CAejB"}

package/dist/agent-operations/record-made.js

@@ -0,0 +1,28 @@
+import { createdBetween, startOfSession, } from './scene-checkpoint.js';
+/**
+ * Runs a call and keeps what it made in the agent's session: every node in the scene after it that
+ * was not before, whichever way the call wrote it (a tool of its own, a patch, a shell). Writers that
+ * report their own creations (`applyAgentOutcome`) say the same, and a node is made once.
+ *
+ * The session's first call also takes `start`, before anything is written. A call that replaces the
+ * scene (a load, a clear) begins another session, and what it lays down is not the agent's.
+ */
+export async function recordMade(host, run) {
+    // A copy: a host may write its own map in place, and a "before" that grows reads nothing as new.
+    const before = { ...host.getNodes() };
+    const first = startOfSession(host.readSession(), before);
+    if (first)
+        host.keep(first);
+    const began = host.readSession().checkpoints.start;
+    try {
+        return await run();
+    }
+    finally {
+        // The session of a scene too large to remember has no start, and nothing to look back from.
+        if (began && host.readSession().checkpoints.start === began) {
+            const made = createdBetween(before, host.getNodes());
+            if (made.length)
+                host.keep({ made });
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+type Pt = [number, number];
+export type RoofRectangle = {
+    minX: number;
+    maxX: number;
+    minZ: number;
+    maxZ: number;
+};
+export type RoofFootprint = {
+    rectangles: RoofRectangle[];
+    roofType: 'gable' | 'hip' | 'flat';
+};
+export declare function roofRectangles(polygons: readonly (readonly Pt[])[]): RoofFootprint;
+/**
+ * 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 declare function buildingFrame(polygons: readonly (readonly Pt[])[]): {
+    angle: number;
+    polygons: Pt[][];
+    toWorld: ([x, z]: Pt) => Pt;
+};
+export {};
+//# sourceMappingURL=roof-footprint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"roof-footprint.d.ts","sourceRoot":"","sources":["../../src/agent-operations/roof-footprint.ts"],"names":[],"mappings":"AAOA,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC1B,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AACtF,MAAM,MAAM,aAAa,GAAG;IAAE,UAAU,EAAE,aAAa,EAAE,CAAC;IAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,CAAA;CAAE,CAAA;AAoE/F,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,CAAC,SAAS,EAAE,EAAE,CAAC,EAAE,GAAG,aAAa,CA6HlF;AA4DD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,SAAS,CAAC,SAAS,EAAE,EAAE,CAAC,EAAE;;;sBAmB5C,EAAE,KAAG,EAAE;EAE5B"}

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