@pascal-app/core 1.0.1 → 1.0.4

package/dist/agent-operations/add-object.d.ts

@@ -0,0 +1,114 @@
+import { type ScriptedNode } from '../lib/geometry-script-node.js';
+import { type AnyNode, type CompiledGeometryScript, type GeometryScriptLanguage, type GeometryScriptParamValue } from '../schema/index.js';
+import type { AgentOperation } from './types.js';
+export type AddObjectInput = {
+    /** Absent for a params-only edit: the host compiled the object's stored script. */
+    code?: string;
+    params?: Record<string, GeometryScriptParamValue>;
+    nodeId?: string;
+    parentId?: string;
+    position?: number[];
+    /** Degrees about Y, as the contract parses it. */
+    rotation?: number;
+    side?: 'front' | 'back';
+    name?: string;
+    description?: string;
+    tags?: string[];
+    category?: string;
+    /** What the object stands in for; kept in `metadata.reason`, listed by verify_scene. */
+    reason?: string;
+    /** What the surface's compile produced from `code` (compiled before the operation runs). */
+    compiled: CompiledGeometryScript;
+};
+/**
+ * Words that name what Pascal already builds, with the tool that builds it. An object named so is
+ * built with a hint naming that tool: authored objects are for what has no type.
+ */
+export declare const PASCAL_TYPES: [RegExp, string][];
+/**
+ * `add_object`: the item a compiled three.js module becomes. Not in
+ * AGENT_OPERATIONS: each surface compiles `code` first (the chat in its
+ * worker, the MCP on the server) and passes the result as `compiled`.
+ * The artifact is referenced by hash and its bounds become the item's dimensions; editing
+ * keeps the item's identity, placement, children, paint and reason. Only a new object is judged
+ * by its shape and must give a reason: the editor's inspector rebuilds through the edit path.
+ */
+/**
+ * A new object says what it stands in for. Hosts check it before running the script: a missing
+ * reason refused after the compile has run it and stored its artifacts for nothing.
+ */
+export declare function requireAddObjectReason(input: {
+    nodeId?: string;
+    reason?: string;
+}): void;
+export declare const addObject: AgentOperation<AddObjectInput>;
+export type RescriptOpeningInput = {
+    description?: string;
+    category?: string;
+    tags?: string[];
+    nodeId: string;
+    /** Where it goes; without one its bottom edge stays put. */
+    position?: number[];
+    name?: string;
+    /** What the host compiled: new code, or the stored script with new params. */
+    compiled: CompiledGeometryScript;
+};
+/**
+ * `add_window` / `add_door` with a nodeId: a window or door built from (or
+ * given) a script, rebuilt from what the host compiled. Its size is what the
+ * script built; marks, hosting and the opening's own fields are kept.
+ */
+export declare const rescriptOpening: AgentOperation<RescriptOpeningInput>;
+/**
+ * The param values a rebuild of `node` compiles with: its current ones under the
+ * edit's. The compile then keeps only what the module declares, clamps numbers to
+ * their new range and gives a param new to the code, or one whose type changed,
+ * its default. A node without a script just takes the edit's.
+ */
+export declare function editedScriptParams(node: AnyNode | undefined, params: Record<string, GeometryScriptParamValue> | undefined): Record<string, GeometryScriptParamValue> | undefined;
+/**
+ * The language a build of `node` runs in: new code's own (the node's when not
+ * given), and the stored script's for a params-only rebuild.
+ */
+export declare function editedScriptLanguage(node: AnyNode | undefined, input: {
+    code?: string;
+    language?: GeometryScriptLanguage;
+}): GeometryScriptLanguage;
+/** The scripted node `get_source` and a params-only rebuild act on, or a refusal. */
+export declare function authoredObject(nodes: Record<string, AnyNode>, nodeId: string): ScriptedNode;
+/**
+ * Params are a script's values: without code, only a node already built from a
+ * script has one to rerun, so a new node, or one without a script, is refused.
+ */
+export declare function refuseParamsWithoutScript(nodes: Record<string, AnyNode>, input: {
+    code?: string;
+    params?: unknown;
+    nodeId?: string;
+}): void;
+/**
+ * Why a raw update (chat `update_node`, MCP `apply_patch`) may not write what a
+ * node's script owns, its `source` or the size it built, or null: the stored
+ * fields would no longer match the geometry. Restating the current value passes.
+ */
+export declare function scriptedFieldRefusal(node: AnyNode, data: Record<string, unknown>): string | null;
+/** What `get_source` answers once the host has the module's text. */
+export declare function readSourceResult(node: ScriptedNode, code: string): {
+    nodeId: `item_${string}` | `column_${string}` | `door_${string}` | `window_${string}`;
+    type: "column" | "door" | "window" | "item";
+    name: string | undefined;
+    language: "three" | "bpy";
+    code: string;
+    params: {
+        value: string | number | boolean;
+        id: string;
+        kind: "string" | "number" | "boolean";
+        default: string | number | boolean;
+        label?: string | undefined;
+        min?: number | undefined;
+        max?: number | undefined;
+        step?: number | undefined;
+        unit?: string | undefined;
+        options?: string[] | undefined;
+    }[];
+};
+//# sourceMappingURL=add-object.d.ts.map

