@pascal-app/core 1.0.4 → 1.0.6

package/dist/agent-operations/authored-scene-merge.d.ts

@@ -0,0 +1,4 @@
+import type { SceneChanges, SceneNodes } from './types.js';
+/** Apply a design delta against its last candidate, preserving edits made since that candidate. */
+export declare function authoredSceneChanges(current: SceneNodes, base: SceneNodes, next: SceneNodes): SceneChanges;
+//# sourceMappingURL=authored-scene-merge.d.ts.map

package/dist/agent-operations/authored-scene-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authored-scene-merge.d.ts","sourceRoot":"","sources":["../../src/agent-operations/authored-scene-merge.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAkDvD,mGAAmG;AACnG,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,UAAU,EACnB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,UAAU,GACf,YAAY,CAwDd"}

package/dist/agent-operations/authored-scene-merge.js

@@ -0,0 +1,96 @@
+import { refuse } from '../agent-tools/refusal.js';
+const equal = (a, b) => {
+    if (Object.is(a, b))
+        return true;
+    if (Array.isArray(a) && Array.isArray(b))
+        return a.length === b.length && a.every((value, index) => equal(value, b[index]));
+    if (record(a) && record(b)) {
+        const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+        return [...keys].every((key) => equal(a[key], b[key]));
+    }
+    return false;
+};
+const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+function merged(base, current, next, path) {
+    if (equal(base, next) || equal(current, next))
+        return current;
+    if (equal(base, current))
+        return next;
+    if (record(base) && record(current) && record(next)) {
+        const result = {};
+        for (const key of new Set([
+            ...Object.keys(base),
+            ...Object.keys(current),
+            ...Object.keys(next),
+        ])) {
+            const value = merged(base[key], current[key], next[key], `${path}.${key}`);
+            if (value !== undefined)
+                result[key] = value;
+        }
+        return result;
+    }
+    if (path.endsWith('.children') &&
+        Array.isArray(base) &&
+        Array.isArray(current) &&
+        Array.isArray(next)) {
+        return [
+            ...new Set([
+                ...current.filter((id) => !base.includes(id) || next.includes(id)),
+                ...next.filter((id) => !base.includes(id)),
+            ]),
+        ];
+    }
+    refuse('authored_edit_conflict', `Both the design and the current scene changed ${path}. Preserve the current edit and resolve this change explicitly.`, { path, mutationApplied: false });
+}
+/** Apply a design delta against its last candidate, preserving edits made since that candidate. */
+export function authoredSceneChanges(current, base, next) {
+    const create = [];
+    const update = [];
+    const remove = [];
+    const effective = { ...current };
+    for (const id of new Set([...Object.keys(base), ...Object.keys(next)])) {
+        const old = base[id];
+        const now = current[id];
+        const desired = next[id];
+        if (!old) {
+            if (!desired)
+                continue;
+            if (now) {
+                if (!equal(now, desired))
+                    refuse('authored_id_conflict', `Node ${id} already belongs to existing work.`, {
+                        mutationApplied: false,
+                    });
+                continue;
+            }
+            create.push({ node: desired, parentId: desired.parentId ?? undefined });
+            effective[id] = desired;
+        }
+        else if (!now) {
+            // A person's deletion wins over regeneration, including a same-payload replay.
+            delete effective[id];
+        }
+        else if (!desired) {
+            if (!equal(now, old))
+                refuse('authored_edit_conflict', `Node ${id} was edited after conversion and cannot be removed by regeneration.`, { mutationApplied: false });
+            remove.push(id);
+            delete effective[id];
+        }
+        else {
+            const value = merged(old, now, desired, id);
+            effective[id] = value;
+            if (!equal(now, value)) {
+                const data = {};
+                for (const key of new Set([...Object.keys(now), ...Object.keys(value)])) {
+                    if (!equal(now[key], value[key]))
+                        data[key] = value[key];
+                }
+                update.push({ id, data: data });
+            }
+        }
+    }
+    for (const node of Object.values(effective)) {
+        if (node.parentId && !effective[node.parentId])
+            refuse('authored_edit_conflict', `Removing ${node.parentId} would discard or orphan ${node.id}. Preserve the current hierarchy.`, { mutationApplied: false });
+    }
+    return { create, update, delete: remove };
+}

