@pascal-app/mcp 1.0.1 → 1.0.4

package/dist/tools/patch-guards.js

@@ -0,0 +1,253 @@
+import { nodeRegistry, planNodeDeletion, previewDefaultGutterRefresh, validateNodeRelations, } from '@pascal-app/core';
+import { scriptedFieldRefusal, unknownMaterialPresetRefusal, } from '@pascal-app/core/agent-operations';
+import { AnyNode, nodeKindOf, parseNode } from '@pascal-app/core/schema';
+const guards = [];
+/** Runs a guard on every apply_patch from now on; registering a guard again replaces it. */
+export function registerPatchGuard(guard) {
+    const at = guards.findIndex((known) => known.name === guard.name);
+    if (at >= 0)
+        guards[at] = guard;
+    else
+        guards.push(guard);
+    guards.sort((a, b) => a.order - b.order);
+}
+export function runPatchGuards(patches, nodes) {
+    for (const guard of guards)
+        guard.run(patches, nodes);
+}
+/**
+ * A patch op refused because it would break node identity, the hierarchy or
+ * the node's schema. apply_patch returns it as a tool error whose text is
+ * JSON `{ code, patchIndex, id, message }`.
+ */
+export class PatchRefusedError extends Error {
+    code;
+    patchIndex;
+    nodeId;
+    constructor(code, patchIndex, nodeId, detail) {
+        super(`${code}: patches[${patchIndex}] ${detail}`);
+        this.code = code;
+        this.patchIndex = patchIndex;
+        this.nodeId = nodeId;
+        this.name = 'PatchRefusedError';
+    }
+}
+/**
+ * Fields an update may restate but not change: `id` and `type` are the node's
+ * identity, `object` and `children` its place in the graph. `parentId` stays
+ * writable, checked below: the store reconciles both parents' `children`.
+ */
+const IMMUTABLE_FIELDS = [
+    ['id', 'identity_change'],
+    ['type', 'identity_change'],
+    ['object', 'immutable_field'],
+    ['children', 'immutable_field'],
+];
+const CORE_KINDS = new Set(AnyNode.options.map(nodeKindOf));
+const sameValue = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+ * Schema issues of a node, keyed `path: message`, from its kind's schema: the
+ * registered definition's, or the core per-kind schema. `null` only for a kind
+ * with neither (a plugin kind this runtime has not registered), which is then
+ * not validated.
+ */
+function schemaIssues(node) {
+    const type = node.type;
+    if (typeof type !== 'string')
+        return null;
+    const schema = nodeRegistry.get(type)?.schema;
+    if (!(schema || CORE_KINDS.has(type)))
+        return null;
+    const result = schema ? schema.safeParse(node) : parseNode(node);
+    const issues = result.success ? [] : (result.error?.issues ?? []);
+    return new Set(issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`));
+}
+function withChild(parent, childId) {
+    const children = parent.children;
+    if (!Array.isArray(children) || children.includes(childId))
+        return parent;
+    return { ...parent, children: [...children, childId] };
+}
+function withoutChild(parent, childId) {
+    const children = parent.children;
+    if (!Array.isArray(children))
+        return parent;
+    return { ...parent, children: children.filter((id) => id !== childId) };
+}
+/**
+ * Dry-runs a patch against the scene as each op leaves it and refuses:
+ * - a create whose id is already present (`node_exists`): a silent replace
+ *   orphans the old node's children;
+ * - an update that changes `id`, `type`, `object` or `children`
+ *   (`immutable_field`); restating the current value passes;
+ * - an update whose merged node has schema issues the node did not have
+ *   before (`invalid_update`); kinds without a schema in this runtime pass;
+ * - an update writing a material preset the catalog does not know
+ *   (`invalid_update`; a create is rejected like other invalid creates): it
+ *   would render as the default finish;
+ * - an update of what a node's script owns, its `source` or the size it
+ *   built (`scripted_field`): only a rebuild keeps them and the geometry in step;
+ * - any op on a node an earlier delete in the patch removed, or on a default
+ *   gutter or downspout that delete regenerates, and any update of the roof
+ *   segment holding them (`regenerated_default`).
+ *
+ * Deletes run through the bridge's own deletion preview (`planDeletion`; the
+ * local bridge uses core's store planner), one call per run of consecutive
+ * deletes as the bridge batches them, so cascades and wall merges are seen as
+ * that bridge applies them. A bridge without a preview gets a stricter rule:
+ * a create may not reuse any id present at the start of the patch.
+ * An update of a roof segment unsettles the default gutters its refresh may
+ * regenerate, as a delete does.
+ * Lives in the tool layer so every bridge behind `apply_patch` inherits it.
+ */
+export function assertPatchKeepsIdentity(patches, nodes, rootNodeIds, planDeletion) {
+    const initialIds = new Set(Object.keys(nodes));
+    let scene = {
+        nodes: { ...nodes },
+        rootNodeIds: [...rootNodeIds],
+        collections: {},
+    };
+    const at = (id) => scene.nodes[id];
+    const put = (node) => {
+        scene.nodes[node.id] = node;
+    };
+    // Default gutters and downspouts a delete run refreshes: the store may keep,
+    // move or replace them with freshly minted ids, so later ops in the same
+    // patch cannot address them reliably.
+    const regenerated = new Map();
+    // Roof segments whose `children` that refresh rewrites: an update restating
+    // their pre-delete children would bring back obsolete ids.
+    const regeneratedHosts = new Map();
+    const refuseRegenerated = (index, id) => {
+        const deleteIndex = regenerated.get(id);
+        if (deleteIndex === undefined)
+            return;
+        throw new PatchRefusedError('regenerated_default', index, id, `"${id}" is a default gutter or downspout that the edit at patches[${deleteIndex}] regenerates. Address it in a separate apply_patch call.`);
+    };
+    // Updating a roof or roof segment makes the store refresh that roof's
+    // default gutters, with the same effect on ids as a delete's refresh.
+    const unsettleRoofRefresh = (node, index) => {
+        const roofId = node.type === 'roof' ? node.id : node.type === 'roof-segment' ? node.parentId : null;
+        if (!roofId)
+            return;
+        const preview = previewDefaultGutterRefresh(scene.nodes, [roofId]);
+        for (const id of preview.unsettledIds)
+            regenerated.set(id, index);
+        for (const id of preview.regeneratedHostIds)
+            regeneratedHosts.set(id, index);
+    };
+    let pendingDeletes = [];
+    const flushDeletes = (index) => {
+        const plan = planDeletion
+            ? planDeletion(scene, pendingDeletes)
+            : planNodeDeletion(scene, pendingDeletes, { mintDefaults: false });
+        for (const id of plan.unsettledIds)
+            regenerated.set(id, index);
+        for (const id of plan.regeneratedHostIds)
+            regeneratedHosts.set(id, index);
+        scene = { nodes: plan.nodes, rootNodeIds: plan.rootNodeIds, collections: plan.collections };
+        pendingDeletes = [];
+    };
+    patches.forEach((patch, index) => {
+        if (patch.op === 'create') {
+            // Parse like the store does, so defaults such as an empty `children`
+            // list exist for later ops in the patch; the bridge reports schema errors.
+            const parsed = parseNode(patch.node);
+            const node = (parsed.success ? parsed.data : patch.node);
+            if (typeof node?.id !== 'string')
+                return;
+            const preset = unknownMaterialPresetRefusal(node);
+            if (preset)
+                throw new Error(`invalid patch: patches[${index}] create "${node.id}": ${preset}`);
+            refuseRegenerated(index, node.id);
+            const effectiveParentId = patch.parentId ?? node.parentId;
+            if (effectiveParentId)
+                refuseRegenerated(index, effectiveParentId);
+            if (at(node.id) || (!planDeletion && initialIds.has(node.id))) {
+                throw new PatchRefusedError('node_exists', index, node.id, planDeletion || at(node.id)
+                    ? `create id "${node.id}" already exists. Use op "update" to change it, or delete it earlier in the same patch to replace it.`
+                    : `create id "${node.id}" existed when the patch started, and this bridge cannot preview its deletes. Delete it in one apply_patch call and create it in the next.`);
+            }
+            const parentId = patch.parentId ?? node.parentId ?? null;
+            if (patch.parentId !== undefined && !at(patch.parentId)) {
+                throw new Error(`invalid patch: patches[${index}] create parentId "${patch.parentId}" not found`);
+            }
+            put({ ...node, parentId });
+            const parent = parentId ? at(parentId) : undefined;
+            if (parent)
+                put(withChild(parent, node.id));
+            return;
+        }
+        if (patch.op === 'update') {
+            refuseRegenerated(index, patch.id);
+            const hostDeleteIndex = regeneratedHosts.get(patch.id);
+            if (hostDeleteIndex !== undefined) {
+                throw new PatchRefusedError('regenerated_default', index, patch.id, `the edit at patches[${hostDeleteIndex}] regenerates the default gutters and downspouts under "${patch.id}", so its children are not known yet. Update it in a separate apply_patch call.`);
+            }
+            if (typeof patch.data?.parentId === 'string')
+                refuseRegenerated(index, patch.data.parentId);
+            const current = at(patch.id);
+            if (!current)
+                throw new Error(`invalid patch: patches[${index}] update id "${patch.id}" not found`);
+            if (!patch.data || typeof patch.data !== 'object')
+                return;
+            const data = patch.data;
+            for (const [field, code] of IMMUTABLE_FIELDS) {
+                const before = current[field];
+                if (field in data && !sameValue(data[field], before)) {
+                    throw new PatchRefusedError(code, index, patch.id, `update cannot change "${field}" of "${patch.id}" (${JSON.stringify(before)} → ${JSON.stringify(data[field])}). Create a new node, delete the old one, or reparent children through their own parentId.`);
+                }
+            }
+            const scripted = scriptedFieldRefusal(current, data);
+            if (scripted)
+                throw new PatchRefusedError('scripted_field', index, patch.id, scripted);
+            const preset = unknownMaterialPresetRefusal(data, current);
+            if (preset)
+                throw new PatchRefusedError('invalid_update', index, patch.id, preset);
+            const merged = { ...current, ...data };
+            const issuesAfter = schemaIssues(merged);
+            if (issuesAfter && issuesAfter.size > 0) {
+                const issuesBefore = schemaIssues(current) ?? new Set();
+                const added = [...issuesAfter].filter((issue) => !issuesBefore.has(issue));
+                if (added.length > 0) {
+                    throw new PatchRefusedError('invalid_update', index, patch.id, `update of ${current.type} "${patch.id}" fails its schema: ${added.slice(0, 5).join('; ')}`);
+                }
+            }
+            if ('parentId' in data && data.parentId !== current.parentId) {
+                const newParent = typeof data.parentId === 'string' ? at(data.parentId) : undefined;
+                if (!(newParent && Array.isArray(newParent.children))) {
+                    throw new PatchRefusedError('invalid_parent', index, patch.id, `update cannot move "${patch.id}" under ${JSON.stringify(data.parentId)}: ${newParent ? `a ${newParent.type} holds no children` : 'no such node'}.`);
+                }
+                const before = { ...scene.nodes };
+                const oldParent = current.parentId ? at(current.parentId) : undefined;
+                if (oldParent)
+                    put(withoutChild(oldParent, patch.id));
+                put(withChild(newParent, patch.id));
+                put(merged);
+                unsettleRoofRefresh(merged, index);
+                try {
+                    validateNodeRelations(before, scene.nodes, [patch.id]);
+                }
+                catch (err) {
+                    throw new PatchRefusedError('invalid_parent', index, patch.id, `${newParent.type} "${newParent.id}" does not accept "${patch.id}": ${err instanceof Error ? err.message : String(err)}`);
+                }
+                return;
+            }
+            put(merged);
+            unsettleRoofRefresh(merged, index);
+            return;
+        }
+        if (patch.op === 'delete') {
+            refuseRegenerated(index, patch.id);
+            if (!at(patch.id) || pendingDeletes.includes(patch.id)) {
+                throw new Error(`invalid patch: patches[${index}] delete id "${patch.id}" not found`);
+            }
+            pendingDeletes.push(patch.id);
+            // The bridge applies a run of consecutive deletes as one deleteNodes
+            // call, and wall merges and kind cascades depend on the whole id list,
+            // so plan the run together once it ends.
+            if (patches[index + 1]?.op !== 'delete')
+                flushDeletes(index);
+        }
+    });
+}

package/dist/tools/photo-to-scene/photo-to-scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"photo-to-scene.d.ts","sourceRoot":"","sources":["../../../src/tools/photo-to-scene/photo-to-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAYxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAKvD;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;CAa7B,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;CAQ9B,CAAA;AAmTD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA8ErF"}
+{"version":3,"file":"photo-to-scene.d.ts","sourceRoot":"","sources":["../../../src/tools/photo-to-scene/photo-to-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAMxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAKvD;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;CAa7B,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;CAQ9B,CAAA;AAmTD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA8ErF"}

package/dist/tools/photo-to-scene/photo-to-scene.js

@@ -1,5 +1,6 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { AnyNode, BuildingNode, LevelNode, SiteNode, WallNode, ZoneNode, } from '@pascal-app/core/schema';
+import { newZone } from '@pascal-app/core';
+import { AnyNode, BuildingNode, LevelNode, SiteNode, WallNode } from '@pascal-app/core/schema';
 import { z } from 'zod';
 import { DESTRUCTIVE_OPEN_WORLD_TOOL_ANNOTATIONS } from '../annotations.js';
 import { appendLiveSceneEvent } from '../live-sync.js';
@@ -236,7 +237,7 @@ function buildSceneGraphFromVision(vision, defaultWallThickness, defaultWallHeig
     for (let i = 0; i < vision.rooms.length; i++) {
         const r = vision.rooms[i];
         try {
-            const zone = ZoneNode.parse({
+            const zone = newZone({
                 name: r.name,
                 polygon: r.polygon,
             });

package/dist/tools/place-design.d.ts

@@ -0,0 +1,34 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations/index.js';
+export declare const placeDesignInput: {
+    design: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    hostId: z.ZodString;
+    position: z.ZodArray<z.ZodNumber>;
+    rotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    side: z.ZodOptional<z.ZodEnum<{
+        front: "front";
+        back: "back";
+    }>>;
+    surfaceId: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    name: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+};
+export declare const placeDesignOutput: {
+    project: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unsaved: z.ZodOptional<z.ZodString>;
+    persistence: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            unbound: "unbound";
+            events_unsupported: "events_unsupported";
+        }>;
+        warning: z.ZodString;
+    }, z.core.$strip>>;
+    designId: z.ZodString;
+    parentId: z.ZodString;
+    surfaceId: z.ZodNullable<z.ZodString>;
+};
+export declare function registerPlaceDesign(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=place-design.d.ts.map

package/dist/tools/place-design.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"place-design.d.ts","sourceRoot":"","sources":["../../src/tools/place-design.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAOpD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;CA8B5B,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;CAK7B,CAAA;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAyDpF"}

package/dist/tools/place-design.js

@@ -0,0 +1,91 @@
+import { DesignPlacementError, planDesignPlacement } from '@pascal-app/core/procedural-items';
+import { z } from 'zod';
+import { ADDITIVE_TOOL_ANNOTATIONS } from './annotations.js';
+import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+import { measurement } from './measurement.js';
+import { NodeIdSchema, Vec3Schema } from './schemas.js';
+import { validateDesignInput } from './validate-design.js';
+export const placeDesignInput = {
+    design: validateDesignInput.design,
+    hostId: NodeIdSchema.describe('Floor designs: a level, or a slab or zone on it, or a placed design with surfaceId. Wall-side designs: a straight wall. Ceiling designs: a ceiling.'),
+    position: Vec3Schema.describe('Metres. Floor: level-local [x, y, z], y above the floor. Wall-side: [along, height, offset] of the mounting reference from the wall start. Ceiling: plan [x, 0, z] of the reference. Surface: [x, 0, z] in the surface frame.'),
+    rotation: measurement('angle', 'rad', {
+        description: 'Yaw. Not for wall-side designs; use side to face the other way.',
+    }).optional(),
+    side: z.enum(['front', 'back']).optional().describe('Wall face for wall-side designs.'),
+    surfaceId: z
+        .string()
+        .optional()
+        .describe('Named surface of the host design to rest on (see validate_design measurements.surfaces).'),
+    parameters: validateDesignInput.parameters,
+    slots: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Slot id to "#rrggbb" or a scene:/library: material reference.'),
+    name: z.string().optional(),
+    id: z
+        .string()
+        .optional()
+        .describe('Optional new id ("procedural-item_…"). Refused if it exists: this tool only creates.'),
+};
+export const placeDesignOutput = {
+    designId: z.string(),
+    parentId: z.string(),
+    surfaceId: z.string().nullable(),
+    ...liveSyncOutput,
+};
+export function registerPlaceDesign(server, bridge) {
+    server.registerTool('place_design', {
+        title: 'Place design',
+        description: 'Create one instance of a design (procedural item recipe, object or JSON string) in the scene. The design must pass validate_design. Its mounting picks the host: floor designs go on a level (or a slab or zone of it) or on a named surface of a placed design; wall-side designs on a straight wall face; ceiling designs under a ceiling. Only creates: refusals are tool errors whose JSON carries a code (invalid_design with diagnostics, design_version_not_enabled for version 2 designs until the next release, design_too_large above 24 KiB, invalid_placement, node_exists, host_not_found, wrong_host, unknown_surface, does_not_fit) and change nothing.',
+        inputSchema: placeDesignInput,
+        outputSchema: placeDesignOutput,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+    }, async (args) => {
+        const refuse = (refusal) => ({
+            content: [{ type: 'text', text: JSON.stringify(refusal) }],
+            isError: true,
+        });
+        let placement;
+        try {
+            placement = planDesignPlacement(bridge.getNodes(), {
+                ...args,
+                position: args.position,
+            });
+        }
+        catch (error) {
+            if (!(error instanceof DesignPlacementError))
+                throw error;
+            return refuse({
+                code: error.code,
+                message: error.message,
+                ...(error.diagnostics.length > 0 && { diagnostics: error.diagnostics.slice(0, 8) }),
+            });
+        }
+        const { node, parentId, hostUpdate } = placement;
+        const patches = [
+            { op: 'create', node: node, parentId: parentId },
+            ...(hostUpdate
+                ? [
+                    {
+                        op: 'update',
+                        id: hostUpdate.id,
+                        data: { attachments: hostUpdate.attachments },
+                    },
+                ]
+                : []),
+        ];
+        bridge.applyPatch(patches);
+        const persistence = await publishLiveSceneSnapshot(bridge, 'place_design');
+        const payload = {
+            designId: node.id,
+            parentId,
+            surfaceId: args.surfaceId ?? null,
+            ...persistencePayload(persistence),
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/redo.d.ts

@@ -5,6 +5,8 @@ export declare const redoInput: {
     steps: z.ZodOptional<z.ZodNumber>;
 };
 export declare const redoOutput: {
+    project: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unsaved: z.ZodOptional<z.ZodString>;
     persistence: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
             unbound: "unbound";

package/dist/tools/redo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redo.d.ts","sourceRoot":"","sources":["../../src/tools/redo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAIpD,eAAO,MAAM,SAAS;;CAErB,CAAA;AAED,eAAO,MAAM,UAAU;;;;;;;;;CAGtB,CAAA;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAsB7E"}
+{"version":3,"file":"redo.d.ts","sourceRoot":"","sources":["../../src/tools/redo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AASpD,eAAO,MAAM,SAAS;;CAErB,CAAA;AAED,eAAO,MAAM,UAAU;;;;;;;;;;;CAGtB,CAAA;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAsB7E"}

package/dist/tools/redo.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
-import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+import { currentLiveSync, liveSyncOutput, persistencePayload, publishLiveSceneSnapshot, } from './live-sync.js';
 export const redoInput = {
     steps: z.number().int().positive().optional(),
 };
@@ -17,7 +17,7 @@ export function registerRedo(server, bridge) {
         annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
     }, async ({ steps }) => {
         const redone = bridge.redo(steps ?? 1);
-        const persistence = redone > 0 ? await publishLiveSceneSnapshot(bridge, 'redo') : 'published';
+        const persistence = redone > 0 ? await publishLiveSceneSnapshot(bridge, 'redo') : currentLiveSync(bridge);
         const payload = { redone, ...persistencePayload(persistence) };
         return {
             content: [{ type: 'text', text: JSON.stringify(payload) }],

package/dist/tools/room-tools.d.ts

@@ -1,125 +1,62 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
 import type { SceneOperations } from '../operations/index.js';
-export declare const searchAssetsInput: {
-    query: z.ZodString;
-    category: z.ZodOptional<z.ZodString>;
-};
-export declare const searchAssetsOutput: {
-    results: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    total: z.ZodNumber;
-};
-export declare const createRoomInput: {
-    levelId: z.ZodString;
-    name: z.ZodString;
-    polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
-    color: z.ZodOptional<z.ZodString>;
-    wallHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    wallThickness: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-};
-export declare const createRoomOutput: {
-    persistence: z.ZodOptional<z.ZodObject<{
-        status: z.ZodEnum<{
-            unbound: "unbound";
-            events_unsupported: "events_unsupported";
-        }>;
-        warning: z.ZodString;
-    }, z.core.$strip>>;
-    zoneId: z.ZodString;
-    slabId: z.ZodString;
-    ceilingId: z.ZodString;
-    wallIds: z.ZodArray<z.ZodString>;
-    areaSqMeters: z.ZodNumber;
-};
-export declare const addDoorInput: {
-    wallId: z.ZodString;
-    t: z.ZodOptional<z.ZodNumber>;
-    position: z.ZodOptional<z.ZodNumber>;
-    width: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    hingesSide: z.ZodOptional<z.ZodEnum<{
-        right: "right";
-        left: "left";
-    }>>;
-    swingDirection: z.ZodOptional<z.ZodEnum<{
-        inward: "inward";
-        outward: "outward";
-    }>>;
-};
+import { type GeometryScriptHost } from './add-object.js';
+/** The contract's one result (core `addWallOpening`), and the live sync's note. */
 export declare const addDoorOutput: {
-    persistence: z.ZodOptional<z.ZodObject<{
-        status: z.ZodEnum<{
+    project: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    unsaved: import("zod").ZodOptional<import("zod").ZodString>;
+    persistence: import("zod").ZodOptional<import("zod").ZodObject<{
+        status: import("zod").ZodEnum<{
             unbound: "unbound";
             events_unsupported: "events_unsupported";
         }>;
-        warning: z.ZodString;
-    }, z.core.$strip>>;
-    doorId: z.ZodString;
-    localX: z.ZodNumber;
-    t: z.ZodNumber;
-    position: z.ZodNumber;
-    wallLength: z.ZodNumber;
-    clamped: z.ZodBoolean;
-    coordinateSystem: z.ZodLiteral<"wall-local-meters">;
-};
-export declare const addWindowInput: {
-    wallId: z.ZodString;
-    t: z.ZodOptional<z.ZodNumber>;
-    position: z.ZodOptional<z.ZodNumber>;
-    width: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    sillHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        warning: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    ok: import("zod").ZodLiteral<true>;
+    wallId: import("zod").ZodString;
+    localX: import("zod").ZodNumber;
+    t: import("zod").ZodNumber;
+    wallLength: import("zod").ZodNumber;
+    clamped: import("zod").ZodBoolean;
+    coordinateSystem: import("zod").ZodLiteral<"wall-local-meters">;
+    message: import("zod").ZodString;
+    achieved: import("zod").ZodObject<{
+        created: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
+        updated: import("zod").ZodNumber;
+        deleted: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
+        unchanged: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+    }, import("zod/v4/core").$strip>;
+    doorId: import("zod").ZodString;
 };
 export declare const addWindowOutput: {
-    persistence: z.ZodOptional<z.ZodObject<{
-        status: z.ZodEnum<{
+    project: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    unsaved: import("zod").ZodOptional<import("zod").ZodString>;
+    persistence: import("zod").ZodOptional<import("zod").ZodObject<{
+        status: import("zod").ZodEnum<{
             unbound: "unbound";
             events_unsupported: "events_unsupported";
         }>;
-        warning: z.ZodString;
-    }, z.core.$strip>>;
-    windowId: z.ZodString;
-    localX: z.ZodNumber;
-    t: z.ZodNumber;
-    position: z.ZodNumber;
-    wallLength: z.ZodNumber;
-    clamped: z.ZodBoolean;
-    coordinateSystem: z.ZodLiteral<"wall-local-meters">;
-    sillHeight: z.ZodNumber;
-};
-export declare const furnishRoomInput: {
-    levelId: z.ZodOptional<z.ZodString>;
-    zoneId: z.ZodOptional<z.ZodString>;
-    roomType: z.ZodEnum<{
-        bedroom: "bedroom";
-        storage: "storage";
-        living: "living";
-        dining: "dining";
-        kitchen: "kitchen";
-        bathroom: "bathroom";
-        laundry: "laundry";
-        entry: "entry";
-        hallway: "hallway";
-    }>;
-    polygon: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
-    doorWallIndex: z.ZodOptional<z.ZodNumber>;
-};
-export declare const furnishRoomOutput: {
-    persistence: z.ZodOptional<z.ZodObject<{
-        status: z.ZodEnum<{
-            unbound: "unbound";
-            events_unsupported: "events_unsupported";
-        }>;
-        warning: z.ZodString;
-    }, z.core.$strip>>;
-    placed: z.ZodNumber;
-    itemIds: z.ZodArray<z.ZodString>;
-    skipped: z.ZodArray<z.ZodString>;
-};
-export declare function registerSearchAssets(server: McpServer): void;
-export declare function registerCreateRoom(server: McpServer, bridge: SceneOperations): void;
-export declare function registerAddDoor(server: McpServer, bridge: SceneOperations): void;
-export declare function registerAddWindow(server: McpServer, bridge: SceneOperations): void;
-export declare function registerFurnishRoom(server: McpServer, bridge: SceneOperations): void;
-export declare function registerRoomTools(server: McpServer, bridge: SceneOperations): void;
+        warning: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    sillHeight: import("zod").ZodOptional<import("zod").ZodNumber>;
+    ok: import("zod").ZodLiteral<true>;
+    wallId: import("zod").ZodString;
+    localX: import("zod").ZodNumber;
+    t: import("zod").ZodNumber;
+    wallLength: import("zod").ZodNumber;
+    clamped: import("zod").ZodBoolean;
+    coordinateSystem: import("zod").ZodLiteral<"wall-local-meters">;
+    message: import("zod").ZodString;
+    achieved: import("zod").ZodObject<{
+        created: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
+        updated: import("zod").ZodNumber;
+        deleted: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
+        unchanged: import("zod").ZodOptional<import("zod").ZodLiteral<true>>;
+    }, import("zod/v4/core").$strip>;
+    windowId: import("zod").ZodString;
+};
+export declare function registerAddDoor(server: McpServer, bridge: SceneOperations, geometryScripts?: GeometryScriptHost): void;
+export declare function registerAddWindow(server: McpServer, bridge: SceneOperations, geometryScripts?: GeometryScriptHost): void;
+/** add_door and add_window; create_room and furnish_room are shared tools (shared-tools.ts). */
+export declare function registerRoomTools(server: McpServer, bridge: SceneOperations, geometryScripts?: GeometryScriptHost): void;
 //# sourceMappingURL=room-tools.d.ts.map

package/dist/tools/room-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"room-tools.d.ts","sourceRoot":"","sources":["../../src/tools/room-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAWxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAkCpD,eAAO,MAAM,iBAAiB;;;CAG7B,CAAA;AAED,eAAO,MAAM,kBAAkB;;;CAG9B,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;CAa3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;CAO5B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;CAQxB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;CASzB,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;CAU1B,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;CAU3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;CAM5B,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;CAK7B,CAAA;AA4QD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAuB5D;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAuDnF;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA6ChF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA4ClF;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA0HpF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAMlF"}
+{"version":3,"file":"room-tools.d.ts","sourceRoot":"","sources":["../../src/tools/room-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAyBxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,EAAmB,KAAK,kBAAkB,EAAc,MAAM,cAAc,CAAA;AAMnF,mFAAmF;AACnF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;CAA0C,CAAA;AACpE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4C,CAAA;AAoHxE,wBAAgB,eAAe,CAC7B,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,eAAe,EACvB,eAAe,CAAC,EAAE,kBAAkB,GACnC,IAAI,CA8BN;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,eAAe,EACvB,eAAe,CAAC,EAAE,kBAAkB,GACnC,IAAI,CA8BN;AAED,gGAAgG;AAChG,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,eAAe,EACvB,eAAe,CAAC,EAAE,kBAAkB,GACnC,IAAI,CAGN"}