package/dist/agent-operations/add-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-object.d.ts","sourceRoot":"","sources":["../../src/agent-operations/add-object.ts"],"names":[],"mappings":"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"}

package/dist/agent-operations/add-object.js

@@ -0,0 +1,361 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { artifactUrl } from '../lib/artifact-store.js';
+import { isScriptedNode, matchScriptSlotsToLibrary, scriptedSize, scriptInteractive, scriptSource, } from '../lib/geometry-script-node.js';
+import { geometryRestingHeight, resettledPosition } from '../lib/geometry-surfaces.js';
+import { generateId, ItemNode, } from '../schema/index.js';
+import { targetLevel } from './level-target.js';
+const ATTACH = {
+    floor: undefined,
+    wall: 'wall',
+    'wall-side': 'wall-side',
+    ceiling: 'ceiling',
+};
+const HOSTS = {
+    floor: ['level', 'item'],
+    wall: ['wall'],
+    'wall-side': ['wall'],
+    ceiling: ['ceiling'],
+};
+function scriptAsset(compiled, input, previous) {
+    const { min, max } = compiled.manifest.bounds;
+    const restingHeight = geometryRestingHeight(compiled.manifest);
+    const attachTo = ATTACH[compiled.mount];
+    const interactive = scriptInteractive(compiled.manifest);
+    return {
+        id: `script_${compiled.sha256.slice(0, 16)}`,
+        category: input.category ?? previous?.category ?? 'object',
+        name: input.name ?? previous?.name ?? 'Authored object',
+        thumbnail: previous?.thumbnail ?? '',
+        source: 'mine',
+        src: artifactUrl(compiled.sha256),
+        dimensions: [max[0] - min[0], max[1] - min[1], max[2] - min[2]],
+        ...(attachTo ? { attachTo } : {}),
+        ...(restingHeight === null ? {} : { surface: { height: restingHeight } }),
+        offset: [0, 0, 0],
+        rotation: [0, 0, 0],
+        scale: [1, 1, 1],
+        ...(interactive ? { interactive } : {}),
+    };
+}
+/**
+ * Words that name what Pascal already builds, with the tool that builds it. An object named so is
+ * built with a hint naming that tool: authored objects are for what has no type.
+ */
+export const PASCAL_TYPES = [
+    [/\bwalls?\b/i, 'walls: add_wall'],
+    [
+        /\b(slabs?|floor plates?|floors?)\b/i,
+        'a floor: rooms make their floor plates (create_room), shaped by set_room_floor_construction or set_floor_foundation',
+    ],
+    [
+        /\b(doors?|windows?|sills?|glazing)\b/i,
+        'add_door / add_window (with code for a design their fields cannot express)',
+    ],
+    [/\b(stairs?|staircases?)\b/i, 'create_stair'],
+    [/\broofs?\b/i, 'create_roof'],
+    [/\b(rooms?|zones?|apartments?)\b/i, 'rooms: create_room'],
+];
+/**
+ * What a label names: the last word of its main phrase. "entry door pull handle (brass)" is a
+ * handle; "door" only says which one (it was once refused as a door).
+ */
+function headWord(label) {
+    const phrase = label.split(/\(|,|\s[-–—]\s|\sof\s/i)[0].trim();
+    return phrase.split(/\s+/).at(-1) ?? phrase;
+}
+/**
+ * The tool for an object named after something Pascal builds: an invitation, not a gate. A word
+ * gate taught evasion: refused "entry door pull handle (brass)", the agent relabelled it "brass
+ * pull bars", and the label stopped naming the gap.
+ */
+function typeHint(input) {
+    for (const label of [input.name, input.category]) {
+        const named = label && PASCAL_TYPES.find(([word]) => word.test(headWord(label)));
+        if (named)
+            return `"${label}" is something Pascal builds: ${named[1]}.`;
+    }
+    return undefined;
+}
+/** A wall's box: thin, a metre long or more, two metres high or more. */
+function wallSized(compiled) {
+    const [width, height, depth] = scriptedSize(compiled.manifest);
+    return Math.min(width, depth) <= 0.45 && Math.max(width, depth) >= 1 && height >= 2;
+}
+/** A plain box: one cuboid, as a wall is. A bookcase or a screen has shelves or holes. */
+const PLAIN_BOX = 12;
+/**
+ * A floor object that is a plain box with a wall's size, or a floor plate, is refused: Pascal builds
+ * those, and rooms, openings and facades only work with its own. Production saw whole houses of
+ * plain custom solids, nothing editable as walls, rooms or doors.
+ */
+function refuseWallOrSlabShape(compiled, input) {
+    const [width, height, depth] = scriptedSize(compiled.manifest);
+    const long = Math.max(width, depth);
+    const short = Math.min(width, depth);
+    const label = input.name ?? input.category ?? 'The object';
+    if (wallSized(compiled) && compiled.manifest.triangles <= PLAIN_BOX)
+        refuse('use_walls', `"${label}" (${long.toFixed(2)} × ${short.toFixed(2)} m, ${height.toFixed(2)} m high) is a plain box with a wall's size: build it with add_wall so rooms, openings and facades work with it.`, { label });
+    const base = input.position?.[1] ?? 0;
+    if (height <= 0.35 && short >= 2 && base <= 0.05) {
+        // Its extent along x and z as it stands, so the numbers match the outline the agent drew.
+        const turn = ((input.rotation ?? 0) * Math.PI) / 180;
+        const [c, s] = [Math.abs(Math.cos(turn)), Math.abs(Math.sin(turn))];
+        const [x, z] = [width * c + depth * s, width * s + depth * c];
+        refuse('use_slab', `"${label}" (${x.toFixed(2)} × ${z.toFixed(2)} m in x and z, ${height.toFixed(2)} m thick, on the floor) is a floor plate: build it as a slab.`, { label });
+    }
+}
+/** An item's category lives on its asset, so its source meta leaves it out. */
+const itemSourceMeta = ({ category: _, ...input }) => input;
+const round = (value) => Math.round(value * 1000) / 1000;
+function summary(node, compiled, orphanedSlots) {
+    const { bounds, parts, slots, lights, params, triangles, cutout, animations } = compiled.manifest;
+    return {
+        nodeId: node.id,
+        mount: compiled.mount,
+        size: bounds.max.map((v, i) => round(v - bounds.min[i])),
+        parts: parts.map((part) => (part.type ? `${part.id} (${part.type})` : part.id)),
+        slots: slots.map((slot) => slot.id),
+        lights: lights.map((light) => light.id),
+        animations: animations.map((clip) => clip.name),
+        params: params.map((spec) => ({ ...spec, value: compiled.params[spec.id] })),
+        cutout,
+        triangles,
+        ...(orphanedSlots.length > 0
+            ? {
+                orphanedSlots,
+                note: `Paint on ${orphanedSlots.join(', ')} is kept but no longer shows: the new output has no slot with that id.`,
+            }
+            : {}),
+    };
+}
+/**
+ * `add_object`: the item a compiled three.js module becomes. Not in
+ * AGENT_OPERATIONS: each surface compiles `code` first (the chat in its
+ * worker, the MCP on the server) and passes the result as `compiled`.
+ * The artifact is referenced by hash and its bounds become the item's dimensions; editing
+ * keeps the item's identity, placement, children, paint and reason. Only a new object is judged
+ * by its shape and must give a reason: the editor's inspector rebuilds through the edit path.
+ */
+/**
+ * A new object says what it stands in for. Hosts check it before running the script: a missing
+ * reason refused after the compile has run it and stored its artifacts for nothing.
+ */
+export function requireAddObjectReason(input) {
+    if (!input.nodeId && !input.reason?.trim())
+        refuse('reason_required', 'Say what this object stands in for (reason): why no Pascal tool or catalog item builds it. The scene check lists every authored object with its reason.');
+}
+export const addObject = (nodes, input, context) => {
+    const { compiled } = input;
+    const rotation = input.rotation === undefined ? undefined : [0, (input.rotation * Math.PI) / 180, 0];
+    if (input.nodeId) {
+        if (nodes[input.nodeId]?.type === 'column')
+            refuse('use_column_tool', `Rebuild ${input.nodeId} with add_column and nodeId.`, {
+                id: input.nodeId,
+                type: 'column',
+            });
+        const previous = authoredObject(nodes, input.nodeId);
+        if (previous.type !== 'item')
+            refuse('use_opening_tool', `${previous.id} is a ${previous.type}: rebuild it with add_${previous.type} and nodeId.`, { id: previous.id, type: previous.type });
+        const slotIds = new Set(compiled.manifest.slots.map((slot) => slot.id));
+        const orphanedSlots = Object.keys(previous.slots ?? {}).filter((id) => !slotIds.has(id));
+        const next = ItemNode.parse({
+            ...previous,
+            name: input.name ?? previous.name,
+            position: input.position ?? previous.position,
+            rotation: rotation ?? previous.rotation,
+            ...(input.side === undefined ? {} : { side: input.side }),
+            source: scriptSource(compiled, itemSourceMeta(input), previous.source),
+            slots: matchScriptSlotsToLibrary(compiled.manifest, previous.slots, previous.source?.manifest),
+            asset: scriptAsset(compiled, input, previous.asset),
+            ...(input.reason ? { metadata: { ...previous.metadata, reason: input.reason } } : {}),
+        });
+        // Children resting on or hanging from the object follow its new geometry.
+        const resettled = [];
+        for (const childId of previous.children) {
+            const child = nodes[childId];
+            if (child?.type !== 'item' || child.wallId)
+                continue;
+            const position = resettledPosition(compiled.manifest, child, next.scale);
+            if (!position || position.every((v, i) => Math.abs(v - child.position[i]) < 1e-4))
+                continue;
+            resettled.push({ id: child.id, position });
+        }
+        return {
+            result: {
+                ...summary(next, compiled, orphanedSlots),
+                ...(resettled.length > 0 ? { resettled: resettled.map((entry) => entry.id) } : {}),
+            },
+            changes: {
+                update: [
+                    { id: next.id, data: next },
+                    ...resettled.map(({ id, position }) => ({ id, data: { position } })),
+                ],
+            },
+        };
+    }
+    const parent = input.parentId ? nodes[input.parentId] : targetLevel(nodes, {}, context);
+    if (!parent)
+        refuse('node_not_found', `Node not found: ${input.parentId}.`, { id: input.parentId });
+    const hosts = HOSTS[compiled.mount];
+    if (!hosts.includes(parent.type)) {
+        refuse('wrong_host', `A ${compiled.mount} object goes on a ${hosts.join(' or ')}, not on a ${parent.type}. Pass parentId of a ${hosts[0]}, or change \`mount\`.`, { mount: compiled.mount, parentType: parent.type });
+    }
+    if (compiled.mount === 'floor' && parent.type === 'level')
+        refuseWallOrSlabShape(compiled, input);
+    requireAddObjectReason(input);
+    const asset = scriptAsset(compiled, input, undefined);
+    const node = ItemNode.parse({
+        object: 'node',
+        id: compiled.nodeId ?? generateId('item'),
+        type: 'item',
+        name: input.name ?? asset.name,
+        parentId: parent.id,
+        ...(parent.type === 'wall' ? { wallId: parent.id, side: input.side ?? 'front' } : {}),
+        position: input.position ?? [0, 0, 0],
+        rotation: rotation ?? [0, 0, 0],
+        source: scriptSource(compiled, itemSourceMeta(input)),
+        slots: matchScriptSlotsToLibrary(compiled.manifest),
+        asset,
+        metadata: { reason: input.reason },
+    });
+    const hint = [
+        typeHint(input),
+        compiled.mount === 'floor' &&
+            wallSized(compiled) &&
+            `It has a wall's size: if it is a wall, add_wall builds it so rooms, openings and facades work with it.`,
+    ]
+        .filter(Boolean)
+        .join(' ');
+    return {
+        result: { ...summary(node, compiled, []), ...(hint ? { hint } : {}) },
+        changes: { create: [{ node, parentId: parent.id }] },
+    };
+};
+/**
+ * `add_window` / `add_door` with a nodeId: a window or door built from (or
+ * given) a script, rebuilt from what the host compiled. Its size is what the
+ * script built; marks, hosting and the opening's own fields are kept.
+ */
+export const rescriptOpening = (nodes, input) => {
+    const { compiled } = input;
+    const previous = nodes[input.nodeId];
+    if (!previous)
+        refuse('node_not_found', `Node not found: ${input.nodeId}.`, { id: input.nodeId });
+    if (previous.type !== 'window' && previous.type !== 'door')
+        refuse('not_an_opening', `${input.nodeId} is a ${previous.type}, not a window or door.`, {
+            id: input.nodeId,
+            type: previous.type,
+        });
+    const slotIds = new Set(compiled.manifest.slots.map((slot) => slot.id));
+    const orphanedSlots = Object.keys(previous.slots ?? {}).filter((id) => !slotIds.has(id));
+    // A window or door keeps its place on the wall and its bottom edge; its size is what the script built.
+    if (compiled.mount !== 'wall')
+        refuse('wrong_mount', `A ${previous.type}'s script uses mount 'wall'.`, {
+            mount: compiled.mount,
+        });
+    const [width, height] = scriptedSize(compiled.manifest);
+    // Given a position, that is where it goes; otherwise its bottom edge stays put.
+    const [x, y, z] = previous.position;
+    const placed = input.position ?? [
+        x,
+        y - previous.height / 2 + height / 2,
+        z,
+    ];
+    // A wider rebuild stays on its wall, as a new opening does.
+    const wall = previous.wallId ? nodes[previous.wallId] : undefined;
+    const wallLength = wall?.type === 'wall' ? Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]) : 0;
+    const position = wallLength >= width
+        ? [Math.min(wallLength - width / 2, Math.max(width / 2, placed[0])), placed[1], placed[2]]
+        : placed;
+    return {
+        result: summary(previous, compiled, orphanedSlots),
+        changes: {
+            update: [
+                {
+                    id: previous.id,
+                    data: {
+                        name: input.name ?? previous.name,
+                        source: scriptSource(compiled, input, previous.source),
+                        slots: matchScriptSlotsToLibrary(compiled.manifest, previous.slots, previous.source?.manifest),
+                        width,
+                        height,
+                        position,
+                    },
+                },
+            ],
+        },
+    };
+};
+/**
+ * The param values a rebuild of `node` compiles with: its current ones under the
+ * edit's. The compile then keeps only what the module declares, clamps numbers to
+ * their new range and gives a param new to the code, or one whose type changed,
+ * its default. A node without a script just takes the edit's.
+ */
+export function editedScriptParams(node, params) {
+    return isScriptedNode(node) ? { ...node.source.params, ...params } : params;
+}
+/**
+ * The language a build of `node` runs in: new code's own (the node's when not
+ * given), and the stored script's for a params-only rebuild.
+ */
+export function editedScriptLanguage(node, input) {
+    const stored = isScriptedNode(node) ? node.source.language : 'three';
+    return input.code ? (input.language ?? stored) : stored;
+}
+/** The scripted node `get_source` and a params-only rebuild act on, or a refusal. */
+export function authoredObject(nodes, nodeId) {
+    const node = nodes[nodeId];
+    if (!node)
+        refuse('node_not_found', `Node not found: ${nodeId}.`, { id: nodeId });
+    if (!isScriptedNode(node))
+        refuse('not_authored', `${nodeId} is a ${node.type} without a script; only objects, windows, doors and columns built from code have one.`, { id: nodeId, type: node.type });
+    return node;
+}
+/**
+ * Params are a script's values: without code, only a node already built from a
+ * script has one to rerun, so a new node, or one without a script, is refused.
+ */
+export function refuseParamsWithoutScript(nodes, input) {
+    if (!input.params || input.code)
+        return;
+    if (!input.nodeId)
+        refuse('not_authored', 'Pass code with params: they are values for its script.');
+    authoredObject(nodes, input.nodeId);
+}
+/** The native size a scripted window, door or column takes from what its script built. */
+const SCRIPTED_SIZE = {
+    window: ['width', 'height'],
+    door: ['width', 'height'],
+    column: ['width', 'height', 'depth'],
+};
+/**
+ * Why a raw update (chat `update_node`, MCP `apply_patch`) may not write what a
+ * node's script owns, its `source` or the size it built, or null: the stored
+ * fields would no longer match the geometry. Restating the current value passes.
+ */
+export function scriptedFieldRefusal(node, data) {
+    if (!isScriptedNode(node))
+        return null;
+    const owned = ['source', ...(SCRIPTED_SIZE[node.type] ?? [])];
+    const current = node;
+    const fields = owned.filter((key) => key in data && JSON.stringify(data[key]) !== JSON.stringify(current[key]));
+    if (fields.length === 0)
+        return null;
+    const tool = node.type === 'item' ? 'add_object' : `add_${node.type}`;
+    return `${node.id} is built from a script, so ${fields.join(', ')} ${fields.length === 1 ? 'comes' : 'come'} from it: rebuild it with ${tool} with nodeId and params (get_source shows them); nothing was changed.`;
+}
+/** What `get_source` answers once the host has the module's text. */
+export function readSourceResult(node, code) {
+    return {
+        nodeId: node.id,
+        type: node.type,
+        name: node.name,
+        language: node.source.language,
+        code,
+        params: node.source.manifest.params.map((spec) => ({
+            ...spec,
+            value: node.source.params[spec.id] ?? spec.default,
+        })),
+    };
+}

