@pascal-app/mcp 0.2.0

package/dist/tools/geometry.d.ts

@@ -0,0 +1,24 @@
+import type { WallNode } from '@pascal-app/core/schema';
+export type Vec2 = [number, number];
+export type Vec3 = [number, number, number];
+export declare function distance2D(a: Vec2, b: Vec2): number;
+export declare function wallLength(wall: Pick<WallNode, 'start' | 'end'>): number;
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function wallLocalXFromT(wall: Pick<WallNode, 'start' | 'end'>, t: number, width: number): number;
+export declare function projectWorldPointToWallLocalX(wall: Pick<WallNode, 'start' | 'end'>, position: Vec3): number;
+export declare function polygonArea(points: Vec2[]): number;
+export declare function polygonBounds(points: Vec2[]): {
+    minX: number;
+    maxX: number;
+    minZ: number;
+    maxZ: number;
+    width: number;
+    depth: number;
+    centerX: number;
+    centerZ: number;
+};
+export declare function pointInBoundsWithPadding(x: number, z: number, bounds: ReturnType<typeof polygonBounds>, padding: number): boolean;
+export declare function pointOnSegment(point: Vec2, a: Vec2, b: Vec2, tolerance?: number): boolean;
+export declare function pointInPolygon(point: Vec2, polygon: Vec2[], includeBoundary?: boolean): boolean;
+export declare function polygonContainsPolygon(outer: Vec2[], inner: Vec2[]): boolean;
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/tools/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEvD,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AACnC,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAE3C,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAInD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,GAAG,MAAM,CAExE;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAGrE;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,GACZ,MAAM,CAGR;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,QAAQ,EAAE,IAAI,GACb,MAAM,CAWR;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,CASlD;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG;IAC7C,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB,CAiBA;AAED,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,OAAO,CAOT;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,SAAO,GAAG,OAAO,CAOvF;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,eAAe,UAAO,GAAG,OAAO,CAgB5F;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAE5E"}

package/dist/tools/geometry.js

@@ -0,0 +1,94 @@
+export function distance2D(a, b) {
+    const dx = b[0] - a[0];
+    const dz = b[1] - a[1];
+    return Math.sqrt(dx * dx + dz * dz);
+}
+export function wallLength(wall) {
+    return distance2D(wall.start, wall.end);
+}
+export function clamp(value, min, max) {
+    if (max < min)
+        return (min + max) / 2;
+    return Math.max(min, Math.min(max, value));
+}
+export function wallLocalXFromT(wall, t, width) {
+    const length = wallLength(wall);
+    return clamp(t * length, width / 2, length - width / 2);
+}
+export function projectWorldPointToWallLocalX(wall, position) {
+    const [sx, sz] = wall.start;
+    const [ex, ez] = wall.end;
+    const dx = ex - sx;
+    const dz = ez - sz;
+    const len = Math.sqrt(dx * dx + dz * dz);
+    if (len === 0)
+        return 0;
+    const px = position[0] - sx;
+    const pz = position[2] - sz;
+    const distance = px * (dx / len) + pz * (dz / len);
+    return clamp(distance, 0, len);
+}
+export function polygonArea(points) {
+    if (points.length < 3)
+        return 0;
+    let area = 0;
+    for (let i = 0; i < points.length; i++) {
+        const current = points[i];
+        const next = points[(i + 1) % points.length];
+        area += current[0] * next[1] - next[0] * current[1];
+    }
+    return Math.abs(area) / 2;
+}
+export function polygonBounds(points) {
+    const xs = points.map((p) => p[0]);
+    const zs = points.map((p) => p[1]);
+    const minX = Math.min(...xs);
+    const maxX = Math.max(...xs);
+    const minZ = Math.min(...zs);
+    const maxZ = Math.max(...zs);
+    return {
+        minX,
+        maxX,
+        minZ,
+        maxZ,
+        width: maxX - minX,
+        depth: maxZ - minZ,
+        centerX: (minX + maxX) / 2,
+        centerZ: (minZ + maxZ) / 2,
+    };
+}
+export function pointInBoundsWithPadding(x, z, bounds, padding) {
+    return (x >= bounds.minX + padding &&
+        x <= bounds.maxX - padding &&
+        z >= bounds.minZ + padding &&
+        z <= bounds.maxZ - padding);
+}
+export function pointOnSegment(point, a, b, tolerance = 1e-6) {
+    const cross = (point[1] - a[1]) * (b[0] - a[0]) - (point[0] - a[0]) * (b[1] - a[1]);
+    if (Math.abs(cross) > tolerance)
+        return false;
+    const dot = (point[0] - a[0]) * (b[0] - a[0]) + (point[1] - a[1]) * (b[1] - a[1]);
+    if (dot < -tolerance)
+        return false;
+    const lenSq = (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2;
+    return dot <= lenSq + tolerance;
+}
+export function pointInPolygon(point, polygon, includeBoundary = true) {
+    if (polygon.length < 3)
+        return false;
+    let inside = false;
+    const [x, z] = point;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const a = polygon[i];
+        const b = polygon[j];
+        if (pointOnSegment(point, a, b))
+            return includeBoundary;
+        const intersects = a[1] > z !== b[1] > z && x < ((b[0] - a[0]) * (z - a[1])) / (b[1] - a[1]) + a[0];
+        if (intersects)
+            inside = !inside;
+    }
+    return inside;
+}
+export function polygonContainsPolygon(outer, inner) {
+    return inner.every((point) => pointInPolygon(point, outer, true));
+}

