@pascal-app/mcp 1.0.3 → 1.0.4

package/dist/tools/live-sync.js

@@ -1,24 +1,15 @@
-import { syncAutoStairOpenings } from '@pascal-app/core/stair-openings';
+import { refuse, writeTarget } from '@pascal-app/core/agent-tools';
 import { z } from 'zod';
-import { SceneVersionConflictError } from '../storage/types.js';
-import { ErrorCode, throwMcpError } from './errors.js';
-export function syncDerivedStairOpenings(operations) {
-    const updates = syncAutoStairOpenings(operations.getNodes());
-    if (updates.length === 0)
-        return 0;
-    operations.applyPatch(updates.map((update) => ({
-        op: 'update',
-        id: update.id,
-        data: update.data,
-    })));
-    return updates.length;
-}
+import { SceneVersionConflictError, SceneWipeBlockedError } from '../storage/types.js';
+import { ErrorCode, McpError, throwMcpError } from './errors.js';
 /**
  * Output-schema fragment for every tool that mutates the scene. Spread into
  * the tool's `outputSchema` so `persistencePayload` fields survive the SDK's
  * structured-content validation.
  */
 export const liveSyncOutput = {
+    project: z.string().nullable().optional(),
+    unsaved: z.string().optional(),
     persistence: z
         .object({
         status: z.enum(['unbound', 'events_unsupported']),
@@ -31,13 +22,29 @@ const LIVE_SYNC_WARNINGS = {
     events_unsupported: 'The change was applied to the in-memory session only: the attached scene store does not support live scene events, so nothing was persisted.',
 };
 /**
- * Payload fragment matching `liveSyncOutput`: empty after a successful
- * publish, a `persistence` warning when the mutation stayed in-memory.
+ * Payload fragment matching `liveSyncOutput`: the project the write reached, or `null` and a note
+ * when none is bound; a `persistence` warning when the mutation stayed in-memory.
+ */
+export function persistencePayload({ status, project }) {
+    return {
+        ...writeTarget(project),
+        ...(status === 'published'
+            ? {}
+            : { persistence: { status, warning: LIVE_SYNC_WARNINGS[status] } }),
+    };
+}
+/** Where the session's writes go, for a call that publishes nothing (an undo with nothing to undo). */
+export function currentLiveSync(operations) {
+    const project = operations.getActiveScene()?.projectId ?? null;
+    return { status: project ? 'published' : 'unbound', project };
+}
+const LIVE_SYNC_VERSION_CONFLICT = 'live_sync_version_conflict';
+/**
+ * Whether a tool call failed because the stored scene changed after the session
+ * loaded it. The store refuses before writing, so nothing from the call persisted.
  */
-export function persistencePayload(status) {
-    if (status === 'published')
-        return {};
-    return { persistence: { status, warning: LIVE_SYNC_WARNINGS[status] } };
+export function isLiveSyncVersionConflict(error) {
+    return error instanceof McpError && error.message.endsWith(LIVE_SYNC_VERSION_CONFLICT);
 }
 /**
  * Persist the bridge's current graph to the active scene and append a live
@@ -46,13 +53,15 @@ export function persistencePayload(status) {
  * append scene events; callers surface that through `persistencePayload` so
  * the skip is never silent (#725).
  */
-export async function publishLiveSceneSnapshot(operations, kind) {
-    syncDerivedStairOpenings(operations);
+export async function publishLiveSceneSnapshot(operations, kind, 
+/** `allowSceneWipe`: the write empties the project on purpose (clear_scene). */
+options = {}) {
     const active = operations.getActiveScene();
     if (!active)
-        return 'unbound';
+        return { status: 'unbound', project: null };
+    const project = active.projectId ?? active.id;
     if (!operations.canAppendSceneEvents)
-        return 'events_unsupported';
+        return { status: 'events_unsupported', project };
     const graph = operations.exportSceneGraph();
     try {
         const meta = await operations.saveScene({
@@ -63,9 +72,11 @@ export async function publishLiveSceneSnapshot(operations, kind) {
             thumbnailUrl: active.thumbnailUrl,
             graph,
             expectedVersion: active.version,
+            ...(active.graphHash !== undefined ? { expectedGraphHash: active.graphHash } : {}),
             saveMode: 'draft',
             publish: false,
             operation: kind,
+            ...(options.allowSceneWipe ? { allowSceneWipe: true } : {}),
         });
         operations.setActiveScene(meta);
         await operations.appendSceneEvent({
@@ -76,8 +87,18 @@ export async function publishLiveSceneSnapshot(operations, kind) {
         });
     }
     catch (error) {
+        if (error instanceof SceneWipeBlockedError) {
+            // The store kept what it held; the session goes back to it, so the agent's next write builds
+            // on the project as stored rather than on the refused one (deleting the only room, say).
+            const stored = await operations.loadStoredScene(active.id).catch(() => null);
+            if (stored)
+                operations.loadJSON(stored.graph);
+            refuse('scene_wipe_blocked', stored
+                ? 'This write would leave the project empty, so it was blocked and nothing changed. To empty the project on purpose, call clear_scene. To remove only part of it, such as its only room, build what replaces it first, then remove it.'
+                : 'This write would leave the project empty, so it was blocked and not saved. Call load_scene before writing again. To empty the project on purpose, call clear_scene.', { sceneId: active.id, mutationApplied: false, sessionRestored: !!stored });
+        }
         if (error instanceof SceneVersionConflictError) {
-            throwMcpError(ErrorCode.InvalidRequest, 'live_sync_version_conflict', {
+            throwMcpError(ErrorCode.InvalidRequest, LIVE_SYNC_VERSION_CONFLICT, {
                 sceneId: active.id,
                 expectedVersion: active.version,
             });
@@ -85,7 +106,7 @@ export async function publishLiveSceneSnapshot(operations, kind) {
         const message = error instanceof Error ? error.message : String(error);
         throwMcpError(ErrorCode.InternalError, `live_sync_failed: ${message}`);
     }
-    return 'published';
+    return { status: 'published', project };
 }
 export async function appendLiveSceneEvent(operations, sceneId, version, kind, graph) {
     if (!operations.canAppendSceneEvents)

package/dist/tools/local-geometry-scripts.d.ts

@@ -0,0 +1,8 @@
+import type { GeometryScriptHost } from './add-object.js';
+/**
+ * Local compile is opt-in: a separate process is not an untrusted-code sandbox.
+ * three.js modules need PASCAL_SERVER_SCRIPT_COMPILE=1; bpy modules run in the
+ * Blender binary PASCAL_BLENDER names.
+ */
+export declare function localGeometryScripts(projectPath: string): GeometryScriptHost;
+//# sourceMappingURL=local-geometry-scripts.d.ts.map

package/dist/tools/local-geometry-scripts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-geometry-scripts.d.ts","sourceRoot":"","sources":["../../src/tools/local-geometry-scripts.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAEtD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,kBAAkB,CA4D5E"}

package/dist/tools/local-geometry-scripts.js

@@ -0,0 +1,67 @@
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { compileBlenderBuild } from '@pascal-app/geometry-script/blender';
+import { runBlenderLocally } from '@pascal-app/geometry-script/blender-local';
+import { DiskArtifactStore } from '../storage/disk-artifact-store.js';
+/**
+ * Local compile is opt-in: a separate process is not an untrusted-code sandbox.
+ * three.js modules need PASCAL_SERVER_SCRIPT_COMPILE=1; bpy modules run in the
+ * Blender binary PASCAL_BLENDER names.
+ */
+export function localGeometryScripts(projectPath) {
+    const artifacts = new DiskArtifactStore(projectPath);
+    return {
+        compile: async (input) => {
+            if (input.language === 'bpy') {
+                const blender = process.env.PASCAL_BLENDER;
+                if (!blender)
+                    throw new Error('bpy scripts need PASCAL_BLENDER, the path to a Blender binary');
+                const run = await runBlenderLocally({ blender, code: input.code, params: input.params });
+                const { glb, ...compiled } = await compileBlenderBuild({ ...input, run });
+                return { ...compiled, glb: new Uint8Array(glb) };
+            }
+            if (process.env.PASCAL_SERVER_SCRIPT_COMPILE !== '1') {
+                throw new Error('Local script compilation requires PASCAL_SERVER_SCRIPT_COMPILE=1');
+            }
+            return new Promise((resolve, reject) => {
+                const child = spawn(process.execPath, [fileURLToPath(new URL('./geometry-script-worker.js', import.meta.url))], { env: {}, stdio: ['pipe', 'pipe', 'pipe'] });
+                const chunks = [];
+                let stderr = '';
+                const timer = setTimeout(() => {
+                    child.kill('SIGKILL');
+                    reject(new Error('Geometry script compilation timed out'));
+                }, 20_000);
+                child.stdout.on('data', (chunk) => chunks.push(chunk));
+                child.stderr.on('data', (chunk) => {
+                    stderr = (stderr + chunk.toString()).slice(-2000);
+                });
+                child.stdin.on('error', reject);
+                child.on('error', (error) => {
+                    clearTimeout(timer);
+                    reject(error);
+                });
+                child.on('close', () => {
+                    clearTimeout(timer);
+                    try {
+                        const message = JSON.parse(Buffer.concat(chunks).toString());
+                        if (!message.ok)
+                            return reject(new Error(message.error));
+                        resolve({
+                            ...message.compiled,
+                            glb: new Uint8Array(Buffer.from(message.glb, 'base64')),
+                        });
+                    }
+                    catch {
+                        reject(new Error(`Geometry script compilation failed: ${stderr}`));
+                    }
+                });
+                child.stdin.end(JSON.stringify(input));
+            });
+        },
+        storeArtifact: async ({ sha256, bytes }) => {
+            await artifacts.put(sha256, bytes);
+            return sha256;
+        },
+        readArtifact: ({ sha256 }) => artifacts.read(sha256),
+    };
+}

package/dist/tools/measure.d.ts

@@ -7,6 +7,12 @@ export declare const measureInput: {
 };
 export declare const measureOutput: {
     distanceMeters: z.ZodNumber;
+    fromPoint: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    toPoint: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    approximate: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>>;
     areaSqMeters: z.ZodOptional<z.ZodNumber>;
     units: z.ZodLiteral<"meters">;
     areaUnits: z.ZodOptional<z.ZodLiteral<"square_meters">>;

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

@@ -1 +1 @@
-{"version":3,"file":"measure.d.ts","sourceRoot":"","sources":["../../src/tools/measure.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;AAKpD,eAAO,MAAM,YAAY;;;CAGxB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;CAKzB,CAAA;AAsED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAyEhF"}
+{"version":3,"file":"measure.d.ts","sourceRoot":"","sources":["../../src/tools/measure.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;AAMpD,eAAO,MAAM,YAAY;;;CAGxB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;CAQzB,CAAA;AAeD,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA6FhF"}

package/dist/tools/measure.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
 import { ErrorCode, throwMcpError } from './errors.js';
+import { resolveNodeWorldPoint } from './node-world-point.js';
 import { NodeIdSchema } from './schemas.js';
 export const measureInput = {
     fromId: NodeIdSchema,
@@ -8,66 +9,13 @@ export const measureInput = {
 };
 export const measureOutput = {
     distanceMeters: z.number(),
+    fromPoint: z.array(z.number()).optional(),
+    toPoint: z.array(z.number()).optional(),
+    approximate: z.array(z.object({ id: z.string(), reason: z.string() })).optional(),
     areaSqMeters: z.number().optional(),
     units: z.literal('meters'),
     areaUnits: z.literal('square_meters').optional(),
 };
-/**
- * Compute a 3D centre point in level-coordinate space for distance measurement.
- *
- * For walls / fences: midpoint of the start/end segment at Y=0.
- * For positioned nodes (item, door, window, building, stair, roof): `position`.
- * For polygon nodes (slab, ceiling, zone): 2D centroid lifted to Y=0.
- * For site: centroid of property line at Y=0 if available.
- *
- * Returns null if no representative centre can be derived (e.g. level node
- * has no position of its own).
- */
-function getCentre(node) {
-    switch (node.type) {
-        case 'wall':
-        case 'fence': {
-            const [x1, z1] = node.start;
-            const [x2, z2] = node.end;
-            return [(x1 + x2) / 2, 0, (z1 + z2) / 2];
-        }
-        case 'item':
-        case 'door':
-        case 'window':
-        case 'building':
-        case 'stair':
-        case 'roof':
-            return node.position;
-        case 'slab':
-        case 'ceiling':
-        case 'zone': {
-            const poly = node.polygon;
-            if (!poly || poly.length === 0)
-                return null;
-            let cx = 0;
-            let cz = 0;
-            for (const [x, z] of poly) {
-                cx += x;
-                cz += z;
-            }
-            return [cx / poly.length, 0, cz / poly.length];
-        }
-        case 'site': {
-            const pts = node.polygon?.points ?? [];
-            if (pts.length === 0)
-                return [0, 0, 0];
-            let cx = 0;
-            let cz = 0;
-            for (const [x, z] of pts) {
-                cx += x;
-                cz += z;
-            }
-            return [cx / pts.length, 0, cz / pts.length];
-        }
-        default:
-            return null;
-    }
-}
 /** Compute polygon area via the shoelace formula. */
 function shoelaceArea(polygon) {
     if (polygon.length < 3)
@@ -84,7 +32,7 @@ function shoelaceArea(polygon) {
 export function registerMeasure(server, bridge) {
     server.registerTool('measure', {
         title: 'Measure',
-        description: 'Measure distance (in meters) between two nodes, or the net area of a polygon node when fromId === toId.',
+        description: "Measure the distance (in meters) between two nodes, or the net area of a polygon node when fromId === toId. Distance is between world-space reference points, returned as fromPoint/toPoint: a positioned node's origin in its host's frame (an item's base, a door's or window's centre in its wall), a wall's or fence's midpoint at its base, a slab's, ceiling's or zone's polygon centroid on its plane, a block's or imported mesh's vertex-bounds centre, a level's plan centre on its base plane, and another container's descendants' centre. `approximate` lists nodes whose renderer derives the pose from data not modelled here (a downspout at its gutter outlet, a gutter at the eave), with the reason.",
         inputSchema: measureInput,
         outputSchema: measureOutput,
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
@@ -124,17 +72,37 @@ export function registerMeasure(server, bridge) {
                 structuredContent: payload,
             };
         }
-        const fromCentre = getCentre(from);
-        const toCentre = getCentre(to);
-        if (!(fromCentre && toCentre)) {
-            throwMcpError(ErrorCode.InvalidRequest, `Cannot derive centre for measurement between ${from.type} and ${to.type}`);
-        }
-        const dx = fromCentre[0] - toCentre[0];
-        const dy = fromCentre[1] - toCentre[1];
-        const dz = fromCentre[2] - toCentre[2];
+        const nodes = bridge.getNodes();
+        const pointOf = (node) => {
+            try {
+                const point = resolveNodeWorldPoint(node.id, nodes);
+                if (point)
+                    return point;
+            }
+            catch (err) {
+                const reason = err instanceof Error ? err.message : String(err);
+                throwMcpError(ErrorCode.InvalidRequest, `Cannot derive a world point for ${node.type} ${node.id}: ${reason}`);
+            }
+            throwMcpError(ErrorCode.InvalidRequest, `Cannot derive a world point for ${node.type} ${node.id}`);
+        };
+        const fromResolved = pointOf(from);
+        const toResolved = pointOf(to);
+        const fromPoint = fromResolved.point;
+        const toPoint = toResolved.point;
+        const approximate = [];
+        if (fromResolved.approximate)
+            approximate.push({ id: from.id, reason: fromResolved.approximate });
+        if (toResolved.approximate)
+            approximate.push({ id: to.id, reason: toResolved.approximate });
+        const dx = fromPoint[0] - toPoint[0];
+        const dy = fromPoint[1] - toPoint[1];
+        const dz = fromPoint[2] - toPoint[2];
         const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
         const payload = {
             distanceMeters: distance,
+            fromPoint,
+            toPoint,
+            ...(approximate.length > 0 ? { approximate } : {}),
             units: 'meters',
         };
         return {

package/dist/tools/measurement.d.ts

@@ -1,37 +1,2 @@
-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>>;
+export { measurement } from '@pascal-app/core/agent-tools';
 //# sourceMappingURL=measurement.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../src/tools/measurement.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/tools/measurement.js

@@ -1,94 +1,2 @@
-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);
-}
+// The one measurement() helper, shared with the hosted chat through the agent tool contracts.
+export { measurement } from '@pascal-app/core/agent-tools';

package/dist/tools/node-world-point.d.ts

@@ -0,0 +1,37 @@
+import type { Vec3 } from '@pascal-app/core/agent-operations';
+import { AnyNode } from '@pascal-app/core/schema';
+type Nodes = Readonly<Record<string, AnyNode>>;
+/**
+ * Built-in kinds the viewer lifts onto the slab under them through the
+ * `floorPlaced` capability of their registered definition, and whose footprint
+ * core cannot derive without it (core derives item, shelf and procedural-item
+ * footprints from the node itself). Headless MCP does not load
+ * `@pascal-app/nodes`, so their lift is unresolved and flagged, not guessed. A
+ * test keeps this list in step with the definitions.
+ */
+export declare const HEADLESS_UNRESOLVED_FLOOR_LIFT_KINDS: readonly ["block", "cabinet", "cabinet-module", "column", "duct-terminal", "hvac-equipment", "spawn", "stair"];
+/**
+ * World-space reference point of any node, following the frames the viewer
+ * renders it in (core's `nodeLevelFrame`, the level's stacked base Y and its
+ * building transform):
+ * - a positioned node: its origin (an item's or column's base, a door's or
+ *   window's centre), inside its host's frame;
+ * - a wall or fence: the midpoint of its centreline (arc or spline) at its base;
+ * - a grid line: its midpoint;
+ * - a slab, ceiling, zone or site: its polygon centroid on its own plane;
+ * - a block or imported mesh: the centre of its vertex bounds;
+ * - a path or measurement: the centre of its points;
+ * - a level: the plan centre of its content on its base plane;
+ * - another container (a unit, …): the centre of its descendants' points,
+ *   or its origin when it has none.
+ * Kinds whose renderer derives the pose elsewhere (a downspout at its gutter
+ * outlet, a gutter at the eave, …) are returned with an `approximate` reason.
+ */
+export type NodeWorldPoint = {
+    point: Vec3;
+    /** Set when the renderer derives this kind's pose from data not modelled here. */
+    approximate?: string;
+};
+export declare function resolveNodeWorldPoint(id: string, nodes: Nodes): NodeWorldPoint | null;
+export {};
+//# sourceMappingURL=node-world-point.d.ts.map

package/dist/tools/node-world-point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-world-point.d.ts","sourceRoot":"","sources":["../../src/tools/node-world-point.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mCAAmC,CAAA;AAS7D,OAAO,EACL,OAAO,EAIR,MAAM,yBAAyB,CAAA;AAEhC,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAgN9C;;;;;;;GAOG;AACH,eAAO,MAAM,oCAAoC,gHASvC,CAAA;AA6KV;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,IAAI,CAAA;IACX,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,cAAc,GAAG,IAAI,CAMrF"}