package/dist/agent-operations/add-wall.d.ts

@@ -0,0 +1,15 @@
+import { type LevelTargetInput } from './level-target.js';
+import type { AgentOperation, SceneNodes } from './types.js';
+type AddWallInput = LevelTargetInput & {
+    start: number[];
+    end: number[];
+    thickness?: number;
+    height?: number;
+    curveOffset?: number;
+};
+/** A level declared as the roof holds the roof, not rooms: walls and stairs stay off it. */
+export declare function refuseRoofLevel(nodes: SceneNodes, levelId: string, what: string): void;
+/** `add_wall`: one wall between two points, named as the editor names walls. */
+export declare const addWall: AgentOperation<AddWallInput>;
+export {};
+//# sourceMappingURL=add-wall.d.ts.map

package/dist/agent-operations/add-wall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-wall.d.ts","sourceRoot":"","sources":["../../src/agent-operations/add-wall.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGzD,KAAK,YAAY,GAAG,gBAAgB,GAAG;IACrC,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,GAAG,EAAE,MAAM,EAAE,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,4FAA4F;AAC5F,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAQ/E;AAED,gFAAgF;AAChF,eAAO,MAAM,OAAO,EAAE,cAAc,CAAC,YAAY,CAqChD,CAAA"}

package/dist/agent-operations/add-wall.js

