@pascal-app/mcp 1.0.4 → 1.0.6

package/dist/tools/place-design.js

@@ -1,91 +0,0 @@
-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/validate-design.d.ts

@@ -1,136 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,28 +0,0 @@
-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,
-        };
-    });
-}

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

@@ -1,19 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import type { SceneOperations } from '../operations/index.js';
-export declare const validateSceneInput: {};
-export declare const validateSceneOutput: {
-    valid: z.ZodBoolean;
-    errors: z.ZodArray<z.ZodObject<{
-        nodeId: z.ZodString;
-        path: z.ZodString;
-        message: z.ZodString;
-    }, z.core.$strip>>;
-    warnings: z.ZodArray<z.ZodObject<{
-        nodeId: z.ZodString;
-        path: z.ZodString;
-        message: z.ZodString;
-    }, z.core.$strip>>;
-};
-export declare function registerValidateScene(server: McpServer, bridge: SceneOperations): void;
-//# sourceMappingURL=validate-scene.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"validate-scene.d.ts","sourceRoot":"","sources":["../../src/tools/validate-scene.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;AAGpD,eAAO,MAAM,kBAAkB,IAAK,CAAA;AAQpC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;CAI/B,CAAA;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAmBtF"}

package/dist/tools/validate-scene.js

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-import { READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
-export const validateSceneInput = {};
-const validationIssue = z.object({
-    nodeId: z.string(),
-    path: z.string(),
-    message: z.string(),
-});
-export const validateSceneOutput = {
-    valid: z.boolean(),
-    errors: z.array(validationIssue),
-    warnings: z.array(validationIssue),
-};
-export function registerValidateScene(server, bridge) {
-    server.registerTool('validate_scene', {
-        title: 'Validate scene',
-        description: 'Run Zod validation against every node in the scene. Returns `{ valid, errors, warnings }` where each entry has `{ nodeId, path, message }`. Warnings do not fail validation; for example a hidden Site, whose flag hides only its own ground and boundary while the buildings on it stay visible and exported.',
-        inputSchema: validateSceneInput,
-        outputSchema: validateSceneOutput,
-        annotations: READ_ONLY_TOOL_ANNOTATIONS,
-    }, async () => {
-        const result = bridge.validateScene();
-        return {
-            content: [{ type: 'text', text: JSON.stringify(result) }],
-            structuredContent: result,
-        };
-    });
-}