@pascal-app/mcp 0.3.1 → 1.0.0-beta.1

package/dist/tools/describe-node.js

@@ -1,5 +1,7 @@
+import { resolveCeilingHeight } from '@pascal-app/core';
 import { z } from 'zod';
 import { ErrorCode, throwMcpError } from './errors';
+import { resolveReportedWallHeight } from './scene-query';
 import { NodeIdSchema } from './schemas';
 export const describeNodeInput = {
     id: NodeIdSchema,
@@ -17,13 +19,13 @@ export const describeNodeOutput = {
  * Build a short, human-readable one-liner describing the node.
  * Covers the common shapes; falls back to a generic sentence otherwise.
  */
-function describe(node) {
+function describe(node, bridge) {
     switch (node.type) {
         case 'wall': {
             const [x1, z1] = node.start;
             const [x2, z2] = node.end;
             const t = node.thickness ?? 0.1;
-            const h = node.height ?? 2.5;
+            const h = resolveReportedWallHeight(bridge, node);
             return `Wall from (${x1},${z1}) to (${x2},${z2}), thickness ${t.toFixed(2)}m, height ${h.toFixed(2)}m`;
         }
         case 'level':
@@ -39,7 +41,7 @@ function describe(node) {
         case 'slab':
             return `Slab with ${node.polygon.length} vertices`;
         case 'ceiling':
-            return `Ceiling with ${node.polygon.length} vertices, height ${node.height.toFixed(2)}m`;
+            return `Ceiling with ${node.polygon.length} vertices, height ${resolveCeilingHeight(node, bridge.getNodes()).toFixed(2)}m`;
         case 'door':
             return `Door (${node.width.toFixed(2)}m x ${node.height.toFixed(2)}m)`;
         case 'window':
@@ -69,14 +71,21 @@ export function registerDescribeNode(server, bridge) {
         const children = bridge.getChildren(id);
         const childrenIds = children.map((n) => n.id);
         const n = node;
+        const properties = n.type === 'wall'
+            ? {
+                ...n,
+                resolvedHeight: resolveReportedWallHeight(bridge, n),
+                heightIsExplicit: n.height !== undefined,
+            }
+            : n;
         const payload = {
             id: n.id,
             type: n.type,
             parentId: (n.parentId ?? null),
             ancestryIds,
             childrenIds,
-            properties: n,
-            description: describe(n),
+            properties: properties,
+            description: describe(n, bridge),
         };
         return {
             content: [{ type: 'text', text: JSON.stringify(payload) }],

package/dist/tools/find-nodes.d.ts

@@ -8,9 +8,10 @@ export declare const findNodesInput: {
         level: "level";
         wall: "wall";
         fence: "fence";
+        slab: "slab";
+        door: "door";
         item: "item";
         zone: "zone";
-        slab: "slab";
         stair: "stair";
         ceiling: "ceiling";
         roof: "roof";
@@ -19,7 +20,6 @@ export declare const findNodesInput: {
         scan: "scan";
         guide: "guide";
         window: "window";
-        door: "door";
     }>>;
     parentId: z.ZodOptional<z.ZodString>;
     levelId: z.ZodOptional<z.ZodString>;

package/dist/tools/find-nodes.js

@@ -79,7 +79,7 @@ export function registerFindNodes(server, bridge) {
         // Zone-polygon filter: point-in-polygon on a representative 2D point.
         if (zoneId) {
             const zone = bridge.getNode(zoneId);
-            if (!zone || zone.type !== 'zone') {
+            if (zone?.type !== 'zone') {
                 // Unknown zoneId → return empty list rather than throw; matches
                 // typical "filter" semantics.
                 results = [];

package/dist/tools/measurement.d.ts

@@ -0,0 +1,37 @@
+import { type Kind } from '@pascal-app/lingo';
+import { z } from 'zod';
+/**
+ * A zod field for a measurement tool argument that a model may emit as a bare
+ * number OR as natural language. `measurement('length', 'm')` accepts `0.15`,
+ * `"6 in"`, `"180cm"`, `"2 ft 3 in"`; `measurement('angle', 'deg')` accepts
+ * `45`, `"45°"`, `"1.57rad"`, `"0.25 turn"`. The value is canonicalized (via
+ * `@pascal-app/lingo`) to a number in `unit` — the exact unit the tool handler
+ * already expects — so no handler change is needed. `min`/`max` (in `unit`)
+ * reject out-of-range values with a model-readable message.
+ *
+ * The emitted JSON Schema is `number | string`, so the model is free to answer
+ * in whatever unit it is thinking in; AI SDK v6 applies the transform and
+ * forwards the canonical number to the tool executor.
+ *
+ * Tool-boundary safety: genuinely ambiguous separators (`"1,234"`, which could
+ * mean 1234 or 1.234) are rejected rather than silently absorbed, so a European
+ * decimal never becomes a 1000× value.
+ *
+ * NOTE: intentionally duplicated as `editor/packages/mcp/src/tools/measurement.ts`
+ * (MCP tools) and `packages/ai/src/tools/scene/measurement.ts` (AI-chat tools).
+ * The two tool stacks live in different packages — one inside the `editor`
+ * submodule — so they can't share a module. Keep the two copies identical; the
+ * clean long-term dedup is a zod-field adapter exported from `@pascal-app/lingo`.
+ */
+export interface MeasurementOptions {
+    /** Semantic description (e.g. "Wall thickness"). The natural-language note is appended. */
+    description?: string;
+    /** Upper bound, in `unit`. */
+    max?: number;
+    /** Inclusive lower bound, in `unit`. */
+    min?: number;
+    /** Require the value to be strictly greater than 0 (for non-zero dimensions). */
+    positive?: boolean;
+}
+export declare function measurement(kind: Kind, unit: string, opts?: MeasurementOptions): z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+//# sourceMappingURL=measurement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../src/tools/measurement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAiB,MAAM,mBAAmB,CAAA;AAC5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,WAAW,kBAAkB;IACjC,2FAA2F;IAC3F,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,8BAA8B;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,wCAAwC;IACxC,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,iFAAiF;IACjF,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AA6CD,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,kBAAuB,uGAoDlF"}

package/dist/tools/measurement.js

@@ -0,0 +1,94 @@
+import { parseQuantity } from '@pascal-app/lingo';
+import { z } from 'zod';
+function unitNoun(unit) {
+    switch (unit) {
+        case 'm':
+            return 'meters';
+        case 'deg':
+            return 'degrees';
+        case 'rad':
+            return 'radians';
+        default:
+            return unit;
+    }
+}
+function naturalLanguageNote(kind, unit) {
+    let examples;
+    if (kind === 'angle') {
+        // Lead with an example in the field's own unit so a bare number is read
+        // the way the model intends (a bare "45" in a radians field is 45 rad).
+        examples =
+            unit === 'rad' ? '1.5708, "90°", "1.57rad", "0.25 turn"' : '45, "45°", "1.57rad", "0.25 turn"';
+    }
+    else {
+        examples = '0.9, "6 ft", "180cm", "2 ft 3 in"';
+    }
+    return `Accepts a number (${unitNoun(unit)}) or a natural-language string; other units are converted. e.g. ${examples}.`;
+}
+function boundsNote(unit, min, max, positive) {
+    if (positive) {
+        return max === undefined
+            ? ` Must be greater than 0 ${unit}.`
+            : ` Greater than 0, up to ${max} ${unit}.`;
+    }
+    if (min !== undefined && max !== undefined)
+        return ` Range ${min}–${max} ${unit}.`;
+    if (min !== undefined)
+        return ` Minimum ${min} ${unit}.`;
+    if (max !== undefined)
+        return ` Maximum ${max} ${unit}.`;
+    return '';
+}
+export function measurement(kind, unit, opts = {}) {
+    const { min, max, positive = false } = opts;
+    const description = [
+        opts.description,
+        naturalLanguageNote(kind, unit) + boundsNote(unit, min, max, positive),
+    ]
+        .filter(Boolean)
+        .join(' ');
+    return z
+        .union([z.number(), z.string()])
+        .transform((val, ctx) => {
+        let value;
+        if (typeof val === 'number') {
+            value = val;
+        }
+        else {
+            const result = parseQuantity(val, {
+                kind,
+                unit,
+                strictness: 'forgiving',
+                // A genuinely ambiguous separator ("1,234") must not silently become
+                // a 1000× value at a tool boundary — fail so the model self-corrects.
+                escalate: { AMBIGUOUS_NUMBER: 'error' },
+            });
+            if (!result.ok) {
+                ctx.addIssue({
+                    code: 'custom',
+                    message: result.issues[0]?.message ?? `Could not read "${val}" as a ${kind}.`,
+                });
+                return z.NEVER;
+            }
+            value = result.quantity.to(unit).value;
+        }
+        if (!Number.isFinite(value)) {
+            ctx.addIssue({ code: 'custom', message: `Value must be a finite ${kind} in ${unit}.` });
+            return z.NEVER;
+        }
+        if (positive && value <= 0) {
+            ctx.addIssue({ code: 'custom', message: `Must be greater than 0 ${unit} (got ${value}).` });
+            return z.NEVER;
+        }
+        if (min !== undefined && value < min) {
+            ctx.addIssue({ code: 'custom', message: `Must be at least ${min} ${unit} (got ${value}).` });
+            return z.NEVER;
+        }
+        if (max !== undefined && value > max) {
+            ctx.addIssue({ code: 'custom', message: `Must be at most ${max} ${unit} (got ${value}).` });
+            return z.NEVER;
+        }
+        return value;
+    })
+        .describe(description);
+}

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

@@ -10,8 +10,8 @@ export declare const photoToSceneInput: {
     scaleHint: z.ZodOptional<z.ZodString>;
     name: z.ZodDefault<z.ZodString>;
     save: z.ZodDefault<z.ZodBoolean>;
-    defaultWallThickness: z.ZodDefault<z.ZodNumber>;
-    defaultWallHeight: z.ZodDefault<z.ZodNumber>;
+    defaultWallThickness: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    defaultWallHeight: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
 };
 export declare const photoToSceneOutput: {
     sceneId: z.ZodOptional<z.ZodString>;

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;AAGvD;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;CAO7B,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;CAQ9B,CAAA;AAiTD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA6ErF"}
+{"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;AAIvD;;;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,CA6ErF"}

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

@@ -2,6 +2,7 @@ import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
 import { AnyNode, BuildingNode, LevelNode, SiteNode, WallNode, ZoneNode, } from '@pascal-app/core/schema';
 import { z } from 'zod';
 import { appendLiveSceneEvent } from '../live-sync';
+import { measurement } from '../measurement';
 /**
  * Input shape for the `photo_to_scene` orchestrator. `image` matches the
  * contract documented on `analyze_floorplan_image` — base64 or http(s) URL.
@@ -11,8 +12,14 @@ export const photoToSceneInput = {
     scaleHint: z.string().optional().describe('e.g. "1 cm = 1 m" or "approx 80 m²"'),
     name: z.string().default('Scene from photo'),
     save: z.boolean().default(true),
-    defaultWallThickness: z.number().default(0.2),
-    defaultWallHeight: z.number().default(2.6),
+    defaultWallThickness: measurement('length', 'm', {
+        positive: true,
+        description: 'Default wall thickness.',
+    }).default(0.2),
+    defaultWallHeight: measurement('length', 'm', {
+        positive: true,
+        description: 'Default wall height.',
+    }).default(2.6),
 };
 export const photoToSceneOutput = {
     sceneId: z.string().optional(),
@@ -33,6 +40,7 @@ const VisionResponseSchema = z.object({
         start: z.tuple([z.number(), z.number()]),
         end: z.tuple([z.number(), z.number()]),
         thickness: z.number().optional(),
+        height: z.number().positive().optional(),
     })),
     rooms: z.array(z.object({
         name: z.string(),
@@ -54,13 +62,14 @@ const SYSTEM_PROMPT = `You are a vision assistant that extracts structured floor
 Your ONLY job: return a JSON object that exactly matches this schema — no prose, no markdown fences.
 
 {
-  "walls": [{ "start": [x, z], "end": [x, z], "thickness": number? }, ...],
+  "walls": [{ "start": [x, z], "end": [x, z], "thickness": number?, "height": number? }, ...],
   "rooms": [{ "name": string, "polygon": [[x,z], ...], "approximateAreaSqM": number? }, ...],
   "approximateDimensions": { "widthM": number, "depthM": number },
   "confidence": number 0..1
 }
 
 Coordinates are in metres. Origin can be the floor plan's centre or bottom-left — be consistent.
+Only include a wall height when it is visibly measured or annotated in the image.
 If the image is unclear, lower the confidence score but still produce your best attempt.
 DO NOT wrap the JSON in markdown. DO NOT explain. Just output the raw JSON.`;
 const DATA_URI_RE = /^data:(image\/[a-z0-9.+-]+);base64,(.+)$/i;
@@ -163,7 +172,7 @@ function buildSceneGraphFromVision(vision, defaultWallThickness, defaultWallHeig
     const warnings = [];
     // Build the skeleton: site → building → level.
     const building = BuildingNode.parse({});
-    const level = LevelNode.parse({ level: 0 });
+    const level = LevelNode.parse({ level: 0, height: defaultWallHeight });
     const site = SiteNode.parse({ children: [building.id] });
     // Link parent ids so downstream traversal works.
     const siteId = site.id;
@@ -201,7 +210,7 @@ function buildSceneGraphFromVision(vision, defaultWallThickness, defaultWallHeig
                 start: w.start,
                 end: w.end,
                 thickness: w.thickness ?? defaultWallThickness,
-                height: defaultWallHeight,
+                ...(w.height !== undefined ? { height: w.height } : {}),
             });
             const linkedWall = {
                 ...wall,

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

@@ -5,7 +5,7 @@ export declare const placeItemInput: {
     catalogItemId: z.ZodString;
     targetNodeId: z.ZodString;
     position: z.ZodArray<z.ZodNumber>;
-    rotation: z.ZodOptional<z.ZodNumber>;
+    rotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
 };
 export declare const placeItemOutput: {
     itemId: z.ZodString;

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

@@ -1 +1 @@
-{"version":3,"file":"place-item.d.ts","sourceRoot":"","sources":["../../src/tools/place-item.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAOpD,eAAO,MAAM,cAAc;;;;;CAK1B,CAAA;AAED,eAAO,MAAM,eAAe;;;CAG3B,CAAA;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAsFlF"}
+{"version":3,"file":"place-item.d.ts","sourceRoot":"","sources":["../../src/tools/place-item.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAQpD,eAAO,MAAM,cAAc;;;;;CAK1B,CAAA;AAED,eAAO,MAAM,eAAe;;;CAG3B,CAAA;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAsFlF"}

package/dist/tools/place-item.js

@@ -4,12 +4,13 @@ import { findCatalogItem } from './asset-catalog';
 import { ErrorCode, throwMcpError } from './errors';
 import { projectWorldPointToWallLocalX, wallLength } from './geometry';
 import { publishLiveSceneSnapshot } from './live-sync';
+import { measurement } from './measurement';
 import { NodeIdSchema, Vec3Schema } from './schemas';
 export const placeItemInput = {
     catalogItemId: z.string().min(1),
     targetNodeId: NodeIdSchema,
     position: Vec3Schema,
-    rotation: z.number().optional(),
+    rotation: measurement('angle', 'rad', { description: 'Y-axis rotation.' }).optional(),
 };
 export const placeItemOutput = {
     itemId: z.string(),

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

@@ -14,8 +14,8 @@ export declare const createRoomInput: {
     name: z.ZodString;
     polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
     color: z.ZodOptional<z.ZodString>;
-    wallHeight: z.ZodOptional<z.ZodNumber>;
-    wallThickness: z.ZodOptional<z.ZodNumber>;
+    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: {
     zoneId: z.ZodString;
@@ -28,11 +28,11 @@ export declare const addDoorInput: {
     wallId: z.ZodString;
     t: z.ZodOptional<z.ZodNumber>;
     position: z.ZodOptional<z.ZodNumber>;
-    width: z.ZodOptional<z.ZodNumber>;
-    height: 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<{
-        left: "left";
         right: "right";
+        left: "left";
     }>>;
     swingDirection: z.ZodOptional<z.ZodEnum<{
         inward: "inward";
@@ -52,9 +52,9 @@ export declare const addWindowInput: {
     wallId: z.ZodString;
     t: z.ZodOptional<z.ZodNumber>;
     position: z.ZodOptional<z.ZodNumber>;
-    width: z.ZodOptional<z.ZodNumber>;
-    height: z.ZodOptional<z.ZodNumber>;
-    sillHeight: 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>>>;
 };
 export declare const addWindowOutput: {
     windowId: z.ZodString;

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;AA0BpD,eAAO,MAAM,iBAAiB;;;CAG7B,CAAA;AAED,eAAO,MAAM,kBAAkB;;;CAG9B,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;CAO3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;CAM5B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;CAQxB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;CAQzB,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;CAO1B,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;CAS3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;CAM5B,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;CAI7B,CAAA;AA+PD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAsB5D;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAqDnF;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA2ChF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA0ClF;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAsEpF;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;AAWxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AA2BpD,eAAO,MAAM,iBAAiB;;;CAG7B,CAAA;AAED,eAAO,MAAM,kBAAkB;;;CAG9B,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;CAa3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;CAM5B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;CAQxB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;CAQzB,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;CAU1B,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;CAS3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;CAM5B,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;CAI7B,CAAA;AA+PD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAsB5D;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAqDnF;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA2ChF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA0ClF;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAsEpF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAMlF"}

package/dist/tools/room-tools.js

@@ -4,6 +4,7 @@ import { findCatalogItem, searchCatalogItems } from './asset-catalog';
 import { ErrorCode, throwMcpError } from './errors';
 import { pointInBoundsWithPadding, polygonArea, polygonBounds, wallLength, wallLocalXFromT, } from './geometry';
 import { publishLiveSceneSnapshot } from './live-sync';
+import { measurement } from './measurement';
 import { NodeIdSchema, Vec2Schema } from './schemas';
 const ROOM_TYPES = [
     'bedroom',
@@ -29,8 +30,14 @@ export const createRoomInput = {
     name: z.string().min(1),
     polygon: z.array(Vec2Schema).min(3),
     color: z.string().optional(),
-    wallHeight: z.number().positive().optional(),
-    wallThickness: z.number().positive().optional(),
+    wallHeight: measurement('length', 'm', {
+        positive: true,
+        description: 'Wall height.',
+    }).optional(),
+    wallThickness: measurement('length', 'm', {
+        positive: true,
+        description: 'Wall thickness.',
+    }).optional(),
 };
 export const createRoomOutput = {
     zoneId: z.string(),
@@ -43,8 +50,8 @@ export const addDoorInput = {
     wallId: NodeIdSchema,
     t: z.number().min(0).max(1).optional(),
     position: z.number().min(0).max(1).optional(),
-    width: z.number().positive().optional(),
-    height: z.number().positive().optional(),
+    width: measurement('length', 'm', { positive: true, description: 'Door width.' }).optional(),
+    height: measurement('length', 'm', { positive: true, description: 'Door height.' }).optional(),
     hingesSide: z.enum(['left', 'right']).optional(),
     swingDirection: z.enum(['inward', 'outward']).optional(),
 };
@@ -61,9 +68,12 @@ export const addWindowInput = {
     wallId: NodeIdSchema,
     t: z.number().min(0).max(1).optional(),
     position: z.number().min(0).max(1).optional(),
-    width: z.number().positive().optional(),
-    height: z.number().positive().optional(),
-    sillHeight: z.number().min(0).optional(),
+    width: measurement('length', 'm', { positive: true, description: 'Window width.' }).optional(),
+    height: measurement('length', 'm', { positive: true, description: 'Window height.' }).optional(),
+    sillHeight: measurement('length', 'm', {
+        min: 0,
+        description: 'Sill height above floor.',
+    }).optional(),
 };
 export const addWindowOutput = {
     windowId: z.string(),

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

@@ -1,4 +1,5 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AnyNode } from '@pascal-app/core/schema';
 import { z } from 'zod';
 import type { SceneOperations } from '../operations';
 export declare const levelScopedInput: {
@@ -48,6 +49,9 @@ export declare const verifySceneOutput: {
     issues: z.ZodArray<z.ZodString>;
     hasIssues: z.ZodBoolean;
 };
+export declare function resolveReportedWallHeight(bridge: SceneOperations, wall: Extract<AnyNode, {
+    type: 'wall';
+}>): number;
 export declare function registerListLevels(server: McpServer, bridge: SceneOperations): void;
 export declare function registerGetLevelSummary(server: McpServer, bridge: SceneOperations): void;
 export declare function registerGetWalls(server: McpServer, bridge: SceneOperations): void;

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

@@ -1 +1 @@
-{"version":3,"file":"scene-query.d.ts","sourceRoot":"","sources":["../../src/tools/scene-query.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;AAWpD,eAAO,MAAM,gBAAgB;;CAE5B,CAAA;AAID,eAAO,MAAM,gBAAgB;;;;;;;CAO5B,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;CAcjC,CAAA;AAED,eAAO,MAAM,cAAc;;;CAG1B,CAAA;AAED,eAAO,MAAM,cAAc;;;CAG1B,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;CAY7B,CAAA;AA2YD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAyCnF;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgBxF;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAmBjF;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAmBjF;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAkQpF;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAMxF"}
+{"version":3,"file":"scene-query.d.ts","sourceRoot":"","sources":["../../src/tools/scene-query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAQxE,OAAO,KAAK,EAAE,OAAO,EAAa,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAWpD,eAAO,MAAM,gBAAgB;;CAE5B,CAAA;AAID,eAAO,MAAM,gBAAgB;;;;;;;CAO5B,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;CAcjC,CAAA;AAED,eAAO,MAAM,cAAc;;;CAG1B,CAAA;AAED,eAAO,MAAM,cAAc;;;CAG1B,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;CAY7B,CAAA;AA8CD,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GACvC,MAAM,CAgBR;AAkWD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAyCnF;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgBxF;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAmBjF;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAmBjF;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA4PpF;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAMxF"}

package/dist/tools/scene-query.js

@@ -1,3 +1,5 @@
+import { DEFAULT_LEVEL_HEIGHT, getStoredLevelHeight, getWallPlaneTop, resolveStairTotalRise, resolveWallEffectiveHeight, } from '@pascal-app/core';
+import { computeWallSlabSupport } from '@pascal-app/core/spatial-grid';
 import { z } from 'zod';
 import { distance2D, pointInPolygon, polygonArea, polygonContainsPolygon, wallLength, } from './geometry';
 import { NodeIdSchema } from './schemas';
@@ -71,6 +73,19 @@ function getDefaultLevelId(bridge, requested) {
 function nodesOnLevel(bridge, levelId) {
     return Object.values(bridge.getNodes()).filter((node) => node.id !== levelId && bridge.resolveLevelId(node.id) === levelId);
 }
+export function resolveReportedWallHeight(bridge, wall) {
+    const levelId = bridge.resolveLevelId(wall.id);
+    // Covering-clamped plane for plane-bound walls; explicit heights pass
+    // through resolveWallEffectiveHeight untouched.
+    const planeTop = levelId
+        ? getWallPlaneTop(wall, levelId, bridge.getNodes())
+        : DEFAULT_LEVEL_HEIGHT;
+    const levelNodes = levelId ? nodesOnLevel(bridge, levelId) : [];
+    const slabs = levelNodes.filter((node) => node.type === 'slab');
+    const walls = levelNodes.filter((node) => node.type === 'wall');
+    const support = computeWallSlabSupport(wall, slabs, walls, wall.supportSlabId);
+    return resolveWallEffectiveHeight(wall, planeTop, support.elevation);
+}
 function metadataRecord(node) {
     return typeof node.metadata === 'object' && node.metadata !== null
         ? node.metadata
@@ -116,6 +131,7 @@ function wallSummary(bridge, wall) {
     if (wall.type !== 'wall')
         return null;
     const length = distance2D(wall.start, wall.end);
+    const resolvedHeight = resolveReportedWallHeight(bridge, wall);
     return {
         id: wall.id,
         name: wall.name,
@@ -123,6 +139,8 @@ function wallSummary(bridge, wall) {
         end: wall.end,
         length: Math.round(length * 100) / 100,
         height: wall.height,
+        resolvedHeight,
+        heightIsExplicit: wall.height !== undefined,
         thickness: wall.thickness,
         openings: openingSummaries(bridge, wall.id),
     };
@@ -235,7 +253,7 @@ function stairFootprintPolygons(bridge, stair) {
             {
                 width: stair.width ?? 1,
                 length: 3,
-                height: stair.totalRise ?? 2.5,
+                height: resolveStairTotalRise(stair, nodes),
                 stepCount: stair.stepCount ?? 10,
                 attachmentSide: 'front',
             },
@@ -305,7 +323,7 @@ function parentListsChild(parent, childId) {
 }
 function levelSummary(bridge, levelId) {
     const level = bridge.getNode(levelId);
-    if (!level || level.type !== 'level') {
+    if (level?.type !== 'level') {
         throw new Error(`Level not found: ${levelId}`);
     }
     const nodes = nodesOnLevel(bridge, levelId);
@@ -524,14 +542,9 @@ export function registerVerifyScene(server, bridge) {
                 const summary = levels.find((entry) => entry.levelId === level.id);
                 if (!summary?.isOccupiedStory)
                     continue;
-                const expectedHeight = typeof level.metadata === 'object' &&
-                    level.metadata !== null &&
-                    'height' in level.metadata &&
-                    typeof level.metadata.height === 'number'
-                    ? level.metadata.height
-                    : 3.2;
+                const expectedHeight = getStoredLevelHeight(level);
                 for (const wall of nodesOnLevel(bridge, level.id).filter((node) => node.type === 'wall')) {
-                    const wallHeight = wall.height ?? 2.5;
+                    const wallHeight = resolveReportedWallHeight(bridge, wall);
                     if (wallHeight > expectedHeight + 0.25) {
                         issues.push(`Wall ${wall.name ?? wall.id} on ${level.name ?? level.id} is ${wallHeight}m high; multi-story exterior walls should be split into level-owned story walls`);
                     }
@@ -541,7 +554,7 @@ export function registerVerifyScene(server, bridge) {
         for (const node of Object.values(bridge.getNodes())) {
             if (node.type === 'door' || node.type === 'window') {
                 const parent = node.parentId ? bridge.getNode(node.parentId) : null;
-                if (!parent || parent.type !== 'wall') {
+                if (parent?.type !== 'wall') {
                     issues.push(`${node.type} ${node.id} is not parented to a wall`);
                     continue;
                 }
@@ -558,7 +571,7 @@ export function registerVerifyScene(server, bridge) {
                 if (localX - width / 2 < -0.01 || localX + width / 2 > length + 0.01) {
                     issues.push(`${node.type} ${node.id} extends outside wall ${parent.id}`);
                 }
-                const wallHeight = parent.height ?? 2.5;
+                const wallHeight = resolveReportedWallHeight(bridge, parent);
                 const bottom = node.position[1] - height / 2;
                 const top = node.position[1] + height / 2;
                 if (bottom < -0.01 || top > wallHeight + 0.01) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/mcp",
-  "version": "0.3.1",
+  "version": "1.0.0-beta.1",
   "description": "Model Context Protocol server for Pascal 3D editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -48,21 +48,22 @@
   ],
   "scripts": {
     "build": "tsc --build",
-    "dev": "tsc --build --watch",
+    "dev": "tsgo --build --watch",
     "start": "bun dist/bin/pascal-mcp.js",
     "test": "bun test",
     "smoke": "bun run scripts/smoke.ts",
     "prepublishOnly": "bun run build && bun test"
   },
   "peerDependencies": {
-    "@pascal-app/core": "^0.9.1"
+    "@pascal-app/core": "^1.0.0-beta.1"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "@pascal-app/lingo": "^0.2.0",
     "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@pascal-app/core": "^0.9.1",
+    "@pascal-app/core": "^1.0.0-beta.1",
     "@pascal/typescript-config": "*",
     "@types/node": "^22.19.20",
     "typescript": "6.0.3"