@@ -0,0 +1,47 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { WallNode } from '../schema/index.js';
+import { normalizeWallCurveOffset } from '../systems/wall/wall-curve.js';
+import { WALL_MIN_LENGTH } from '../systems/wall/wall-topology.js';
+import { targetLevel } from './level-target.js';
+import { levelRole } from './scene-queries.js';
+/** A level declared as the roof holds the roof, not rooms: walls and stairs stay off it. */
+export function refuseRoofLevel(nodes, levelId, what) {
+    const level = nodes[levelId];
+    if (level && levelRole(nodes, level).metadataRole === 'roof')
+        refuse('roof_level', `${levelId} is a roof level, not a storey: ${what} belongs on an occupied storey. Add one with add_level if the building needs it.`, { levelId });
+}
+/** `add_wall`: one wall between two points, named as the editor names walls. */
+export const addWall = (nodes, input, context) => {
+    const level = targetLevel(nodes, input, context);
+    refuseRoofLevel(nodes, level.id, 'a wall');
+    const start = input.start;
+    const end = input.end;
+    const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+    if (length < WALL_MIN_LENGTH)
+        refuse('wall_too_short', `A wall from [${start}] to [${end}] is ${length.toFixed(3)} m long; the editor draws none shorter than ${WALL_MIN_LENGTH} m.`, { length });
+    const curveOffset = input.curveOffset
+        ? normalizeWallCurveOffset({ start, end }, input.curveOffset)
+        : 0;
+    const walls = Object.values(nodes).filter((node) => node.type === 'wall').length;
+    const wall = WallNode.parse({
+        name: `Wall ${walls + 1}`,
+        parentId: level.id,
+        start,
+        end,
+        ...(input.thickness === undefined ? {} : { thickness: input.thickness }),
+        ...(input.height === undefined ? {} : { height: input.height }),
+        ...(curveOffset ? { curveOffset } : {}),
+    });
+    return {
+        result: {
+            ok: true,
+            wallId: wall.id,
+            name: wall.name,
+            levelId: level.id,
+            length: Math.round(length * 1000) / 1000,
+            ...(curveOffset ? { curveOffset } : {}),
+            message: `Added wall "${wall.name}" on ${level.name ?? level.id}`,
+        },
+        changes: { create: [{ node: wall, parentId: level.id }] },
+    };
+};