package/dist/agent-operations/batch.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import type { AgentOperation } from './types.js';
+type BatchInput = {
+    calls: {
+        tool: string;
+        input?: Record<string, unknown>;
+    }[];
+    onRefusal?: 'stop' | 'skip';
+};
+type Contract = {
+    name: string;
+    input: Record<string, z.ZodType>;
+};
+/**
+ * `run_batch`: shared tools in order, each on the scene the calls before it left, their changes
+ * merged into one set — one undo step, one write on either surface. The user: the model spent a
+ * round trip per step on what could be serialised (deleting balcony walls one by one, the same
+ * build on every floor). Inputs are checked before anything runs.
+ */
+export declare function createBatchOperation(operations: Readonly<Record<string, AgentOperation<never>>>, contracts: readonly Contract[]): AgentOperation<BatchInput>;
+export {};
+//# sourceMappingURL=batch.d.ts.map

package/dist/agent-operations/batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../src/agent-operations/batch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,SAAS,CAAA;AAE3D,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,EAAE,CAAA;IAC1D,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAC5B,CAAA;AACD,KAAK,QAAQ,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAgBlE;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,EAC3D,SAAS,EAAE,SAAS,QAAQ,EAAE,GAC7B,cAAc,CAAC,UAAU,CAAC,CAsG5B"}

package/dist/agent-operations/batch.js

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import { INDEPENDENT_BATCH_TOOLS } from '../agent-tools/batch.js';
+import { isAgentRefusal, refuse } from '../agent-tools/refusal.js';
+import { applySceneChanges, mergeSceneChanges } from './apply-changes.js';
+import { requireFurnishing } from './design-brief.js';
+import { referencedSceneMaterialIds } from './scene-materials.js';
+/**
+ * `run_batch`: shared tools in order, each on the scene the calls before it left, their changes
+ * merged into one set — one undo step, one write on either surface. The user: the model spent a
+ * round trip per step on what could be serialised (deleting balcony walls one by one, the same
+ * build on every floor). Inputs are checked before anything runs.
+ */
+export function createBatchOperation(operations, contracts) {
+    const names = Object.keys(operations).join(', ');
+    return (nodes, { calls, onRefusal = 'stop' }, context) => {
+        const prepared = calls.map((call, index) => {
+            const operation = operations[call.tool];
+            const contract = contracts.find((candidate) => candidate.name === call.tool);
+            if (!(operation && contract))
+                refuse('unknown_tool', `The batch's call ${index + 1} names ${call.tool}, which a batch cannot run: call it on its own. A batch runs: ${names}.`, { index, tool: call.tool });
+            const parsed = z.object(contract.input).safeParse(call.input ?? {});
+            if (!parsed.success) {
+                const message = `The batch's call ${index + 1} (${call.tool}) has an invalid input: ${parsed.error.issues
+                    .map((issue) => `${issue.path.join('.') || 'input'}: ${issue.message}`)
+                    .join('; ')}.`;
+                // An independent call's bad input is its own report; the others still run.
+                if (INDEPENDENT_BATCH_TOOLS.includes(call.tool))
+                    return { index, tool: call.tool, invalid: message };
+                refuse('invalid_input', `${message} Nothing ran.`, { index, tool: call.tool });
+            }
+            return { index, tool: call.tool, operation, input: parsed.data };
+        });
+        // The gate is a fact of the tool, not of the scene: a call it refuses cannot succeed under
+        // either onRefusal, so the batch is refused whole before anything runs.
+        requireFurnishing('run_batch', { calls }, context.designBrief);
+        let working = nodes;
+        let workingContext = context;
+        const sets = [];
+        const reports = [];
+        for (const call of prepared) {
+            if (call.invalid !== undefined) {
+                reports.push({
+                    index: call.index,
+                    tool: call.tool,
+                    status: 'refused',
+                    code: 'invalid_input',
+                    error: call.invalid,
+                });
+                continue;
+            }
+            try {
+                const { result, changes } = call.operation(working, call.input, {
+                    ...workingContext,
+                    batchCall: call.index,
+                });
+                if (changes) {
+                    sets.push(changes);
+                    working = applySceneChanges(working, changes);
+                    if (changes.materials?.length && workingContext.materials !== undefined)
+                        workingContext = {
+                            ...workingContext,
+                            materials: {
+                                ...workingContext.materials,
+                                ...Object.fromEntries(changes.materials.map((material) => [material.id, material])),
+                            },
+                        };
+                }
+                reports.push({ index: call.index, tool: call.tool, status: 'ok', result });
+            }
+            catch (error) {
+                if (!isAgentRefusal(error))
+                    throw error;
+                if (onRefusal === 'stop' && !INDEPENDENT_BATCH_TOOLS.includes(call.tool))
+                    refuse('batch_call_refused', `The batch stopped at call ${call.index + 1} (${call.tool}), refused with ${error.code}: ${error.message} Nothing in the batch was applied.`, { index: call.index, tool: call.tool, refusal: error.code, ...error.details });
+                reports.push({
+                    index: call.index,
+                    tool: call.tool,
+                    status: 'refused',
+                    code: error.code,
+                    error: error.message,
+                });
+            }
+        }
+        const applied = reports.filter((report) => report.status === 'ok').length;
+        const merged = mergeSceneChanges(sets);
+        // A later erase/delete may cancel a new material's only use in this batch.
+        if (merged.materials) {
+            const refs = referencedSceneMaterialIds(working);
+            merged.materials = merged.materials.filter((material) => context.materials?.[material.id] !== undefined ||
+                refs.has(material.id));
+            if (!merged.materials.length)
+                delete merged.materials;
+        }
+        const changed = merged.create.length +
+            merged.update.length +
+            merged.delete.length +
+            (merged.materials?.length ?? 0) >
+            0;
+        return {
+            result: { status: 'applied', applied, refused: reports.length - applied, calls: reports },
+            ...(changed ? { changes: merged } : {}),
+        };
+    };
+}

