@pascal-app/mcp 1.0.3 → 1.0.5

package/dist/tools/author-scene.js

@@ -0,0 +1,140 @@
+import { achievedChanges, verifyScene, } from '@pascal-app/core/agent-operations';
+import { authorSceneTool, isAgentRefusal, } from '@pascal-app/core/agent-tools';
+import { GEOMETRY_SCRIPT_MIME_TYPES } from '@pascal-app/core/schema';
+import { compileAuthorScene } from '@pascal-app/geometry-script/author-scene';
+import { z } from 'zod';
+import { compileAndStore } from './add-object.js';
+import { DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
+import { refusalResult, toolError } from './errors.js';
+import { persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+import { toPatches } from './shared-tools.js';
+/**
+ * `author_scene` on the MCP: every item's module compiled and stored through the host, the
+ * module and the adapter kept as the scene's provenance, the operation applied, Pascal's checks
+ * run, and the gate report answered. Replay is the same payload through the same operation.
+ */
+export function registerAuthorScene(server, bridge, host) {
+    server.registerTool(authorSceneTool.name, {
+        title: authorSceneTool.title,
+        description: authorSceneTool.description,
+        inputSchema: z.object(authorSceneTool.input),
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    }, async (input) => {
+        if (!host) {
+            return toolError('This Pascal server cannot run geometry scripts.', {
+                code: 'scripts_unavailable',
+            });
+        }
+        const args = input;
+        const scene = bridge.getActiveScene();
+        if (!scene) {
+            return toolError('Open or save a scene first: a conversion is stored with a scene.', {
+                code: 'no_active_scene',
+            });
+        }
+        if (args.sceneId && args.sceneId !== scene.id) {
+            return toolError('Open the requested scene before converting it.', {
+                code: 'scene_mismatch',
+                mutationApplied: false,
+            });
+        }
+        const before = bridge.getNodes();
+        const beforeJson = JSON.stringify(before);
+        const context = {
+            activeLevelId: bridge.activeLevelId?.() ?? null,
+            ...(bridge.supportsMaterialUpserts && bridge.getMaterials
+                ? { materials: bridge.getMaterials() }
+                : {}),
+        };
+        let outcome;
+        try {
+            outcome = await compileAuthorScene(before, args, context, ({ code, kind, inputs, nodeId }) => compileAndStore(host, scene.id, { code, language: 'three', params: undefined, inputs }, kind, { nodeId }), host.signal);
+        }
+        catch (error) {
+            if (isAgentRefusal(error))
+                return refusalResult(error);
+            return toolError(error instanceof Error ? error.message : String(error), {
+                code: 'conversion_failed',
+            });
+        }
+        // Provenance: the design's module and the program that read it, kept as scripts of the scene.
+        const provenance = {};
+        for (const [kind, text] of [
+            ['module', args.module],
+            ['adapter', args.adapter],
+        ]) {
+            if (!text)
+                continue;
+            provenance[kind] = await host.storeArtifact({
+                sceneId: scene.id,
+                sha256: await sha256(text),
+                bytes: new TextEncoder().encode(text),
+                mimeType: GEOMETRY_SCRIPT_MIME_TYPES.three,
+                metadata: { kind: 'item' },
+            });
+        }
+        host.signal?.throwIfAborted();
+        await host.assertActive?.();
+        if (JSON.stringify(bridge.getNodes()) !== beforeJson) {
+            return toolError('The scene changed while its candidate was compiling. Read the current scene and retry the conversion.', { code: 'scene_changed', mutationApplied: false });
+        }
+        const buildingUpdate = outcome.changes.update.find((change) => change.id === outcome.buildingId);
+        buildingUpdate.data.metadata = {
+            ...buildingUpdate.data.metadata,
+            authorScene: {
+                ...provenance,
+                payload: withoutCode(args.payload),
+                report: outcome.result,
+                at: new Date().toISOString(),
+            },
+        };
+        const patches = toPatches(outcome.changes);
+        if (patches.length)
+            bridge.applyPatch(patches);
+        const checks = verifyScene(bridge.getNodes(), undefined, {
+            activeLevelId: null,
+        }).result;
+        const byType = new Map();
+        for (const issue of checks.issues)
+            byType.set(issue.type ?? 'unknown', (byType.get(issue.type ?? 'unknown') ?? 0) + 1);
+        const payload = {
+            ...outcome.result,
+            itemTriangles: outcome.itemTriangles,
+            itemsCompiled: outcome.itemsCompiled,
+            green: outcome.result.defects.length === 0,
+            verify: {
+                valid: checks.valid,
+                issues: checks.issues.length,
+                byType: Object.fromEntries(byType),
+                first: checks.issues.slice(0, 40).map((i) => i.message),
+            },
+            achieved: achievedChanges(before, outcome.changes ?? {}),
+            ...persistencePayload(await publishLiveSceneSnapshot(bridge, authorSceneTool.name)),
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}
+/** The payload as kept with the scene: every module is already its own artifact. */
+function withoutCode(payload) {
+    return {
+        ...payload,
+        levels: payload.levels.map((level) => ({
+            ...level,
+            walls: (level.walls ?? []).map(({ faceLeft, faceRight, ...wall }) => ({
+                ...wall,
+                openings: (wall.openings ?? []).map(({ code: _, ...opening }) => opening),
+                ...(faceLeft ? { faceLeft: { toHeight: faceLeft.toHeight } } : {}),
+                ...(faceRight ? { faceRight: { toHeight: faceRight.toHeight } } : {}),
+            })),
+            items: (level.items ?? []).map(({ code: _, ...item }) => item),
+            rooms: level.rooms.map(({ floorCode: _, wallCode: _w, ...room }) => room),
+        })),
+    };
+}
+async function sha256(text) {
+    const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(text));
+    return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, '0')).join('');
+}

package/dist/tools/check-collisions.d.ts

@@ -1,17 +1,17 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import type { SceneOperations } from '../operations/index.js';
 export declare const checkCollisionsInput: {
     levelId: z.ZodOptional<z.ZodString>;
-    minimumClearance: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    minimumClearance: z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
     floorOnly: z.ZodDefault<z.ZodBoolean>;
     candidate: z.ZodOptional<z.ZodObject<{
         id: z.ZodDefault<z.ZodString>;
         name: z.ZodDefault<z.ZodString>;
         levelId: z.ZodString;
-        position: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>, z.ZodTransform<[number, number, number], number[]>>;
-        dimensions: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>, z.ZodTransform<[number, number, number], number[]>>;
-        rotationY: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        position: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>> | z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>>, z.ZodTransform<[number, number, number], number[]>>;
+        dimensions: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>> | z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>>, z.ZodTransform<[number, number, number], number[]>>;
+        rotationY: z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         source: z.ZodOptional<z.ZodObject<{
             assetId: z.ZodOptional<z.ZodString>;
             uri: z.ZodOptional<z.ZodString>;
@@ -21,8 +21,8 @@ export declare const checkCollisionsInput: {
 export declare const checkCollisionsOutput: {
     status: z.ZodEnum<{
         checked: "checked";
-        partial: "partial";
         insufficient_evidence: "insufficient_evidence";
+        partial: "partial";
     }>;
     units: z.ZodLiteral<"meters">;
     method: z.ZodLiteral<"rotation-aware-plan-aabb">;
@@ -64,8 +64,8 @@ export declare const checkCollisionsOutput: {
         bId: z.ZodString;
         kind: z.ZodString;
         violation: z.ZodEnum<{
-            overlap: "overlap";
             clearance: "clearance";
+            overlap: "overlap";
         }>;
         minimumClearanceMeters: z.ZodNumber;
     }, z.core.$strip>>;

package/dist/tools/check-collisions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-collisions.d.ts","sourceRoot":"","sources":["../../src/tools/check-collisions.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;AA8BpD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;CA+BhC,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDjC,CAAA;AA6BD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAyKxF"}
+{"version":3,"file":"check-collisions.d.ts","sourceRoot":"","sources":["../../src/tools/check-collisions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAO7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AA4BpD,eAAO,MAAM,oBAAoB;IAC/B,OAAO;IACP,gBAAgB;IAIhB,SAAS;IAIT,SAAS;;;;;;;;;;;;CAqBV,CAAA;AAED,eAAO,MAAM,qBAAqB;IAChC,MAAM;;;;;IACN,KAAK;IACL,MAAM;IACN,mBAAmB;IACnB,sBAAsB;IACtB,SAAS;IACT,eAAe;IACf,YAAY;;;;;;;;;;;;;;;;;;;;IAsBZ,YAAY;;;;;IAOZ,iBAAiB;;;;IAMjB,UAAU;;;;;;;;;;CASX,CAAA;AA6BD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA4KxF"}

package/dist/tools/check-collisions.js

@@ -1,9 +1,8 @@
+import { findItemItemCollisions, inspectItemPlanFootprint, resolveNodeLevelId, } from '@pascal-app/core/agent-operations';
 import { ItemNode } from '@pascal-app/core/schema';
 import { z } from 'zod';
 import { READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
-import { inspectItemPlanFootprint, resolveNodeLevelId } from './door-clearance.js';
-import { ErrorCode, throwMcpError } from './errors.js';
-import { findItemItemCollisions } from './layout-clearance.js';
+import { ProtocolErrorCode, throwMcpError } from './errors.js';
 import { measurement } from './measurement.js';
 import { computeGraphHash } from './scene-lifecycle/metadata.js';
 import { NodeIdSchema } from './schemas.js';
@@ -131,24 +130,24 @@ export function registerCheckCollisions(server, bridge) {
     server.registerTool('check_collisions', {
         title: 'Check collisions',
         description: 'Assess declared item footprints with a rotation-aware plan AABB test. Supports an explicit minimum clearance and reports units, source dimensions, skipped evidence, and unsupported checks. Optionally scope to one level or floor-standing items.',
-        inputSchema: checkCollisionsInput,
-        outputSchema: checkCollisionsOutput,
+        inputSchema: z.object(checkCollisionsInput),
+        outputSchema: z.object(checkCollisionsOutput),
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
     }, async ({ levelId, minimumClearance, floorOnly, candidate }) => {
         const sceneNodes = Object.values(bridge.getNodes());
         if (candidate && levelId && candidate.levelId !== levelId) {
-            throwMcpError(ErrorCode.InvalidParams, 'candidate.levelId must match levelId when both are provided');
+            throwMcpError(ProtocolErrorCode.InvalidParams, 'candidate.levelId must match levelId when both are provided');
         }
         const scopeLevelId = candidate?.levelId ?? levelId;
         if (scopeLevelId) {
             const target = sceneNodes.find((node) => node.id === scopeLevelId);
             if (target?.type !== 'level') {
-                throwMcpError(ErrorCode.InvalidParams, `Level not found: ${scopeLevelId}`);
+                throwMcpError(ProtocolErrorCode.InvalidParams, `Level not found: ${scopeLevelId}`);
             }
         }
         if (candidate) {
             if (sceneNodes.some((node) => node.id === candidate.id)) {
-                throwMcpError(ErrorCode.InvalidParams, `Candidate id already exists: ${candidate.id}`);
+                throwMcpError(ProtocolErrorCode.InvalidParams, `Candidate id already exists: ${candidate.id}`);
             }
         }
         const candidateNode = candidate

package/dist/tools/clear-scene.d.ts

@@ -0,0 +1,9 @@
+import type { McpServer } from '@modelcontextprotocol/server';
+import type { SceneOperations } from '../operations/index.js';
+/**
+ * `clear_scene`: the scene goes back to the host's default scaffold (a site, a building, a level),
+ * then is saved with `allowSceneWipe`, so a store that refuses an accidental wipe takes this one.
+ * The project's installed plugins stay, and its undo history goes, as the editor's own clear does.
+ */
+export declare function registerClearScene(server: McpServer, operations: SceneOperations): void;
+//# sourceMappingURL=clear-scene.d.ts.map

package/dist/tools/clear-scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear-scene.d.ts","sourceRoot":"","sources":["../../src/tools/clear-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAG7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,GAAG,IAAI,CAmDvF"}

package/dist/tools/clear-scene.js

@@ -0,0 +1,59 @@
+import { clearSceneTool } from '@pascal-app/core/agent-tools';
+import { z } from 'zod';
+import { DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
+import { refusalResult } from './errors.js';
+import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+/**
+ * `clear_scene`: the scene goes back to the host's default scaffold (a site, a building, a level),
+ * then is saved with `allowSceneWipe`, so a store that refuses an accidental wipe takes this one.
+ * The project's installed plugins stay, and its undo history goes, as the editor's own clear does.
+ */
+export function registerClearScene(server, operations) {
+    server.registerTool(clearSceneTool.name, {
+        title: clearSceneTool.title,
+        description: clearSceneTool.description,
+        inputSchema: z.object(clearSceneTool.input),
+        outputSchema: z.object({
+            cleared: z.object({ removed: z.number() }),
+            version: z.number().nullable(),
+            graphHash: z.string().nullable(),
+            ...liveSyncOutput,
+        }),
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    }, async () => {
+        try {
+            const before = Object.keys(operations.getNodes()).length;
+            const { installedPlugins } = operations.exportSceneGraph();
+            operations.setScene({}, []);
+            operations.loadDefault();
+            // Resetting drops the plugin state on every host; the scaffold is applied again with it.
+            if (installedPlugins)
+                operations.loadJSON({
+                    ...operations.exportSceneGraph(),
+                    collections: {},
+                    materials: {},
+                    installedPlugins,
+                });
+            // Nothing to undo back into: the empty intermediate or the old scene, saved over the clear.
+            operations.clearHistory();
+            const removed = Math.max(0, before - Object.keys(operations.getNodes()).length);
+            const persistence = await publishLiveSceneSnapshot(operations, clearSceneTool.name, {
+                allowSceneWipe: true,
+            });
+            const active = operations.getActiveScene();
+            const payload = {
+                cleared: { removed },
+                version: active?.version ?? null,
+                graphHash: active?.graphHash ?? null,
+                ...persistencePayload(persistence),
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        catch (error) {
+            return refusalResult(error);
+        }
+    });
+}

package/dist/tools/collections.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/server';
+import type { SceneOperations } from '../operations/index.js';
+export declare function registerCollectionTools(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=collections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/tools/collections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAY7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAgBpD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA+CxF"}

package/dist/tools/collections.js

@@ -0,0 +1,53 @@
+import { editCollection, listCollections, writeCollections, } from '@pascal-app/core/agent-operations';
+import { editCollectionTool, listCollectionsTool } from '@pascal-app/core/agent-tools';
+import { z } from 'zod';
+import { DESTRUCTIVE_TOOL_ANNOTATIONS, READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
+import { refusalResult } from './errors.js';
+import { persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+// The collection tools share contracts and operations with the chat; they read the scene's
+// collections beside its nodes, which the node-only shared operations never see.
+function sceneOf(bridge) {
+    return { nodes: bridge.getNodes(), collections: bridge.getCollections() };
+}
+function reply(payload) {
+    return { content: [{ type: 'text', text: JSON.stringify(payload) }] };
+}
+export function registerCollectionTools(server, bridge) {
+    server.registerTool(listCollectionsTool.name, {
+        title: listCollectionsTool.title,
+        description: listCollectionsTool.description,
+        inputSchema: z.object(listCollectionsTool.input),
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    }, async (input) => {
+        try {
+            return reply(listCollections(sceneOf(bridge), input).result);
+        }
+        catch (error) {
+            return refusalResult(error);
+        }
+    });
+    server.registerTool(editCollectionTool.name, {
+        title: editCollectionTool.title,
+        description: editCollectionTool.description,
+        inputSchema: z.object(editCollectionTool.input),
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    }, async (input) => {
+        let outcome;
+        try {
+            outcome = editCollection(sceneOf(bridge), input);
+        }
+        catch (error) {
+            return refusalResult(error);
+        }
+        const { update, collections = {} } = outcome.changes ?? {};
+        bridge.runAsSingleHistoryStep(() => {
+            if (update?.length)
+                bridge.applyPatch(update.map(({ id, data }) => ({ op: 'update', id: id, data })));
+            bridge.setCollections(writeCollections(bridge.getCollections(), collections));
+        });
+        return reply({
+            ...outcome.result,
+            ...persistencePayload(await publishLiveSceneSnapshot(bridge, editCollectionTool.name)),
+        });
+    });
+}

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

@@ -1,115 +1,39 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import type { SceneOperations } from '../operations/index.js';
 export declare const createStoryShellInput: {
     levelId: z.ZodString;
     footprint: z.ZodArray<z.ZodArray<z.ZodNumber>>;
-    wallHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    wallThickness: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    wallHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    wallThickness: z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
     createSlab: z.ZodDefault<z.ZodBoolean>;
     createCeiling: z.ZodDefault<z.ZodBoolean>;
-    slabElevation: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    ceilingHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    slabElevation: z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    ceilingHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
     namePrefix: z.ZodOptional<z.ZodString>;
     wallMaterialPreset: z.ZodOptional<z.ZodString>;
     slabMaterialPreset: z.ZodOptional<z.ZodString>;
     ceilingMaterialPreset: z.ZodOptional<z.ZodString>;
 };
 export declare const createStoryShellOutput: {
+    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";
+            unbound: "unbound";
         }>;
         warning: z.ZodString;
     }, z.core.$strip>>;
     levelId: z.ZodString;
     wallIds: z.ZodArray<z.ZodString>;
+    /** Zones the reconciler derived for the enclosed faces. */
+    zoneIds: z.ZodArray<z.ZodString>;
+    /** Derived floor plate. `null` when floors were declined or nothing reconciled. */
     slabId: z.ZodNullable<z.ZodString>;
+    /** Derived ceiling. `null` when ceilings were declined or nothing reconciled. */
     ceilingId: z.ZodNullable<z.ZodString>;
     createdIds: z.ZodArray<z.ZodString>;
 };
-export declare const createRoofInput: {
-    levelId: z.ZodString;
-    roofLevelId: z.ZodOptional<z.ZodString>;
-    useDedicatedRoofLevel: z.ZodDefault<z.ZodBoolean>;
-    roofLevelLabel: z.ZodDefault<z.ZodString>;
-    roofLevelElevation: z.ZodOptional<z.ZodNumber>;
-    roofLevelHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    center: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    width: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
-    depth: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
-    roofType: z.ZodDefault<z.ZodEnum<{
-        gable: "gable";
-        flat: "flat";
-        hip: "hip";
-        shed: "shed";
-        gambrel: "gambrel";
-        dutch: "dutch";
-        mansard: "mansard";
-        conical: "conical";
-    }>>;
-    pitch: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    wallHeight: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    wallThickness: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    overhang: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    materialPreset: z.ZodOptional<z.ZodString>;
-    name: z.ZodOptional<z.ZodString>;
-};
-export declare const createRoofOutput: {
-    persistence: z.ZodOptional<z.ZodObject<{
-        status: z.ZodEnum<{
-            unbound: "unbound";
-            events_unsupported: "events_unsupported";
-        }>;
-        warning: z.ZodString;
-    }, z.core.$strip>>;
-    referenceLevelId: z.ZodString;
-    roofLevelId: z.ZodString;
-    createdRoofLevelId: z.ZodNullable<z.ZodString>;
-    roofId: z.ZodString;
-    roofSegmentId: z.ZodString;
-};
-export declare const createStairBetweenLevelsInput: {
-    fromLevelId: z.ZodString;
-    toLevelId: z.ZodString;
-    position: z.ZodArray<z.ZodNumber>;
-    rotation: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    width: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    runLength: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    totalRise: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    stepCount: z.ZodDefault<z.ZodNumber>;
-    railingMode: z.ZodDefault<z.ZodEnum<{
-        none: "none";
-        both: "both";
-        right: "right";
-        left: "left";
-    }>>;
-    destinationSlabId: z.ZodOptional<z.ZodString>;
-    sourceCeilingId: z.ZodOptional<z.ZodString>;
-    createDestinationSlabOpening: z.ZodDefault<z.ZodBoolean>;
-    createSourceCeilingOpening: z.ZodDefault<z.ZodBoolean>;
-    openingWidth: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    openingLength: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    openingOffset: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    openingCenter: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    openingRotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    materialPreset: z.ZodOptional<z.ZodString>;
-    name: z.ZodOptional<z.ZodString>;
-};
-export declare const createStairBetweenLevelsOutput: {
-    persistence: z.ZodOptional<z.ZodObject<{
-        status: z.ZodEnum<{
-            unbound: "unbound";
-            events_unsupported: "events_unsupported";
-        }>;
-        warning: z.ZodString;
-    }, z.core.$strip>>;
-    stairId: z.ZodString;
-    stairSegmentId: z.ZodString;
-    destinationSlabId: z.ZodNullable<z.ZodString>;
-    sourceCeilingId: z.ZodNullable<z.ZodString>;
-    openingPolygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
-};
 export declare function registerConstructionTools(server: McpServer, bridge: SceneOperations): void;
 //# sourceMappingURL=construction-tools.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"construction-tools.d.ts","sourceRoot":"","sources":["../../src/tools/construction-tools.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;AAkBpD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;CAsBjC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;CAOlC,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;CAO5B,CAAA;AAED,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCzC,CAAA;AAED,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;CAO1C,CAAA;AA4GD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgV1F"}
+{"version":3,"file":"construction-tools.d.ts","sourceRoot":"","sources":["../../src/tools/construction-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAI7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAOpD,eAAO,MAAM,qBAAqB;IAChC,OAAO;IACP,SAAS;IACT,UAAU;IAIV,aAAa;IAIb,UAAU;IAIV,aAAa;IAIb,aAAa;IAGb,aAAa;IAIb,UAAU;IACV,kBAAkB;IAClB,kBAAkB;IAClB,qBAAqB;CACtB,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;IAGjC,2DAA2D;;IAE3D,mFAAmF;;IAEnF,iFAAiF;;;CAIlF,CAAA;AAgDD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA4H1F"}