package/dist/agent-operations/apply-changes.d.ts

@@ -0,0 +1,16 @@
+import type { AnyNode } from '../schema/index.js';
+import type { SceneChanges, SceneNodes } from './types.js';
+/**
+ * The scene after an operation's changes, without a store: for checks and previews. Same order as
+ * the store's applyNodeChanges — updates, creates, then deletes — so an opening moved off a wall
+ * being replaced is no longer among that wall's children when it goes.
+ */
+export declare function applySceneChanges(nodes: SceneNodes, changes: SceneChanges | undefined): Record<string, AnyNode>;
+/**
+ * Several operations' changes, in order, as one set that lands the scene where applying them one
+ * by one does — whether a surface applies creates, updates or deletes first: a batch is one undo
+ * step. Updates to a node the batch created are folded into its creation, and a node created then
+ * deleted never appears; updates only reach nodes that existed before, deletes come last.
+ */
+export declare function mergeSceneChanges(sets: readonly SceneChanges[]): Required<Omit<SceneChanges, 'materials'>> & Pick<SceneChanges, 'materials'>;
+//# sourceMappingURL=apply-changes.d.ts.map

package/dist/agent-operations/apply-changes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-changes.d.ts","sourceRoot":"","sources":["../../src/agent-operations/apply-changes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAA6B,MAAM,WAAW,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAKvD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,YAAY,GAAG,SAAS,GAChC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAkCzB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,SAAS,YAAY,EAAE,GAC5B,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC,GAAG,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,CAwC7E"}