package/dist/agent-operations/ceiling-object-observations.d.ts

@@ -0,0 +1,31 @@
+import type { AnyNode } from '../schema/index.js';
+type BoundsEvidence = {
+    severity?: 'info';
+    itemId: string;
+    ceilingId: string;
+    levelId: string;
+    coordinateFrame: 'building';
+    bounds: {
+        min: [number, number, number];
+        max: [number, number, number];
+    };
+};
+export type CeilingObjectObservation = (BoundsEvidence & {
+    type: 'item_above_ceiling';
+    message: string;
+    aboveAttachmentMeters: number;
+    attachmentElevation: number;
+}) | (BoundsEvidence & {
+    type: 'item_covering_slab_overlap';
+    message: string;
+    slabId: string;
+    slabLevelId: string;
+    slabBottomY: number;
+    slabTopY: number;
+    overlapHeightMeters: number;
+    overlapAreaSquareMeters: number;
+});
+/** Static script bounds, not mesh intersections. All comparisons stay in the shared building frame. */
+export declare function ceilingObjectObservations(nodes: Record<string, AnyNode>): CeilingObjectObservation[];
+export {};
+//# sourceMappingURL=ceiling-object-observations.d.ts.map

package/dist/agent-operations/ceiling-object-observations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceiling-object-observations.d.ts","sourceRoot":"","sources":["../../src/agent-operations/ceiling-object-observations.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAKxC,KAAK,cAAc,GAAG;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,UAAU,CAAA;IAC3B,MAAM,EAAE;QAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAA;CACzE,CAAA;AAED,MAAM,MAAM,wBAAwB,GAChC,CAAC,cAAc,GAAG;IAChB,IAAI,EAAE,oBAAoB,CAAA;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,qBAAqB,EAAE,MAAM,CAAA;IAC7B,mBAAmB,EAAE,MAAM,CAAA;CAC5B,CAAC,GACF,CAAC,cAAc,GAAG;IAChB,IAAI,EAAE,4BAA4B,CAAA;IAClC,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,uBAAuB,EAAE,MAAM,CAAA;CAChC,CAAC,CAAA;AAoBN,uGAAuG;AACvG,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,wBAAwB,EAAE,CAqF5B"}

package/dist/agent-operations/ceiling-object-observations.js

