@pascal-app/mcp 0.3.0 → 0.3.2

package/README.md

@@ -227,6 +227,77 @@ console.log(scene)
 See [`examples/embed-in-agent.ts`](./examples/embed-in-agent.ts) for a
 compilable version.
 
+## Coordinate conventions
+
+Pascal is a **right-handed** scene where **X and Z form the ground plane and Y
+is up**. Lengths are in **metres**; rotations are **radians**, stored as Euler
+`[x, y, z]` tuples.
+
+**Plan → world.** Every 2-D point you pass is a level/building-local
+ground-plane coordinate
+`[x, z]` — this includes `wall.start` / `wall.end` and the `polygon` / `holes`
+arrays of `slab`, `zone`, and `ceiling`. With the default identity building
+transform, it appears in world space as:
+
+```
+[x, z]  →  (x, y, z)      // the 2nd component is world Z (depth), not "up"
+```
+
+There is no sign flip in the stored convention: tooling consumes the second
+component as world Z directly. The vertical `y` starts from the owning level's
+stacked height as computed by the level system from accumulated level heights,
+plus the element's own height; slabs additionally carry an absolute
+`elevation`.
+
+**Heads-up when you compute coordinates outside the editor.** Pascal's
+viewports apply their own rotations on top of the world axes: the 2-D plan
+panel rotates its content by the user's view rotation (north-aligned = 0°,
+`FLOORPLAN_VIEW_ROTATION_DEG` baseline, north = world −Z), and
+the 3-D "top-down" snap preserves the camera's current azimuth, so when invoked
+from the iso default position, world and screen axes are offset by ~45° until
+you orbit to an axis-aligned view. So a layout authored as if
+*"Y = north, viewed top-down"* — common in land surveys, north-up site plans,
+and 2-D plotting libraries — will arrive **rotated** relative to its source
+when viewed in Pascal (and possibly further reflected, depending on which
+viewport and camera state you're in). The editor's own 2-D and 3-D tools are
+internally consistent with their stored coordinates, so this only affects
+geometry authored programmatically. To verify orientation before trusting
+externally-computed coordinates, place a scaled guide image at known anchor
+points and check alignment; apply whatever rotation (or reflection) your
+authoring side needs to match.
+
+A worked demonstration of all of this — axis-aligned baseline, the rotated
+30° example below, and a paired "page-intent vs world-result" L for the
+external-coordinate gotcha — lives in
+[`examples/coordinate-conventions-demo.md`](./examples/coordinate-conventions-demo.md)
+and [`examples/coordinate-conventions-demo.json`](./examples/coordinate-conventions-demo.json).
+Load the JSON with
+`pascal-mcp --stdio --scene examples/coordinate-conventions-demo.json`.
+
+**Example — a 6 × 4 m slab rotated 30° about its first corner** (coordinates
+rounded to 3 dp; sides ≈ 6 m / 4 m; not axis-aligned, so the mapping is
+actually exercised):
+
+```json
+{
+  "op": "create",
+  "parentId": "<levelId>",
+  "node": {
+    "type": "slab",
+    "elevation": 0.0,
+    "polygon": [[0, 0], [5.196, 3.0], [3.196, 6.464], [-2.0, 3.464]]
+  }
+}
+```
+
+This lands flat on the ground (Y = 0), about 6 m along a heading 30° off the +X
+axis and 4 m along its perpendicular — i.e. occupying world (x, z) directly.
+
+One separate gotcha: wall-attached coordinates are wall-local, not plan
+coordinates. Stored door/window `position[0]`, and `place_item` `position[0]`
+when the target is a wall, are metres along the wall; wall-attached rotations
+are wall-local too.
+
 ## Tools
 
 All tools validate their inputs and outputs with Zod. Mutation tools are

package/dist/bridge/scene-bridge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-bridge.d.ts","sourceRoot":"","sources":["../../src/bridge/scene-bridge.ts"],"names":[],"mappings":"AACA,OAAO,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAA;AACpE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AACtD,OAAO,EAAE,KAAK,SAAS,EAA4B,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAGpG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEjD,MAAM,MAAM,eAAe,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAC/E,MAAM,MAAM,gBAAgB,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,eAAe,EAAE,CAAA;CAAE,CAAA;AAE5E,MAAM,MAAM,WAAW,GAAG;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAA;AAC/E,MAAM,MAAM,WAAW,GAAG;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AACjF,MAAM,MAAM,WAAW,GAAG;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,SAAS,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AAC5E,MAAM,MAAM,KAAK,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,CAAA;AAC3D,MAAM,MAAM,eAAe,GAAG,IAAI,CAChC,SAAS,EACT,IAAI,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,cAAc,GAAG,SAAS,CACrE,CAAA;AAED;;;;;;GAMG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,WAAW,CAA+B;IAElD;;;OAGG;IACH,cAAc,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI;IAW3C,cAAc,IAAI,eAAe,GAAG,IAAI;IAIxC,gBAAgB,IAAI,IAAI;IAIxB,6EAA6E;IAC7E,WAAW,IAAI,IAAI;IAInB,iDAAiD;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,WAAW,EAAE,SAAS,EAAE,GAAG,IAAI;IAI3E,uDAAuD;IACvD,UAAU,IAAI,UAAU,GAAG;QAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE;IAYnE;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAuCzC,oDAAoD;IACpD,OAAO,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,GAAG,IAAI;IAKtC,iEAAiE;IACjE,QAAQ,IAAI,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC;IAItC,qBAAqB;IACrB,cAAc,IAAI,SAAS,EAAE;IAI7B;;;;;;;;;;;;;;OAcG;IACH,WAAW,CAAC,QAAQ,EAAE,SAAS,GAAG,OAAO,EAAE;IAuC3C;;;;;OAKG;IACH,WAAW,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,EAAE;IAqBrC,qEAAqE;IACrE,SAAS,CAAC,MAAM,EAAE;QAChB,IAAI,CAAC,EAAE,WAAW,CAAA;QAClB,QAAQ,CAAC,EAAE,SAAS,GAAG,IAAI,CAAA;QAC3B,OAAO,CAAC,EAAE,SAAS,CAAA;KACpB,GAAG,OAAO,EAAE;IAiBb,4EAA4E;IAC5E,cAAc,CAAC,EAAE,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI;IAQ/C;;;;OAIG;IACH,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,GAAG,SAAS;IAK1D,iEAAiE;IACjE,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI;IAOvD;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,UAAQ,GAAG,MAAM,EAAE;IAwBpD;;;;OAIG;IACH,UAAU,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG;QAC5B,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,SAAS,EAAE,CAAA;QACvB,UAAU,EAAE,SAAS,EAAE,CAAA;KACxB;IAkHD,yDAAyD;IACzD,IAAI,CAAC,KAAK,SAAI,GAAG,MAAM;IAOvB,yDAAyD;IACzD,IAAI,CAAC,KAAK,SAAI,GAAG,MAAM;IAOvB;;;OAGG;IACH,aAAa,IAAI,gBAAgB;IAiBjC;;;OAGG;IACH,UAAU,IAAI,MAAM,EAAE;IAStB,yCAAyC;IACzC,UAAU,IAAI;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE;IAQxD,4CAA4C;IAC5C,YAAY,IAAI,IAAI;IAMpB;;;;OAIG;IACH,OAAO,CAAC,yBAAyB;IAqBjC;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;CAkB5B"}
+{"version":3,"file":"scene-bridge.d.ts","sourceRoot":"","sources":["../../src/bridge/scene-bridge.ts"],"names":[],"mappings":"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"}

package/dist/bridge/scene-bridge.js

@@ -48,6 +48,9 @@ export class SceneBridge {
             nodes: state.nodes,
             rootNodeIds: state.rootNodeIds,
             collections: state.collections ?? {},
+            ...(state.hasExplicitPluginInstallState || state.installedPlugins.length > 0
+                ? { installedPlugins: state.installedPlugins }
+                : {}),
         }));
     }
     /**
@@ -88,6 +91,9 @@ export class SceneBridge {
             }
         }
         this.setScene(nodes, rootNodeIds);
+        if (Array.isArray(obj.installedPlugins)) {
+            useScene.getState().setInstalledPlugins(obj.installedPlugins.filter((id) => typeof id === 'string'), { explicit: true });
+        }
     }
     /** Read a single node, or `null` if not present. */
     getNode(id) {

package/dist/operations/scene-operations.js

@@ -56,6 +56,7 @@ class SceneOperationsFacade {
             nodes: exported.nodes,
             rootNodeIds: exported.rootNodeIds,
             collections: exported.collections,
+            installedPlugins: exported.installedPlugins,
         };
     }
     loadJSON(json) {

package/dist/resources/constraints.js

@@ -15,7 +15,7 @@ const EMPTY_MITER_DATA = {
 };
 function buildPayload(bridge, levelId) {
     const level = bridge.getNode(levelId);
-    if (!level || level.type !== 'level') {
+    if (level?.type !== 'level') {
         return {
             error: 'level_not_found',
             levelId,

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

@@ -4,12 +4,12 @@ import type { SceneOperations } from '../operations';
 export declare const createStoryShellInput: {
     levelId: z.ZodString;
     footprint: z.ZodArray<z.ZodArray<z.ZodNumber>>;
-    wallHeight: z.ZodDefault<z.ZodNumber>;
-    wallThickness: z.ZodDefault<z.ZodNumber>;
+    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>>>;
     createSlab: z.ZodDefault<z.ZodBoolean>;
     createCeiling: z.ZodDefault<z.ZodBoolean>;
-    slabElevation: z.ZodDefault<z.ZodNumber>;
-    ceilingHeight: z.ZodOptional<z.ZodNumber>;
+    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>>>;
     namePrefix: z.ZodOptional<z.ZodString>;
     wallMaterialPreset: z.ZodOptional<z.ZodString>;
     slabMaterialPreset: z.ZodOptional<z.ZodString>;
@@ -28,10 +28,10 @@ export declare const createRoofInput: {
     useDedicatedRoofLevel: z.ZodDefault<z.ZodBoolean>;
     roofLevelLabel: z.ZodDefault<z.ZodString>;
     roofLevelElevation: z.ZodOptional<z.ZodNumber>;
-    roofLevelHeight: 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.ZodNumber;
-    depth: 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<{
         flat: "flat";
         hip: "hip";
@@ -41,10 +41,10 @@ export declare const createRoofInput: {
         dutch: "dutch";
         mansard: "mansard";
     }>>;
-    pitch: z.ZodDefault<z.ZodNumber>;
-    wallHeight: z.ZodDefault<z.ZodNumber>;
-    wallThickness: z.ZodDefault<z.ZodNumber>;
-    overhang: z.ZodDefault<z.ZodNumber>;
+    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>;
 };
@@ -59,26 +59,26 @@ export declare const createStairBetweenLevelsInput: {
     fromLevelId: z.ZodString;
     toLevelId: z.ZodString;
     position: z.ZodArray<z.ZodNumber>;
-    rotation: z.ZodDefault<z.ZodNumber>;
-    width: z.ZodDefault<z.ZodNumber>;
-    runLength: z.ZodDefault<z.ZodNumber>;
-    totalRise: z.ZodDefault<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.ZodDefault<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";
-        left: "left";
-        right: "right";
         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.ZodNumber>;
-    openingLength: z.ZodOptional<z.ZodNumber>;
-    openingOffset: z.ZodDefault<z.ZodNumber>;
+    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.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>;
 };

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;AAaxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAOpD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;CAajC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;CAMlC,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;CAiB3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;CAM5B,CAAA;AAED,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;CAqBzC,CAAA;AAED,eAAO,MAAM,8BAA8B;;;;;;CAM1C,CAAA;AA4GD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAiT1F"}
+{"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;AAaxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAQpD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;CAqBjC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;CAMlC,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;CA0B3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;CAM5B,CAAA;AAED,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCzC,CAAA;AAED,eAAO,MAAM,8BAA8B;;;;;;CAM1C,CAAA;AA4GD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAiT1F"}

package/dist/tools/construction-tools.js

@@ -1,18 +1,25 @@
 import { CeilingNode, getActiveRoofHeight, LevelNode, RoofNode, RoofSegmentNode, SlabNode, StairNode, StairSegmentNode, WallNode, } from '@pascal-app/core/schema';
 import { z } from 'zod';
 import { publishLiveSceneSnapshot } from './live-sync';
+import { measurement } from './measurement';
 import { NodeIdSchema, Vec2Schema, Vec3Schema } from './schemas';
 const ROOF_TYPES = ['hip', 'gable', 'shed', 'gambrel', 'dutch', 'mansard', 'flat'];
 const RAILING_MODES = ['none', 'left', 'right', 'both'];
 export const createStoryShellInput = {
     levelId: NodeIdSchema,
     footprint: z.array(Vec2Schema).min(3),
-    wallHeight: z.number().positive().default(2.8),
-    wallThickness: z.number().positive().default(0.16),
+    wallHeight: measurement('length', 'm', { positive: true, description: 'Wall height.' }).default(2.8),
+    wallThickness: measurement('length', 'm', {
+        positive: true,
+        description: 'Wall thickness.',
+    }).default(0.16),
     createSlab: z.boolean().default(true),
     createCeiling: z.boolean().default(true),
-    slabElevation: z.number().default(0.1),
-    ceilingHeight: z.number().positive().optional(),
+    slabElevation: measurement('length', 'm', { description: 'Slab elevation.' }).default(0.1),
+    ceilingHeight: measurement('length', 'm', {
+        positive: true,
+        description: 'Ceiling height.',
+    }).optional(),
     namePrefix: z.string().optional(),
     wallMaterialPreset: z.string().optional(),
     slabMaterialPreset: z.string().optional(),
@@ -30,16 +37,23 @@ export const createRoofInput = {
     roofLevelId: NodeIdSchema.optional(),
     useDedicatedRoofLevel: z.boolean().default(true),
     roofLevelLabel: z.string().default('Roof'),
+    // A level ordinal (story index), not a length — kept numeric.
     roofLevelElevation: z.number().optional(),
-    roofLevelHeight: z.number().positive().optional(),
+    roofLevelHeight: measurement('length', 'm', {
+        positive: true,
+        description: 'Roof level height.',
+    }).optional(),
     center: Vec3Schema.optional(),
-    width: z.number().positive(),
-    depth: z.number().positive(),
+    width: measurement('length', 'm', { positive: true, description: 'Roof width.' }),
+    depth: measurement('length', 'm', { positive: true, description: 'Roof depth.' }),
     roofType: z.enum(ROOF_TYPES).default('hip'),
-    pitch: z.number().min(0).max(85).default(35),
-    wallHeight: z.number().min(0).default(0.35),
-    wallThickness: z.number().positive().default(0.16),
-    overhang: z.number().min(0).default(0.45),
+    pitch: measurement('angle', 'deg', { min: 0, max: 85, description: 'Roof pitch.' }).default(35),
+    wallHeight: measurement('length', 'm', { min: 0, description: 'Knee-wall height.' }).default(0.35),
+    wallThickness: measurement('length', 'm', {
+        positive: true,
+        description: 'Wall thickness.',
+    }).default(0.16),
+    overhang: measurement('length', 'm', { min: 0, description: 'Eave overhang.' }).default(0.45),
     materialPreset: z.string().optional(),
     name: z.string().optional(),
 };
@@ -54,21 +68,33 @@ export const createStairBetweenLevelsInput = {
     fromLevelId: NodeIdSchema,
     toLevelId: NodeIdSchema,
     position: Vec3Schema,
-    rotation: z.number().default(0),
-    width: z.number().positive().default(1),
-    runLength: z.number().positive().default(3),
-    totalRise: z.number().positive().default(2.8),
+    rotation: measurement('angle', 'rad', { description: 'Y-axis rotation.' }).default(0),
+    width: measurement('length', 'm', { positive: true, description: 'Stair width.' }).default(1),
+    runLength: measurement('length', 'm', {
+        positive: true,
+        description: 'Horizontal run length.',
+    }).default(3),
+    totalRise: measurement('length', 'm', {
+        positive: true,
+        description: 'Total vertical rise.',
+    }).default(2.8),
     stepCount: z.number().int().positive().default(14),
     railingMode: z.enum(RAILING_MODES).default('both'),
     destinationSlabId: NodeIdSchema.optional(),
     sourceCeilingId: NodeIdSchema.optional(),
     createDestinationSlabOpening: z.boolean().default(true),
     createSourceCeilingOpening: z.boolean().default(true),
-    openingWidth: z.number().positive().optional(),
-    openingLength: z.number().positive().optional(),
-    openingOffset: z.number().min(0).default(0.15),
+    openingWidth: measurement('length', 'm', {
+        positive: true,
+        description: 'Floor opening width.',
+    }).optional(),
+    openingLength: measurement('length', 'm', {
+        positive: true,
+        description: 'Floor opening length.',
+    }).optional(),
+    openingOffset: measurement('length', 'm', { min: 0, description: 'Opening offset.' }).default(0),
     openingCenter: Vec2Schema.optional(),
-    openingRotation: z.number().optional(),
+    openingRotation: measurement('angle', 'rad', { description: 'Opening rotation.' }).optional(),
     materialPreset: z.string().optional(),
     name: z.string().optional(),
 };

package/dist/tools/create-level.d.ts

@@ -4,7 +4,7 @@ import type { SceneOperations } from '../operations';
 export declare const createLevelInput: {
     buildingId: z.ZodString;
     elevation: z.ZodOptional<z.ZodNumber>;
-    height: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
     label: z.ZodOptional<z.ZodString>;
 };
 export declare const createLevelOutput: {

package/dist/tools/create-level.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-level.d.ts","sourceRoot":"","sources":["../../src/tools/create-level.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;AAKpD,eAAO,MAAM,gBAAgB;;;;;CAK5B,CAAA;AAED,eAAO,MAAM,iBAAiB;;CAE7B,CAAA;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA0CpF"}
+{"version":3,"file":"create-level.d.ts","sourceRoot":"","sources":["../../src/tools/create-level.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;AAMpD,eAAO,MAAM,gBAAgB;;;;;CAQ5B,CAAA;AAED,eAAO,MAAM,iBAAiB;;CAE7B,CAAA;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA0CpF"}

package/dist/tools/create-level.js

@@ -2,11 +2,15 @@ import { LevelNode } from '@pascal-app/core/schema';
 import { z } from 'zod';
 import { ErrorCode, throwMcpError } from './errors';
 import { publishLiveSceneSnapshot } from './live-sync';
+import { measurement } from './measurement';
 import { NodeIdSchema } from './schemas';
 export const createLevelInput = {
     buildingId: NodeIdSchema,
     elevation: z.number().optional(),
-    height: z.number().optional(),
+    height: measurement('length', 'm', {
+        min: 0,
+        description: 'Level height (stored in metadata).',
+    }).optional(),
     label: z.string().optional(),
 };
 export const createLevelOutput = {

package/dist/tools/create-wall.d.ts

@@ -5,8 +5,8 @@ export declare const createWallInput: {
     levelId: z.ZodString;
     start: z.ZodArray<z.ZodNumber>;
     end: z.ZodArray<z.ZodNumber>;
-    thickness: z.ZodOptional<z.ZodNumber>;
-    height: z.ZodOptional<z.ZodNumber>;
+    thickness: 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>>>;
 };
 export declare const createWallOutput: {
     wallId: z.ZodString;

package/dist/tools/create-wall.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-wall.d.ts","sourceRoot":"","sources":["../../src/tools/create-wall.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;AAKpD,eAAO,MAAM,eAAe;;;;;;CAM3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;CAE5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgDnF"}
+{"version":3,"file":"create-wall.d.ts","sourceRoot":"","sources":["../../src/tools/create-wall.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;AAMpD,eAAO,MAAM,eAAe;;;;;;CAS3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;CAE5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgDnF"}

package/dist/tools/create-wall.js

@@ -2,13 +2,17 @@ import { WallNode } from '@pascal-app/core/schema';
 import { z } from 'zod';
 import { ErrorCode, throwMcpError } from './errors';
 import { publishLiveSceneSnapshot } from './live-sync';
+import { measurement } from './measurement';
 import { NodeIdSchema, Vec2Schema } from './schemas';
 export const createWallInput = {
     levelId: NodeIdSchema,
     start: Vec2Schema,
     end: Vec2Schema,
-    thickness: z.number().positive().optional(),
-    height: z.number().positive().optional(),
+    thickness: measurement('length', 'm', {
+        positive: true,
+        description: 'Wall thickness.',
+    }).optional(),
+    height: measurement('length', 'm', { positive: true, description: 'Wall height.' }).optional(),
 };
 export const createWallOutput = {
     wallId: z.string(),

package/dist/tools/cut-opening.d.ts

@@ -4,12 +4,12 @@ import type { SceneOperations } from '../operations';
 export declare const cutOpeningInput: {
     wallId: z.ZodString;
     type: z.ZodEnum<{
-        window: "window";
         door: "door";
+        window: "window";
     }>;
     position: z.ZodNumber;
-    width: z.ZodNumber;
-    height: z.ZodNumber;
+    width: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+    height: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
 };
 export declare const cutOpeningOutput: {
     openingId: z.ZodString;

package/dist/tools/cut-opening.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cut-opening.d.ts","sourceRoot":"","sources":["../../src/tools/cut-opening.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;AAMpD,eAAO,MAAM,eAAe;;;;;;;;;CAM3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;CAE5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAyDnF"}
+{"version":3,"file":"cut-opening.d.ts","sourceRoot":"","sources":["../../src/tools/cut-opening.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,eAAe;;;;;;;;;CAM3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;CAE5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAyDnF"}

package/dist/tools/cut-opening.js

@@ -3,13 +3,14 @@ import { z } from 'zod';
 import { ErrorCode, throwMcpError } from './errors';
 import { wallLength, wallLocalXFromT } from './geometry';
 import { publishLiveSceneSnapshot } from './live-sync';
+import { measurement } from './measurement';
 import { NodeIdSchema } from './schemas';
 export const cutOpeningInput = {
     wallId: NodeIdSchema,
     type: z.enum(['door', 'window']),
     position: z.number().min(0).max(1),
-    width: z.number().positive(),
-    height: z.number().positive(),
+    width: measurement('length', 'm', { positive: true, description: 'Opening width.' }),
+    height: measurement('length', 'm', { positive: true, description: 'Opening height.' }),
 };
 export const cutOpeningOutput = {
     openingId: z.string(),

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;AAiTD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA6ErF"}