package/dist/agent-operations/apply-changes.js

@@ -0,0 +1,93 @@
+const childrenOf = (node) => node && 'children' in node && Array.isArray(node.children) ? node.children : null;
+/**
+ * The scene after an operation's changes, without a store: for checks and previews. Same order as
+ * the store's applyNodeChanges — updates, creates, then deletes — so an opening moved off a wall
+ * being replaced is no longer among that wall's children when it goes.
+ */
+export function applySceneChanges(nodes, changes) {
+    const next = { ...nodes };
+    const setChildren = (parentId, edit) => {
+        const parent = parentId ? next[parentId] : undefined;
+        const children = childrenOf(parent);
+        if (parent && children)
+            next[parent.id] = { ...parent, children: edit(children) };
+    };
+    const detach = (parentId, id) => setChildren(parentId, (ids) => ids.filter((child) => child !== id));
+    const attach = (parentId, id) => setChildren(parentId, (ids) => (ids.includes(id) ? ids : [...ids, id]));
+    for (const { id, data } of changes?.update ?? []) {
+        const current = next[id];
+        if (!current)
+            continue;
+        if (data.parentId !== undefined && data.parentId !== current.parentId) {
+            detach(current.parentId, id);
+            attach(data.parentId, id);
+        }
+        next[id] = { ...current, ...data };
+    }
+    for (const { node, parentId } of changes?.create ?? []) {
+        next[node.id] = parentId ? { ...node, parentId } : node;
+        attach(parentId ?? node.parentId, node.id);
+    }
+    const remove = (id) => {
+        const node = next[id];
+        delete next[id];
+        for (const child of childrenOf(node) ?? [])
+            remove(child);
+    };
+    for (const id of changes?.delete ?? []) {
+        detach(next[id]?.parentId, id);
+        remove(id);
+    }
+    return next;
+}
+/**
+ * Several operations' changes, in order, as one set that lands the scene where applying them one
+ * by one does — whether a surface applies creates, updates or deletes first: a batch is one undo
+ * step. Updates to a node the batch created are folded into its creation, and a node created then
+ * deleted never appears; updates only reach nodes that existed before, deletes come last.
+ */
+export function mergeSceneChanges(sets) {
+    const created = new Map();
+    const updated = new Map();
+    const deleted = new Set();
+    const collections = {};
+    const materials = new Map();
+    const dropCreated = (id) => {
+        created.delete(id);
+        for (const [childId, entry] of [...created])
+            if ((entry.parentId ?? entry.node.parentId) === id)
+                dropCreated(childId);
+    };
+    for (const set of sets) {
+        Object.assign(collections, set.collections);
+        for (const material of set.materials ?? [])
+            materials.set(material.id, material);
+        for (const { id, data } of set.update ?? []) {
+            const entry = created.get(id);
+            if (entry)
+                created.set(id, {
+                    node: { ...entry.node, ...data },
+                    parentId: data.parentId ?? entry.parentId,
+                });
+            else
+                updated.set(id, { ...updated.get(id), ...data });
+        }
+        for (const entry of set.create ?? [])
+            created.set(entry.node.id, entry);
+        for (const id of set.delete ?? []) {
+            if (created.has(id)) {
+                dropCreated(id);
+                continue;
+            }
+            updated.delete(id);
+            deleted.add(id);
+        }
+    }
+    return {
+        ...(materials.size ? { materials: [...materials.values()] } : {}),
+        create: [...created.values()],
+        update: [...updated].map(([id, data]) => ({ id, data })),
+        delete: [...deleted],
+        collections,
+    };
+}