@@ -0,0 +1,111 @@
+import { liftedManualSlab } from '../lib/floor-construction-lift.js';
+import { withHostedCutterHoles } from '../lib/object-cuts.js';
+import { area, difference, intersection } from '../lib/polygon-boolean.js';
+import { getRenderableSlabPolygon, slabPolygonContextForLevel } from '../lib/slab-polygon.js';
+import { resolveCeilingHeight } from '../services/level-height.js';
+import { CEILING_DRAW_OFFSET, getLevelElevations } from '../services/storey.js';
+import { scriptItemBoundsInLevel } from './layout-clearance.js';
+function projectedHull(corners) {
+    const sorted = corners
+        .map(([x, , z]) => [x, z])
+        .sort((a, b) => a[0] - b[0] || a[1] - b[1])
+        .filter((point, i, points) => !i || point.some((v, axis) => v !== points[i - 1][axis]));
+    const cross = (a, b, c) => (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+    const half = (points) => {
+        const hull = [];
+        for (const point of points) {
+            while (hull.length >= 2 && cross(hull.at(-2), hull.at(-1), point) <= 0)
+                hull.pop();
+            hull.push(point);
+        }
+        return hull.slice(0, -1);
+    };
+    return [...half(sorted), ...half([...sorted].reverse())];
+}
+/** Static script bounds, not mesh intersections. All comparisons stay in the shared building frame. */
+export function ceilingObjectObservations(nodes) {
+    const observations = [];
+    const elevations = getLevelElevations(nodes);
+    for (const item of Object.values(nodes)) {
+        if (item.type !== 'item' || item.asset.attachTo !== 'ceiling')
+            continue;
+        const ceiling = item.parentId ? nodes[item.parentId] : undefined;
+        if (ceiling?.type !== 'ceiling')
+            continue;
+        const resolved = scriptItemBoundsInLevel(item, nodes);
+        if (!resolved)
+            continue;
+        const level = elevations.get(resolved.levelId);
+        if (!level || !Number.isFinite(level.baseY))
+            continue;
+        const attachment = level.baseY + resolveCeilingHeight(ceiling, nodes) - CEILING_DRAW_OFFSET;
+        const bounds = {
+            min: [...resolved.bounds.min],
+            max: [...resolved.bounds.max],
+        };
+        bounds.min[1] += level.baseY;
+        bounds.max[1] += level.baseY;
+        const evidence = {
+            itemId: item.id,
+            ceilingId: ceiling.id,
+            levelId: resolved.levelId,
+            coordinateFrame: 'building',
+            bounds,
+        };
+        const above = bounds.max[1] - attachment;
+        if (above > 1e-6)
+            observations.push({
+                ...evidence,
+                type: 'item_above_ceiling',
+                message: `Object ${item.id} bounds extend ${above.toFixed(3)} m above ceiling attachment ${ceiling.id}`,
+                aboveAttachmentMeters: above,
+                attachmentElevation: attachment,
+            });
+        const footprint = projectedHull(resolved.corners);
+        for (const original of Object.values(nodes)) {
+            if (original.type !== 'slab' || original.recessed || !original.parentId)
+                continue;
+            const slabLevel = elevations.get(original.parentId);
+            // Unlinked legacy levels are not evidence that two different storeys share a building.
+            if (!slabLevel ||
+                (original.parentId !== resolved.levelId &&
+                    (!level.buildingId || slabLevel.buildingId !== level.buildingId)))
+                continue;
+            try {
+                const slab = liftedManualSlab(nodes, original);
+                const top = slabLevel.baseY + slab.elevation;
+                const bottom = top - slab.thickness;
+                const height = Math.min(bounds.max[1], top) - Math.max(bounds.min[1], bottom);
+                if (top <= level.baseY + 1e-6 || !Number.isFinite(height) || height <= 1e-6)
+                    continue;
+                const slabParent = nodes[original.parentId];
+                if (slabParent?.type !== 'level')
+                    continue;
+                const polygon = getRenderableSlabPolygon(slab, slabPolygonContextForLevel(slabParent, (id) => nodes[id]));
+                const holes = withHostedCutterHoles(original, nodes).holes;
+                // Subtract holes as a union, including overlapping stored and derived openings.
+                const solid = holes.length
+                    ? difference(polygon, holes.map((outer) => ({ outer, holes: [] })), { throwOnError: true })
+                    : polygon;
+                const overlap = area(intersection(footprint, solid));
+                if (overlap <= 1e-6)
+                    continue;
+                observations.push({
+                    ...evidence,
+                    type: 'item_covering_slab_overlap',
+                    message: `Object ${item.id} bounds overlap covering slab ${slab.id} over ${height.toFixed(3)} m vertically and ${overlap.toFixed(3)} m² in plan; bounds overlap is not an exact mesh intersection`,
+                    slabId: slab.id,
+                    slabLevelId: original.parentId,
+                    slabBottomY: bottom,
+                    slabTopY: top,
+                    overlapHeightMeters: height,
+                    overlapAreaSquareMeters: overlap,
+                });
+            }
+            catch {
+                // Unsupported or malformed slab geometry is not collision evidence.
+            }
+        }
+    }
+    return observations;
+}

package/dist/agent-operations/corner-window.d.ts

@@ -0,0 +1,19 @@
+import { type CornerWindowInput } from '../building/corner-window.js';
+import { cornerPair } from '../lib/corner-pair.js';
+import { type LevelTargetInput } from './level-target.js';
+import type { AgentOperation } from './types.js';
+import { type SceneIssue } from './verify-scene.js';
+type AddCornerWindowInput = Omit<CornerWindowInput, 'levelId'> & LevelTargetInput;
+/**
+ * `add_corner_window`: one window on each of the two walls meeting at a corner, joined, on the level
+ * named, else the one in view: stacked storeys share their corners' plan points.
+ */
+export declare const addCornerWindow: AgentOperation<AddCornerWindowInput>;
+/**
+ * Corner windows, checked: two windows running to the same corner unjoined (one face of a corner
+ * window built, the wrap missed), a pair whose sides drifted apart, a window naming a partner that
+ * is gone.
+ */
+export declare function cornerWindowIssues(nodes: Parameters<typeof cornerPair>[0]): SceneIssue[];
+export {};
+//# sourceMappingURL=corner-window.d.ts.map

package/dist/agent-operations/corner-window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corner-window.d.ts","sourceRoot":"","sources":["../../src/agent-operations/corner-window.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAoB,MAAM,2BAA2B,CAAA;AACpF,OAAO,EAAE,UAAU,EAAiC,MAAM,oBAAoB,CAAA;AAG9E,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AACnE,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,SAAS,CAAA;AAC3D,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEpE,KAAK,oBAAoB,GAAG,IAAI,CAAC,iBAAiB,EAAE,SAAS,CAAC,GAAG,gBAAgB,CAAA;AAEjF;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,oBAAoB,CAkBhE,CAAA;AAID;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,EAAE,CA+CxF"}

package/dist/agent-operations/corner-window.js

@@ -0,0 +1,84 @@
+import { planCornerWindow } from '../building/corner-window.js';
+import { cornerPair, wallEndPoint, windowCornerEnd } from '../lib/corner-pair.js';
+import { achievedChanges } from './achieved.js';
+import { targetLevel } from './level-target.js';
+import { registerSceneCheck } from './verify-scene.js';
+/**
+ * `add_corner_window`: one window on each of the two walls meeting at a corner, joined, on the level
+ * named, else the one in view: stacked storeys share their corners' plan points.
+ */
+export const addCornerWindow = (nodes, input, context) => {
+    const level = targetLevel(nodes, input, context);
+    const { windows, wallIds, angle } = planCornerWindow(nodes, { ...input, levelId: level.id });
+    const changes = {
+        create: windows.map((node) => ({ node: node, parentId: node.parentId })),
+    };
+    return {
+        changes,
+        result: {
+            ok: true,
+            windowIds: windows.map((window) => window.id),
+            wallIds,
+            angle: Math.round(angle * 10) / 10,
+            post: windows[0].corner.post,
+            message: `Added a corner window across ${wallIds.join(' and ')} (${Math.round(angle)}°), the glass ${windows[0].corner.post === 'none' ? 'fused at the corner' : 'meeting at a post'}.`,
+            achieved: achievedChanges(nodes, changes),
+        },
+    };
+};
+const round = (value) => Math.round(value * 100) / 100;
+/**
+ * Corner windows, checked: two windows running to the same corner unjoined (one face of a corner
+ * window built, the wrap missed), a pair whose sides drifted apart, a window naming a partner that
+ * is gone.
+ */
+export function cornerWindowIssues(nodes) {
+    const issues = [];
+    const atCorner = new Map();
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'window')
+            continue;
+        const window = node;
+        const pair = cornerPair(nodes, window);
+        // Informational: what broke the pair (a side deleted or moved, a wall moved) was a choice.
+        if (window.corner && !pair) {
+            issues.push({
+                type: 'corner_partner_missing',
+                severity: 'info',
+                message: `Window ${window.id} names corner partner ${window.corner.partnerId}, but they no longer make a corner window (one is gone or moved off the corner, or the walls no longer meet there): it renders as a plain window. Only if the person wants the corner wrapped again, merge_windows joins two windows there.`,
+            });
+            continue;
+        }
+        if (pair) {
+            const sill = (w) => w.position[1] - w.height / 2;
+            if (window.id < pair.partner.id &&
+                (Math.abs(window.height - pair.partner.height) > 1e-3 ||
+                    Math.abs(sill(window) - sill(pair.partner)) > 1e-3))
+                issues.push({
+                    type: 'corner_out_of_step',
+                    message: `Corner window ${window.id} and ${pair.partner.id} differ (heights ${round(window.height)} and ${round(pair.partner.height)} m, sills ${round(sill(window))} and ${round(sill(pair.partner))} m): a corner window's sides share height and sill.`,
+                });
+            continue;
+        }
+        const end = windowCornerEnd(nodes, window);
+        const wall = nodes[window.parentId ?? ''];
+        if (!end || wall?.type !== 'wall')
+            continue;
+        const [x, z] = wallEndPoint(wall, end);
+        const key = `${wall.parentId}:${x.toFixed(3)},${z.toFixed(3)}`;
+        atCorner.set(key, [...(atCorner.get(key) ?? []), window]);
+    }
+    for (const [key, windows] of atCorner) {
+        if (new Set(windows.map((w) => w.parentId)).size < 2)
+            continue;
+        const corner = key.split(':')[1];
+        // Informational: two windows meeting at a corner may be what the person drew.
+        issues.push({
+            type: 'corner_unjoined',
+            severity: 'info',
+            message: `Windows ${windows.map((w) => w.id).join(' and ')} both run to the corner (${corner}) without being joined: if the reference wraps the corner, merge_windows joins them as one corner window, the glass fused.`,
+        });
+    }
+    return issues;
+}
+registerSceneCheck({ name: 'corner windows', order: 50, run: (n) => cornerWindowIssues(n) });

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

