@pascal-app/core 1.0.3 → 1.0.5

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/collections.d.ts

@@ -0,0 +1,28 @@
+import { type Collection, type CollectionId, type CollectionTemplateId } from '../schema/index.js';
+import type { AgentOperationOutcome, SceneNodes } from './types.js';
+/** What the collection tools read: the nodes and the scene's collections. */
+export type CollectionScene = {
+    nodes: SceneNodes;
+    collections: Readonly<Record<string, Collection>>;
+};
+export type EditCollectionInput = {
+    collectionId?: string;
+    template?: CollectionTemplateId;
+    name?: string;
+    color?: string;
+    add?: string[];
+    remove?: string[];
+    delete?: boolean;
+};
+/** The scene's collections after `writes` (a surface applies `SceneChanges.collections` with it). */
+export declare function writeCollections(current: Readonly<Record<string, Collection>>, writes: Readonly<Record<string, Collection | null>>): Record<CollectionId, Collection>;
+/**
+ * `edit_collection`: one collection created, changed or deleted. Without an id the call works on
+ * the scene's collection with the template, or else the name, and creates it when there is none.
+ */
+export declare function editCollection(scene: CollectionScene, input: EditCollectionInput): AgentOperationOutcome;
+/** `list_collections`: the scene's collections with their elements, and the templates. */
+export declare function listCollections(scene: CollectionScene, { collectionId }: {
+    collectionId?: string;
+}): AgentOperationOutcome;
+//# sourceMappingURL=collections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/agent-operations/collections.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,oBAAoB,EAE1B,MAAM,WAAW,CAAA;AAElB,OAAO,KAAK,EAAE,qBAAqB,EAAgB,UAAU,EAAE,MAAM,SAAS,CAAA;AAE9E,6EAA6E;AAC7E,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,UAAU,CAAA;IACjB,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAA;CAClD,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,EAAE,oBAAoB,CAAA;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,CAAC,EAAE,MAAM,EAAE,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,qGAAqG;AACrG,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,EAC7C,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC,CAAC,GAClD,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAOlC;AA0DD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,eAAe,EACtB,KAAK,EAAE,mBAAmB,GACzB,qBAAqB,CAoDvB;AAED,0FAA0F;AAC1F,wBAAgB,eAAe,CAC7B,KAAK,EAAE,eAAe,EACtB,EAAE,YAAY,EAAE,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1C,qBAAqB,CAWvB"}

package/dist/agent-operations/collections.js

@@ -0,0 +1,130 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { COLLECTION_TEMPLATES, generateCollectionId, } from '../schema/index.js';
+import { levelIdOf } from './scene-queries.js';
+/** The scene's collections after `writes` (a surface applies `SceneChanges.collections` with it). */
+export function writeCollections(current, writes) {
+    const next = { ...current };
+    for (const [id, collection] of Object.entries(writes)) {
+        if (collection)
+            next[id] = collection;
+        else
+            delete next[id];
+    }
+    return next;
+}
+function describeCollection({ nodes }, collection) {
+    const elements = collection.nodeIds.flatMap((id) => {
+        const node = nodes[id];
+        if (!node)
+            return [];
+        return [
+            {
+                id,
+                name: node.name ?? (node.type === 'item' ? node.asset.name : undefined),
+                type: node.type,
+                levelId: levelIdOf(nodes, id),
+            },
+        ];
+    });
+    return {
+        id: collection.id,
+        name: collection.name,
+        ...(collection.color ? { color: collection.color } : {}),
+        ...(collection.template ? { template: collection.template } : {}),
+        count: elements.length,
+        elements,
+    };
+}
+function collectionById({ collections }, collectionId) {
+    const collection = collections[collectionId];
+    if (!collection)
+        refuse('collection_not_found', `Collection not found: ${collectionId}.`, { collectionId });
+    return collection;
+}
+/** Items mirror their membership in `collectionIds`, as the editor's own collection actions do. */
+function itemMirrorUpdates(nodes, collectionId, before, after) {
+    const members = new Set(after);
+    const updates = [];
+    for (const id of new Set([...before, ...after])) {
+        const node = nodes[id];
+        if (node?.type !== 'item')
+            continue;
+        const current = node.collectionIds ?? [];
+        if (current.includes(collectionId) === members.has(id))
+            continue;
+        updates.push({
+            id,
+            data: {
+                collectionIds: members.has(id)
+                    ? [...current, collectionId]
+                    : current.filter((other) => other !== collectionId),
+            },
+        });
+    }
+    return updates;
+}
+/**
+ * `edit_collection`: one collection created, changed or deleted. Without an id the call works on
+ * the scene's collection with the template, or else the name, and creates it when there is none.
+ */
+export function editCollection(scene, input) {
+    const all = Object.values(scene.collections);
+    const nameKey = input.name?.toLowerCase();
+    const existing = input.collectionId
+        ? collectionById(scene, input.collectionId)
+        : input.template
+            ? all.find((collection) => collection.template === input.template)
+            : nameKey
+                ? all.find((collection) => collection.name.toLowerCase() === nameKey)
+                : refuse('collection_required', 'Pass a collectionId, a template or a name.');
+    if (input.delete) {
+        if (!existing)
+            refuse('collection_not_found', `No collection named ${input.name ?? input.template}.`);
+        return {
+            result: { deletedId: existing.id, name: existing.name },
+            changes: {
+                collections: { [existing.id]: null },
+                update: itemMirrorUpdates(scene.nodes, existing.id, existing.nodeIds, []),
+            },
+        };
+    }
+    const missing = (input.add ?? []).filter((id) => !scene.nodes[id]);
+    if (missing.length)
+        refuse('node_not_found', `Not in the scene: ${missing.join(', ')}.`, { ids: missing });
+    const preset = input.template ? COLLECTION_TEMPLATES[input.template] : undefined;
+    const base = existing ?? {
+        id: generateCollectionId(),
+        name: preset?.name ?? input.name,
+        ...(preset ? { color: preset.color } : {}),
+        nodeIds: [],
+    };
+    const removed = new Set(input.remove ?? []);
+    const nodeIds = [...new Set([...base.nodeIds, ...(input.add ?? [])])].filter((id) => !removed.has(id));
+    const next = {
+        ...base,
+        ...(input.name ? { name: input.name } : {}),
+        ...(input.color ? { color: input.color } : {}),
+        ...(input.template ? { template: input.template } : {}),
+        nodeIds,
+    };
+    return {
+        result: { created: !existing, collection: describeCollection(scene, next) },
+        changes: {
+            collections: { [next.id]: next },
+            update: itemMirrorUpdates(scene.nodes, next.id, base.nodeIds, nodeIds),
+        },
+    };
+}
+/** `list_collections`: the scene's collections with their elements, and the templates. */
+export function listCollections(scene, { collectionId }) {
+    const collections = collectionId
+        ? [collectionById(scene, collectionId)]
+        : Object.values(scene.collections);
+    return {
+        result: {
+            count: collections.length,
+            collections: collections.map((collection) => describeCollection(scene, collection)),
+            templates: Object.entries(COLLECTION_TEMPLATES).map(([id, { name }]) => ({ id, name })),
+        },
+    };
+}

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) });