package/dist/tools/get-node.d.ts

@@ -0,0 +1,11 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const getNodeInput: {
+    id: z.ZodString;
+};
+export declare const getNodeOutput: {
+    node: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+};
+export declare function registerGetNode(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=get-node.d.ts.map

package/dist/tools/get-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-node.d.ts","sourceRoot":"","sources":["../../src/tools/get-node.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;AAIpD,eAAO,MAAM,YAAY;;CAExB,CAAA;AAED,eAAO,MAAM,aAAa;;CAEzB,CAAA;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAqBhF"}

package/dist/tools/get-node.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { ErrorCode, throwMcpError } from './errors';
+import { NodeIdSchema } from './schemas';
+export const getNodeInput = {
+    id: NodeIdSchema,
+};
+export const getNodeOutput = {
+    node: z.record(z.string(), z.unknown()),
+};
+export function registerGetNode(server, bridge) {
+    server.registerTool('get_node', {
+        title: 'Get node',
+        description: 'Return the full node payload for the given ID.',
+        inputSchema: getNodeInput,
+        outputSchema: getNodeOutput,
+    }, async ({ id }) => {
+        const node = bridge.getNode(id);
+        if (!node) {
+            throwMcpError(ErrorCode.InvalidParams, `Node not found: ${id}`);
+        }
+        const payload = { node: node };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

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

@@ -0,0 +1,11 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const getSceneInput: {};
+export declare const getSceneOutput: {
+    nodes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    rootNodeIds: z.ZodArray<z.ZodString>;
+    collections: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+};
+export declare function registerGetScene(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=get-scene.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-scene.d.ts","sourceRoot":"","sources":["../../src/tools/get-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD,eAAO,MAAM,aAAa,IAAK,CAAA;AAE/B,eAAO,MAAM,cAAc;;;;CAI1B,CAAA;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAuBjF"}

package/dist/tools/get-scene.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export const getSceneInput = {};
+export const getSceneOutput = {
+    nodes: z.record(z.string(), z.unknown()),
+    rootNodeIds: z.array(z.string()),
+    collections: z.record(z.string(), z.unknown()).optional(),
+};
+export function registerGetScene(server, bridge) {
+    server.registerTool('get_scene', {
+        title: 'Get scene',
+        description: 'Returns the full scene graph: flat node dictionary, root node IDs, and collections.',
+        inputSchema: getSceneInput,
+        outputSchema: getSceneOutput,
+    }, async () => {
+        const scene = bridge.exportJSON();
+        const payload = {
+            nodes: scene.nodes,
+            rootNodeIds: scene.rootNodeIds,
+            collections: (scene.collections ?? {}),
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,12 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SceneOperations } from '../operations';
+/**
+ * Register every non-vision MCP tool against the given server.
+ * Vision tools (analyze_floorplan_image, analyze_room_photo) are registered
+ * separately via `registerVisionTools` (Agent E).
+ *
+ * Scene-lifecycle tools (save/load/list/delete/rename scene) are registered
+ * when persistence operations are available.
+ */
+export declare function registerTools(server: McpServer, operations: SceneOperations): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AA4BpD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,GAAG,IAAI,CA6BlF"}

package/dist/tools/index.js

@@ -0,0 +1,64 @@
+import { registerApplyPatch } from './apply-patch';
+import { registerCheckCollisions } from './check-collisions';
+import { registerConstructionTools } from './construction-tools';
+import { registerCreateLevel } from './create-level';
+import { registerCreateWall } from './create-wall';
+import { registerCutOpening } from './cut-opening';
+import { registerDeleteNode } from './delete-node';
+import { registerDescribeNode } from './describe-node';
+import { registerDuplicateLevel } from './duplicate-level';
+import { registerExportGlb } from './export-glb';
+import { registerExportJson } from './export-json';
+import { registerFindNodes } from './find-nodes';
+import { registerGetNode } from './get-node';
+import { registerGetScene } from './get-scene';
+import { registerMeasure } from './measure';
+import { registerPhotoToSceneTool } from './photo-to-scene';
+import { registerPlaceItem } from './place-item';
+import { registerRedo } from './redo';
+import { registerRoomTools } from './room-tools';
+import { registerSceneLifecycleTools } from './scene-lifecycle';
+import { registerSceneQueryTools } from './scene-query';
+import { registerSetZone } from './set-zone';
+import { registerTemplateTools } from './templates';
+import { registerUndo } from './undo';
+import { registerValidateScene } from './validate-scene';
+import { registerVariantTools } from './variants';
+/**
+ * Register every non-vision MCP tool against the given server.
+ * Vision tools (analyze_floorplan_image, analyze_room_photo) are registered
+ * separately via `registerVisionTools` (Agent E).
+ *
+ * Scene-lifecycle tools (save/load/list/delete/rename scene) are registered
+ * when persistence operations are available.
+ */
+export function registerTools(server, operations) {
+    registerGetScene(server, operations);
+    registerGetNode(server, operations);
+    registerDescribeNode(server, operations);
+    registerFindNodes(server, operations);
+    registerSceneQueryTools(server, operations);
+    registerMeasure(server, operations);
+    registerConstructionTools(server, operations);
+    registerRoomTools(server, operations);
+    registerApplyPatch(server, operations);
+    registerCreateLevel(server, operations);
+    registerCreateWall(server, operations);
+    registerPlaceItem(server, operations);
+    registerCutOpening(server, operations);
+    registerSetZone(server, operations);
+    registerDuplicateLevel(server, operations);
+    registerDeleteNode(server, operations);
+    registerUndo(server, operations);
+    registerRedo(server, operations);
+    registerExportJson(server, operations);
+    registerExportGlb(server, operations);
+    registerValidateScene(server, operations);
+    registerCheckCollisions(server, operations);
+    registerTemplateTools(server, operations);
+    if (operations.hasStore) {
+        registerSceneLifecycleTools(server, operations);
+        registerVariantTools(server, operations);
+        registerPhotoToSceneTool(server, operations);
+    }
+}

package/dist/tools/live-sync.d.ts

@@ -0,0 +1,11 @@
+import type { SceneGraph } from '@pascal-app/core/clone-scene-graph';
+import type { SceneOperations } from '../operations';
+export declare function syncDerivedStairOpenings(operations: SceneOperations): number;
+/**
+ * Persist the bridge's current graph to the active scene and append a live
+ * event for browser subscribers. No-ops when the MCP session is not currently
+ * bound to a saved scene.
+ */
+export declare function publishLiveSceneSnapshot(operations: SceneOperations, kind: string): Promise<void>;
+export declare function appendLiveSceneEvent(operations: SceneOperations, sceneId: string, version: number, kind: string, graph: SceneGraph): Promise<void>;
+//# sourceMappingURL=live-sync.d.ts.map

package/dist/tools/live-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-sync.d.ts","sourceRoot":"","sources":["../../src/tools/live-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAA;AAEpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAIpD,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,eAAe,GAAG,MAAM,CAW5E;AAED;;;;GAIG;AACH,wBAAsB,wBAAwB,CAC5C,UAAU,EAAE,eAAe,EAC3B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAsCf;AAED,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,UAAU,GAChB,OAAO,CAAC,IAAI,CAAC,CAGf"}

package/dist/tools/live-sync.js

@@ -0,0 +1,62 @@
+import { syncAutoStairOpenings } from '@pascal-app/core/stair-openings';
+import { SceneVersionConflictError } from '../storage/types';
+import { ErrorCode, throwMcpError } from './errors';
+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;
+}
+/**
+ * Persist the bridge's current graph to the active scene and append a live
+ * event for browser subscribers. No-ops when the MCP session is not currently
+ * bound to a saved scene.
+ */
+export async function publishLiveSceneSnapshot(operations, kind) {
+    syncDerivedStairOpenings(operations);
+    const active = operations.getActiveScene();
+    if (!(active && operations.canAppendSceneEvents))
+        return;
+    const graph = operations.exportSceneGraph();
+    try {
+        const meta = await operations.saveScene({
+            id: active.id,
+            name: active.name,
+            projectId: active.projectId,
+            ownerId: active.ownerId,
+            thumbnailUrl: active.thumbnailUrl,
+            graph,
+            expectedVersion: active.version,
+            saveMode: 'draft',
+            publish: false,
+            operation: kind,
+        });
+        operations.setActiveScene(meta);
+        await operations.appendSceneEvent({
+            sceneId: meta.id,
+            version: meta.version,
+            kind,
+            graph,
+        });
+    }
+    catch (error) {
+        if (error instanceof SceneVersionConflictError) {
+            throwMcpError(ErrorCode.InvalidRequest, 'live_sync_version_conflict', {
+                sceneId: active.id,
+                expectedVersion: active.version,
+            });
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throwMcpError(ErrorCode.InternalError, `live_sync_failed: ${message}`);
+    }
+}
+export async function appendLiveSceneEvent(operations, sceneId, version, kind, graph) {
+    if (!operations.canAppendSceneEvents)
+        return;
+    await operations.appendSceneEvent({ sceneId, version, kind, graph });
+}

package/dist/tools/measure.d.ts

@@ -0,0 +1,14 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const measureInput: {
+    fromId: z.ZodString;
+    toId: z.ZodString;
+};
+export declare const measureOutput: {
+    distanceMeters: z.ZodNumber;
+    areaSqMeters: z.ZodOptional<z.ZodNumber>;
+    units: z.ZodLiteral<"meters">;
+};
+export declare function registerMeasure(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=measure.d.ts.map

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

@@ -0,0 +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;AAIpD,eAAO,MAAM,YAAY;;;CAGxB,CAAA;AAED,eAAO,MAAM,aAAa;;;;CAIzB,CAAA;AAsED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAmEhF"}

package/dist/tools/measure.js

@@ -0,0 +1,137 @@
+import { z } from 'zod';
+import { ErrorCode, throwMcpError } from './errors';
+import { NodeIdSchema } from './schemas';
+export const measureInput = {
+    fromId: NodeIdSchema,
+    toId: NodeIdSchema,
+};
+export const measureOutput = {
+    distanceMeters: z.number(),
+    areaSqMeters: z.number().optional(),
+    units: z.literal('meters'),
+};
+/**
+ * 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)
+        return 0;
+    let sum = 0;
+    const n = polygon.length;
+    for (let i = 0; i < n; i++) {
+        const [x1, z1] = polygon[i];
+        const [x2, z2] = polygon[(i + 1) % n];
+        sum += x1 * z2 - x2 * z1;
+    }
+    return Math.abs(sum) / 2;
+}
+export function registerMeasure(server, bridge) {
+    server.registerTool('measure', {
+        title: 'Measure',
+        description: 'Measure distance (in meters) between two nodes, or the area of a polygon node when fromId === toId.',
+        inputSchema: measureInput,
+        outputSchema: measureOutput,
+    }, async ({ fromId, toId }) => {
+        const from = bridge.getNode(fromId);
+        if (!from) {
+            throwMcpError(ErrorCode.InvalidParams, `Node not found: ${fromId}`);
+        }
+        const to = bridge.getNode(toId);
+        if (!to) {
+            throwMcpError(ErrorCode.InvalidParams, `Node not found: ${toId}`);
+        }
+        // Self-measurement: compute area for polygon-bearing nodes.
+        if (fromId === toId) {
+            const n = from;
+            if (n.type === 'zone' || n.type === 'slab' || n.type === 'ceiling') {
+                const area = shoelaceArea(n.polygon);
+                const payload = {
+                    distanceMeters: 0,
+                    areaSqMeters: area,
+                    units: 'meters',
+                };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(payload) }],
+                    structuredContent: payload,
+                };
+            }
+            // For non-polygon self, distance is 0 and no area.
+            const payload = { distanceMeters: 0, units: 'meters' };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(payload) }],
+                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 distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        const payload = {
+            distanceMeters: distance,
+            units: 'meters',
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

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

@@ -0,0 +1,11 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SceneOperations } from '../../operations';
+/**
+ * Register the `photo_to_scene` orchestrator tool. Chains the vision
+ * (`analyze_floorplan_image`-equivalent sampling call) → SceneGraph
+ * synthesis → optional scene save → bridge setScene so callers get a navigable
+ * Pascal scene from a single photo upload.
+ */
+export declare function registerPhotoToSceneTool(server: McpServer, bridge: SceneOperations): void;
+export { photoToSceneInput, photoToSceneOutput, registerPhotoToScene, } from './photo-to-scene';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/photo-to-scene/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAGvD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAEzF;AAED,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,kBAAkB,CAAA"}

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

@@ -0,0 +1,11 @@
+import { registerPhotoToScene } from './photo-to-scene';
+/**
+ * Register the `photo_to_scene` orchestrator tool. Chains the vision
+ * (`analyze_floorplan_image`-equivalent sampling call) → SceneGraph
+ * synthesis → optional scene save → bridge setScene so callers get a navigable
+ * Pascal scene from a single photo upload.
+ */
+export function registerPhotoToSceneTool(server, bridge) {
+    registerPhotoToScene(server, bridge);
+}
+export { photoToSceneInput, photoToSceneOutput, registerPhotoToScene, } from './photo-to-scene';

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

@@ -0,0 +1,26 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../../operations';
+/**
+ * Input shape for the `photo_to_scene` orchestrator. `image` matches the
+ * contract documented on `analyze_floorplan_image` — base64 or http(s) URL.
+ */
+export declare const photoToSceneInput: {
+    image: z.ZodString;
+    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>;
+};
+export declare const photoToSceneOutput: {
+    sceneId: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    walls: z.ZodNumber;
+    rooms: z.ZodNumber;
+    confidence: z.ZodNumber;
+    notes: z.ZodOptional<z.ZodString>;
+    graph: z.ZodOptional<z.ZodAny>;
+};
+export declare function registerPhotoToScene(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=photo-to-scene.d.ts.map

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

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