@@ -0,0 +1,32 @@
+import { type RoofGlazing, type RoofSystemType, type RoofType } from '../schema/index.js';
+import type { AgentOperation } from './types.js';
+type Pt = [number, number];
+type CreateRoofInput = {
+    levelId?: string;
+    level?: string;
+    roofSystem?: RoofSystemType;
+    glazing?: RoofGlazing;
+    barrelRise?: number;
+    barrelSegments?: number;
+    wallThickness?: number;
+    roofType?: RoofType;
+    pitch?: number;
+    overhang?: number;
+    wallHeight?: number;
+    width?: number;
+    depth?: number;
+    center?: number[];
+    materialPreset?: string;
+    fasciaHeight?: number;
+    fasciaMaterialPreset?: string;
+    name?: string;
+};
+/** A polygon moved out by `distance` along each edge's outward normal, corners mitred up to the limit. */
+export declare function grown(polygon: Pt[], distance: number): Pt[];
+/**
+ * `create_roof`: a roof over a storey, one segment per rectangle of its footprint (or the one
+ * rectangle asked for), on the building's roof level above it, standing on the storey's walls.
+ */
+export declare const createRoof: AgentOperation<CreateRoofInput>;
+export {};
+//# sourceMappingURL=create-roof.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-roof.d.ts","sourceRoot":"","sources":["../../src/agent-operations/create-roof.ts"],"names":[],"mappings":"AAGA,OAAO,EAKL,KAAK,WAAW,EAGhB,KAAK,cAAc,EACnB,KAAK,QAAQ,EAEd,MAAM,WAAW,CAAA;AAQlB,OAAO,KAAK,EAAgB,cAAc,EAA4B,MAAM,SAAS,CAAA;AAErF,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAI1B,KAAK,eAAe,GAAG;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,cAAc,CAAA;IAC3B,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAmID,0GAA0G;AAC1G,wBAAgB,KAAK,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,EAAE,EAAE,CA4B3D;AAiCD;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CA0KtD,CAAA"}