@pascal-app/mcp 1.0.3 → 1.0.4

package/dist/tools/shared-tools.js

@@ -0,0 +1,361 @@
+import { AGENT_OPERATIONS, achievedChanges, applyAgentOutcome, writeCollections, } from '@pascal-app/core/agent-operations';
+import { addLevelTool, addWallTool, createRoomTool, createStairTool, deleteNodeTool, duplicateLevelTool, findByTypeTool, fitStairTool, furnishRoomTool, getLevelSummaryTool, getNodeTool, getWallsTool, getZonesTool, listLevelsTool, measureStairTool, paintTool, placeItemsTool, ROOM_TOOL_CONTRACTS, searchAssetsTool, searchMaterialsTool, verifySceneTool, } from '@pascal-app/core/agent-tools';
+import { MaterialSchema, SceneMaterial, } from '@pascal-app/core/schema';
+import { z } from 'zod';
+import { ADDITIVE_TOOL_ANNOTATIONS, DESTRUCTIVE_TOOL_ANNOTATIONS, READ_ONLY_TOOL_ANNOTATIONS, } from './annotations.js';
+import { builtInCatalog } from './asset-catalog.js';
+import { registerCollectionTools } from './collections.js';
+import { refusalResult } from './errors.js';
+import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+import { ROOM_TOOL_ANNOTATIONS, structureOutput } from './structure-tools.js';
+const jsonObject = z.record(z.string(), z.unknown());
+/** What the scene holds after a mutating call (core achievedChanges). */
+const achievedOutput = {
+    achieved: z
+        .object({
+        created: z.record(z.string(), z.number()),
+        updated: z.number(),
+        deleted: z.record(z.string(), z.number()),
+        unchanged: z.literal(true).optional(),
+    })
+        .optional(),
+};
+const levelRoleOutput = {
+    levelId: z.string(),
+    levelName: z.string().optional(),
+    floorIndex: z.number(),
+    role: z.string(),
+    metadataRole: z.string().nullable(),
+    isOccupiedStory: z.boolean(),
+    isSupportLevel: z.boolean(),
+    referenceLevelId: z.string().nullable(),
+};
+const SHARED_TOOLS = [
+    {
+        contract: measureStairTool,
+        operation: AGENT_OPERATIONS.measure_stair,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: { measurements: z.json(), layouts: z.json() },
+    },
+    {
+        contract: fitStairTool,
+        operation: AGENT_OPERATIONS.fit_stair,
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+        outputSchema: { stairId: z.string().min(1), measurements: z.json(), ...liveSyncOutput },
+    },
+    {
+        contract: findByTypeTool,
+        operation: AGENT_OPERATIONS.find_by_type,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: listLevelsTool,
+        operation: AGENT_OPERATIONS.list_levels,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: {
+            activeSceneId: z.string().nullable(),
+            activeLevelId: z.string().nullable(),
+            levelCount: z.number(),
+            occupiedStoryCount: z.number(),
+            supportLevelCount: z.number(),
+            roofLevelIds: z.array(z.string()),
+            levels: z.array(jsonObject),
+        },
+        envelope: (bridge) => ({ activeSceneId: bridge.getActiveScene()?.id ?? null }),
+    },
+    {
+        contract: getNodeTool,
+        operation: AGENT_OPERATIONS.get_node,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: { node: jsonObject, materials: z.record(z.string(), SceneMaterial).optional() },
+    },
+    {
+        contract: getLevelSummaryTool,
+        operation: AGENT_OPERATIONS.get_level_summary,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: {
+            ...levelRoleOutput,
+            counts: jsonObject,
+            walls: z.array(jsonObject),
+            zones: z.array(jsonObject),
+            slabs: z.array(jsonObject),
+            ceilings: z.array(jsonObject),
+            items: z.array(jsonObject),
+            openings: z.array(jsonObject),
+            stairs: z.array(jsonObject),
+            roofs: z.array(jsonObject),
+            other: z.array(jsonObject),
+        },
+    },
+    {
+        contract: getWallsTool,
+        operation: AGENT_OPERATIONS.get_walls,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: { levelId: z.string(), walls: z.array(jsonObject) },
+    },
+    {
+        contract: getZonesTool,
+        operation: AGENT_OPERATIONS.get_zones,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: { levelId: z.string(), zones: z.array(jsonObject) },
+    },
+    {
+        contract: duplicateLevelTool,
+        operation: AGENT_OPERATIONS.duplicate_level,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+        outputSchema: {
+            newLevelId: z.string(),
+            name: z.string().optional(),
+            floorIndex: z.number(),
+            shiftedLevelIds: z.array(z.string()),
+            copied: z.record(z.string(), z.number()),
+            skipped: z.record(z.string(), z.number()),
+            newNodeIds: z.array(z.string()),
+            // A floor copy is hundreds of ids: the result lists 40 and counts the rest.
+            newNodeIdsOmitted: z.number().optional(),
+            ...achievedOutput,
+            ...liveSyncOutput,
+        },
+    },
+    {
+        contract: verifySceneTool,
+        operation: AGENT_OPERATIONS.verify_scene,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: {
+            ok: z.boolean(),
+            valid: z.boolean(),
+            levelCount: z.number(),
+            occupiedStoryCount: z.number(),
+            supportLevelCount: z.number(),
+            roofLevelIds: z.array(z.string()),
+            activeSceneId: z.string().nullable(),
+            activeLevelId: z.string().nullable(),
+            levels: z.array(jsonObject),
+            emptyLevelIds: z.array(z.string()),
+            issues: z.array(z.object({
+                type: z.string(),
+                message: z.string(),
+                severity: z.literal('info').optional(),
+                wallId: z.string().optional(),
+                end: z.enum(['start', 'end']).optional(),
+                reason: z.enum(['gap', 'crosses', 'parallel', 'rejected']).optional(),
+                gap: z.number().optional(),
+                nearestWallId: z.string().optional(),
+            })),
+            hasIssues: z.boolean(),
+            authoredObjects: z
+                .array(z.object({
+                id: z.string(),
+                name: z.string(),
+                category: z.string(),
+                reason: z.string().nullable(),
+            }))
+                .optional(),
+        },
+        envelope: (bridge) => ({ activeSceneId: bridge.getActiveScene()?.id ?? null }),
+    },
+    {
+        contract: addWallTool,
+        operation: AGENT_OPERATIONS.add_wall,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: addLevelTool,
+        operation: AGENT_OPERATIONS.add_level,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: createStairTool,
+        operation: AGENT_OPERATIONS.create_stair,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: placeItemsTool,
+        operation: AGENT_OPERATIONS.place_items,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+        catalog: true,
+    },
+    {
+        contract: deleteNodeTool,
+        operation: AGENT_OPERATIONS.delete_node,
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+        outputSchema: { deletedIds: z.array(z.string()), ...achievedOutput, ...liveSyncOutput },
+    },
+    {
+        contract: createRoomTool,
+        operation: AGENT_OPERATIONS.create_room,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+        outputSchema: {
+            ok: z.literal(true),
+            zoneId: z.string(),
+            // The floor plate and the ceiling the host derived; null where it derives none (a terrace).
+            slabId: z.string().nullable(),
+            ceilingId: z.string().nullable(),
+            // One per polygon edge; null where no wall runs along it.
+            wallIds: z.array(z.string().nullable()),
+            reusedWalls: z.number(),
+            areaSqMeters: z.number(),
+            doorIds: z.array(z.string()),
+            windowIds: z.array(z.string()),
+            skippedOpenings: z
+                .array(z.object({
+                kind: z.enum(['door', 'window']),
+                index: z.number(),
+                code: z.string(),
+                message: z.string(),
+            }))
+                .optional(),
+            message: z.string(),
+            ...achievedOutput,
+            ...liveSyncOutput,
+        },
+    },
+    {
+        contract: furnishRoomTool,
+        operation: AGENT_OPERATIONS.furnish_room,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+        catalog: true,
+        outputSchema: {
+            ok: z.literal(true),
+            placed: z.number(),
+            itemIds: z.array(z.string()),
+            skipped: z.array(z.string()),
+            doorWallIndex: z.number(),
+            doorsDetected: z.number(),
+            message: z.string(),
+            ...achievedOutput,
+            ...liveSyncOutput,
+        },
+    },
+    {
+        contract: searchAssetsTool,
+        operation: AGENT_OPERATIONS.search_assets,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        catalog: true,
+    },
+    {
+        contract: paintTool,
+        operation: AGENT_OPERATIONS.paint,
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+        outputSchema: {
+            ok: z.literal(true),
+            painted: z.array(z.object({ id: z.string(), roles: z.array(z.string()) })),
+            finish: z.string(),
+            materialId: z.string().optional(),
+            material: MaterialSchema.optional(),
+            createdMaterial: SceneMaterial.optional(),
+            note: z.string().optional(),
+            ...achievedOutput,
+            ...liveSyncOutput,
+        },
+    },
+    {
+        contract: searchMaterialsTool,
+        operation: AGENT_OPERATIONS.search_materials,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    },
+    ...ROOM_TOOL_CONTRACTS.map((contract) => {
+        const name = contract.name;
+        return {
+            contract,
+            operation: AGENT_OPERATIONS[name],
+            annotations: ROOM_TOOL_ANNOTATIONS[name],
+            outputSchema: { ...structureOutput, ...achievedOutput },
+        };
+    }),
+];
+export function toPatches(changes) {
+    return [
+        ...(changes.materials ?? []).map((material) => ({ op: 'upsert_material', material })),
+        ...(changes.create ?? []).map(({ node, parentId }) => ({
+            op: 'create',
+            node,
+            parentId: parentId,
+        })),
+        ...(changes.update ?? []).map(({ id, data }) => ({
+            op: 'update',
+            id: id,
+            data,
+        })),
+        ...(changes.delete ?? []).map((id) => ({
+            op: 'delete',
+            id: id,
+            cascade: true,
+        })),
+    ];
+}
+function writesScene(changes) {
+    return Boolean(changes &&
+        (toPatches(changes).length ||
+            (changes.collections && Object.keys(changes.collections).length)));
+}
+export function registerSharedTools(server, bridge, catalog = builtInCatalog) {
+    for (const tool of SHARED_TOOLS)
+        registerOperationTool(server, bridge, tool, catalog);
+    registerCollectionTools(server, bridge);
+}
+/**
+ * Registers one operation tool, as the shared tools are: a host adds a plugin's `'operation'`
+ * tools with it, from the plugin's `./agent-tools` contract and `./agent-operations` operation.
+ */
+export function registerOperationTool(server, bridge, tool, catalog = builtInCatalog) {
+    server.registerTool(tool.contract.name, {
+        title: tool.contract.title,
+        description: tool.contract.description,
+        inputSchema: tool.contract.input,
+        // Loose: a client that listed the tools rejects any field the schema leaves out, and the
+        // operations in core grow fields (verify_scene's guesses) that this list would miss.
+        ...(tool.outputSchema ? { outputSchema: z.looseObject(tool.outputSchema) } : {}),
+        annotations: tool.annotations,
+    }, async (input) => {
+        let outcome;
+        // A copy of the map: a host may write its own in place (the hosted bridge does), and a
+        // "before" that grows with the call reads every creation as unchanged.
+        const before = { ...bridge.getNodes() };
+        const context = {
+            activeLevelId: null,
+            ...(tool.catalog && { catalog: await catalog() }),
+            ...(bridge.supportsMaterialUpserts && bridge.getMaterials
+                ? { materials: bridge.getMaterials() }
+                : {}),
+        };
+        try {
+            outcome = tool.operation(before, input, context);
+        }
+        catch (error) {
+            return refusalResult(error);
+        }
+        let result = outcome.result;
+        let persistence = {};
+        // An outcome edits the scene through its node changes, its collection writes, or the
+        // follow-up it plans once the host has reconciled; any of them is one history step.
+        if (writesScene(outcome.changes) || outcome.afterReconcile) {
+            result = bridge.runAsSingleHistoryStep(() => applyAgentOutcome(outcome, {
+                getNodes: () => bridge.getNodes(),
+                applyChanges: (changes) => {
+                    const next = toPatches(changes);
+                    if (next.length)
+                        bridge.applyPatch(next);
+                    if (changes.collections && Object.keys(changes.collections).length)
+                        bridge.setCollections(writeCollections(bridge.getCollections(), changes.collections));
+                },
+                reconcile: () => {
+                    bridge.deriveStructure();
+                },
+            }));
+            persistence = persistencePayload(await publishLiveSceneSnapshot(bridge, tool.contract.name));
+        }
+        // What the scene holds after the call, not only what the call says it built.
+        const achieved = outcome.changes ? achievedChanges(before, outcome.changes) : null;
+        const payload = {
+            ...result,
+            ...(achieved ? { achieved } : {}),
+            ...(tool.envelope?.(bridge) ?? {}),
+            ...persistence,
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

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

@@ -0,0 +1,57 @@
+import type { ROOM_OPERATIONS } from '@pascal-app/core/agent-operations';
+import { z } from 'zod';
+import { ADDITIVE_TOOL_ANNOTATIONS, DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
+export type RoomToolName = keyof typeof ROOM_OPERATIONS;
+export declare const ROOM_TOOL_ANNOTATIONS: Record<RoomToolName, typeof ADDITIVE_TOOL_ANNOTATIONS | typeof DESTRUCTIVE_TOOL_ANNOTATIONS>;
+export declare const structureOutput: {
+    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>>;
+    zoneId: z.ZodOptional<z.ZodString>;
+    openingId: z.ZodOptional<z.ZodString>;
+    openingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    hints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodLiteral<"manual-ceiling">;
+        openingId: z.ZodString;
+        surfaceIds: z.ZodArray<z.ZodString>;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+    idMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    changes: z.ZodNumber;
+    separatorId: z.ZodOptional<z.ZodString>;
+    separatorIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    zoneIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    payload: z.ZodOptional<z.ZodObject<{
+        zoneId: z.ZodString;
+        name: z.ZodString;
+        mode: z.ZodEnum<{
+            merge: "merge";
+            delete: "delete";
+            blocked: "blocked";
+        }>;
+        mergedIntoZoneId: z.ZodOptional<z.ZodString>;
+        contents: z.ZodEnum<{
+            delete: "delete";
+            keep: "keep";
+        }>;
+        wallIds: z.ZodArray<z.ZodString>;
+        keptSharedWallIds: z.ZodArray<z.ZodString>;
+        separatorIds: z.ZodArray<z.ZodString>;
+        keptSharedSeparatorIds: z.ZodArray<z.ZodString>;
+        openingIds: z.ZodArray<z.ZodString>;
+        itemIds: z.ZodArray<z.ZodString>;
+        opensZoneIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    conflicts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        nodeIds: z.ZodArray<z.ZodString>;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+};
+//# sourceMappingURL=structure-tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"structure-tools.d.ts","sourceRoot":"","sources":["../../src/tools/structure-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAA;AACxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,yBAAyB,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAA;AAMvF,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,eAAe,CAAA;AAEvD,eAAO,MAAM,qBAAqB,EAAE,MAAM,CACxC,YAAY,EACZ,OAAO,yBAAyB,GAAG,OAAO,4BAA4B,CAgBvE,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuC3B,CAAA"}

package/dist/tools/structure-tools.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { ADDITIVE_TOOL_ANNOTATIONS, DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
+import { liveSyncOutput } from './live-sync.js';
+export const ROOM_TOOL_ANNOTATIONS = {
+    cut_floor_opening: ADDITIVE_TOOL_ANNOTATIONS,
+    remove_floor_opening: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    set_floor_foundation: ADDITIVE_TOOL_ANNOTATIONS,
+    set_room_floor_construction: ADDITIVE_TOOL_ANNOTATIONS,
+    rebase_floor_reference: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    create_mezzanine: ADDITIVE_TOOL_ANNOTATIONS,
+    move_zone: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    duplicate_zone: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    rotate_zone: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    lock_outside_faces: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    set_zone_intent: ADDITIVE_TOOL_ANNOTATIONS,
+    divide_zone: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    merge_zones: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    delete_zone: DESTRUCTIVE_TOOL_ANNOTATIONS,
+};
+export const structureOutput = {
+    zoneId: z.string().optional(),
+    openingId: z.string().optional(),
+    openingIds: z.array(z.string()).optional(),
+    hints: z
+        .array(z.object({
+        code: z.literal('manual-ceiling'),
+        openingId: z.string(),
+        surfaceIds: z.array(z.string()),
+        message: z.string(),
+    }))
+        .optional(),
+    idMap: z.record(z.string(), z.array(z.string())).optional(),
+    changes: z.number(),
+    separatorId: z.string().optional(),
+    separatorIds: z.array(z.string()).optional(),
+    zoneIds: z.array(z.string()).optional(),
+    payload: z
+        .object({
+        zoneId: z.string(),
+        name: z.string(),
+        mode: z.enum(['delete', 'merge', 'blocked']),
+        mergedIntoZoneId: z.string().optional(),
+        contents: z.enum(['delete', 'keep']),
+        wallIds: z.array(z.string()),
+        keptSharedWallIds: z.array(z.string()),
+        separatorIds: z.array(z.string()),
+        keptSharedSeparatorIds: z.array(z.string()),
+        openingIds: z.array(z.string()),
+        itemIds: z.array(z.string()),
+        opensZoneIds: z.array(z.string()),
+    })
+        .optional(),
+    conflicts: z
+        .array(z.object({ code: z.string(), nodeIds: z.array(z.string()), message: z.string() }))
+        .optional(),
+    ...liveSyncOutput,
+};

package/dist/tools/undo.d.ts

@@ -5,6 +5,8 @@ export declare const undoInput: {
     steps: z.ZodOptional<z.ZodNumber>;
 };
 export declare const undoOutput: {
+    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/undo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"undo.d.ts","sourceRoot":"","sources":["../../src/tools/undo.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":"undo.d.ts","sourceRoot":"","sources":["../../src/tools/undo.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/undo.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 undoInput = {
     steps: z.number().int().positive().optional(),
 };
@@ -17,7 +17,7 @@ export function registerUndo(server, bridge) {
         annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
     }, async ({ steps }) => {
         const undone = bridge.undo(steps ?? 1);
-        const persistence = undone > 0 ? await publishLiveSceneSnapshot(bridge, 'undo') : 'published';
+        const persistence = undone > 0 ? await publishLiveSceneSnapshot(bridge, 'undo') : currentLiveSync(bridge);
         const payload = { undone, ...persistencePayload(persistence) };
         return {
             content: [{ type: 'text', text: JSON.stringify(payload) }],

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

@@ -0,0 +1,136 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations/index.js';
+export declare const validateDesignInput: {
+    design: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+};
+export declare const validateDesignOutput: {
+    valid: z.ZodBoolean;
+    diagnostics: z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+        }>;
+        code: z.ZodEnum<{
+            schema: "schema";
+            parameters: "parameters";
+            invalid_json: "invalid_json";
+            rule: "rule";
+            sweep: "sweep";
+            floating_component: "floating_component";
+            unbalanced: "unbalanced";
+            behind_wall: "behind_wall";
+            draw_budget: "draw_budget";
+            design_version_not_enabled: "design_version_not_enabled";
+            design_too_large: "design_too_large";
+        }>;
+        path: z.ZodOptional<z.ZodString>;
+        message: z.ZodString;
+        hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    design: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        mounting: z.ZodEnum<{
+            ceiling: "ceiling";
+            "wall-side": "wall-side";
+            floor: "floor";
+        }>;
+        parameters: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            default: z.ZodNumber;
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+            step: z.ZodNumber;
+            unit: z.ZodString;
+        }, z.core.$strip>>;
+        slots: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    sweep: z.ZodNullable<z.ZodObject<{
+        cases: z.ZodNumber;
+        failed: z.ZodNumber;
+        failures: z.ZodArray<z.ZodObject<{
+            values: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            error: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    measurements: z.ZodNullable<z.ZodObject<{
+        parameters: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        bounds: z.ZodObject<{
+            min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            dimensions: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        }, z.core.$strip>;
+        shapes: z.ZodNumber;
+        triangles: z.ZodObject<{
+            actual: z.ZodNumber;
+            budget: z.ZodNumber;
+            limit: z.ZodNumber;
+        }, z.core.$strip>;
+        drawBudget: z.ZodNumber;
+        drawGroups: z.ZodArray<z.ZodObject<{
+            slot: z.ZodString;
+            motionGroup: z.ZodNullable<z.ZodString>;
+            shapes: z.ZodNumber;
+            triangles: z.ZodNumber;
+        }, z.core.$strip>>;
+        parts: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            instances: z.ZodNumber;
+            shapes: z.ZodNumber;
+            triangles: z.ZodNumber;
+            slots: z.ZodArray<z.ZodString>;
+            motion: z.ZodNullable<z.ZodEnum<{
+                hinge: "hinge";
+                slide: "slide";
+                spin: "spin";
+            }>>;
+            lights: z.ZodNumber;
+            bounds: z.ZodNullable<z.ZodObject<{
+                min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                dimensions: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        datum: z.ZodObject<{
+            kind: z.ZodEnum<{
+                wall: "wall";
+                ceiling: "ceiling";
+                floor: "floor";
+            }>;
+            axis: z.ZodEnum<{
+                z: "z";
+                y: "y";
+            }>;
+            value: z.ZodNumber;
+            gap: z.ZodNumber;
+            contact: z.ZodNullable<z.ZodObject<{
+                parts: z.ZodArray<z.ZodString>;
+                shapes: z.ZodNumber;
+                min: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+                max: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>>;
+            balanced: z.ZodNullable<z.ZodBoolean>;
+        }, z.core.$strip>;
+        components: z.ZodObject<{
+            count: z.ZodNumber;
+            list: z.ZodArray<z.ZodObject<{
+                parts: z.ZodArray<z.ZodString>;
+                shapes: z.ZodNumber;
+                bounds: z.ZodObject<{
+                    min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                    max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                    dimensions: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                }, z.core.$strip>;
+                touchesDatum: z.ZodBoolean;
+                datumGap: z.ZodNumber;
+                nearestGap: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        surfaces: z.ZodArray<z.ZodString>;
+        motions: z.ZodNumber;
+        lights: z.ZodNumber;
+    }, z.core.$strip>>;
+};
+export declare function registerValidateDesign(server: McpServer, _bridge: SceneOperations): void;
+//# sourceMappingURL=validate-design.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate-design.d.ts","sourceRoot":"","sources":["../../src/tools/validate-design.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAExE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAGpD,eAAO,MAAM,mBAAmB;;;CAU/B,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA+B,CAAA;AAEhE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAmBxF"}

package/dist/tools/validate-design.js

@@ -0,0 +1,28 @@
+import { DesignValidationSchema, validateDesign } from '@pascal-app/core/procedural-items';
+import { z } from 'zod';
+import { READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
+export const validateDesignInput = {
+    design: z
+        .union([z.string(), z.record(z.string(), z.unknown())])
+        .describe('The design (procedural recipe, version 1 or 2) as an object, or as a JSON string for clients that cannot send recursive objects. Schema: pascal://schema/design.'),
+    parameters: z
+        .record(z.string(), z.number())
+        .optional()
+        .describe('Parameter values to measure at, by parameter id. Defaults otherwise.'),
+};
+export const validateDesignOutput = DesignValidationSchema.shape;
+export function registerValidateDesign(server, _bridge) {
+    server.registerTool('validate_design', {
+        title: 'Validate design',
+        description: 'Check a design (procedural item recipe) without changing the scene. Returns `valid`, coded `diagnostics` with paths (errors block placement, warnings flag floating or unbalanced parts), the parameter `sweep`, and `measurements` at the given parameters: bounds, per-part bounds and instances, true triangle counts, draw groups per slot, datum contact and connected components. It is the authority: some rules are not expressible in pascal://schema/design. Repair and re-validate until `valid` is true. Version 2 designs validate fully but carry a design_version_not_enabled warning: placement accepts version 1 only until the next release.',
+        inputSchema: validateDesignInput,
+        outputSchema: validateDesignOutput,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    }, async ({ design, parameters }) => {
+        const result = validateDesign(design, { parameters });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result) }],
+            structuredContent: result,
+        };
+    });
+}