@pascal-app/mcp 0.2.0

package/dist/tools/undo.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { publishLiveSceneSnapshot } from './live-sync';
+export const undoInput = {
+    steps: z.number().int().positive().optional(),
+};
+export const undoOutput = {
+    undone: z.number(),
+};
+export function registerUndo(server, bridge) {
+    server.registerTool('undo', {
+        title: 'Undo',
+        description: 'Undo the most recent N steps in the scene history (default 1). Returns the number of steps actually undone.',
+        inputSchema: undoInput,
+        outputSchema: undoOutput,
+    }, async ({ steps }) => {
+        const undone = bridge.undo(steps ?? 1);
+        if (undone > 0)
+            await publishLiveSceneSnapshot(bridge, 'undo');
+        const payload = { undone };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/validate-scene.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 validateSceneInput: {};
+export declare const validateSceneOutput: {
+    valid: z.ZodBoolean;
+    errors: z.ZodArray<z.ZodObject<{
+        nodeId: z.ZodString;
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+};
+export declare function registerValidateScene(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=validate-scene.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate-scene.d.ts","sourceRoot":"","sources":["../../src/tools/validate-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD,eAAO,MAAM,kBAAkB,IAAK,CAAA;AAEpC,eAAO,MAAM,mBAAmB;;;;;;;CAS/B,CAAA;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAkBtF"}

package/dist/tools/validate-scene.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export const validateSceneInput = {};
+export const validateSceneOutput = {
+    valid: z.boolean(),
+    errors: z.array(z.object({
+        nodeId: z.string(),
+        path: z.string(),
+        message: z.string(),
+    })),
+};
+export function registerValidateScene(server, bridge) {
+    server.registerTool('validate_scene', {
+        title: 'Validate scene',
+        description: 'Run Zod validation against every node in the scene. Returns `{ valid, errors }` where each error has `{ nodeId, path, message }`.',
+        inputSchema: validateSceneInput,
+        outputSchema: validateSceneOutput,
+    }, async () => {
+        const result = bridge.validateScene();
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result) }],
+            structuredContent: result,
+        };
+    });
+}

package/dist/tools/variants/generate-variants.d.ts

@@ -0,0 +1,30 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../../operations';
+export declare const generateVariantsInput: {
+    baseSceneId: z.ZodOptional<z.ZodString>;
+    count: z.ZodDefault<z.ZodNumber>;
+    vary: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        "wall-thickness": "wall-thickness";
+        "wall-height": "wall-height";
+        "zone-labels": "zone-labels";
+        "room-proportions": "room-proportions";
+        "open-plan": "open-plan";
+        "door-positions": "door-positions";
+        "fence-style": "fence-style";
+    }>>>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    save: z.ZodDefault<z.ZodBoolean>;
+};
+export declare const generateVariantsOutput: {
+    variants: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        description: z.ZodString;
+        nodeCount: z.ZodNumber;
+        sceneId: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        graph: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>>;
+};
+export declare function registerGenerateVariants(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=generate-variants.d.ts.map

package/dist/tools/variants/generate-variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-variants.d.ts","sourceRoot":"","sources":["../../../src/tools/variants/generate-variants.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,kBAAkB,CAAA;AAcvD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;CAYjC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;CAWlC,CAAA;AAmDD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA4FzF"}

package/dist/tools/variants/generate-variants.js

@@ -0,0 +1,160 @@
+import { forkSceneGraph } from '@pascal-app/core/clone-scene-graph';
+import { AnyNode as AnyNodeSchema } from '@pascal-app/core/schema';
+import { z } from 'zod';
+import { ErrorCode, throwMcpError } from '../errors';
+import { applyMutation, describeVariant, mulberry32 } from './mutations';
+const MUTATION_KINDS = [
+    'wall-thickness',
+    'wall-height',
+    'zone-labels',
+    'room-proportions',
+    'open-plan',
+    'door-positions',
+    'fence-style',
+];
+export const generateVariantsInput = {
+    baseSceneId: z
+        .string()
+        .optional()
+        .describe('If set, fork from this saved scene; else fork from current bridge state.'),
+    count: z.number().int().min(1).max(10).default(3),
+    vary: z.array(z.enum(MUTATION_KINDS)).min(1).default(['wall-thickness', 'wall-height']),
+    seed: z.number().int().optional().describe('Deterministic RNG seed.'),
+    save: z
+        .boolean()
+        .default(false)
+        .describe('If true, also save each variant via SceneStore and return ids.'),
+};
+export const generateVariantsOutput = {
+    variants: z.array(z.object({
+        index: z.number(),
+        description: z.string(),
+        nodeCount: z.number(),
+        sceneId: z.string().optional(),
+        url: z.string().optional(),
+        graph: z.any().optional(),
+    })),
+};
+/**
+ * `forkSceneGraph` normalises `SiteNode.children` to string IDs, but the
+ * `SiteNode` schema declares that field as an array of full `BuildingNode` /
+ * `ItemNode` objects (see CROSS_CUTTING §2). To keep variants validating
+ * against `AnyNode`, re-embed the site children from the flat dict.
+ *
+ * Pure: returns a new graph without mutating the input.
+ */
+function rehydrateSiteChildren(graph) {
+    const out = {
+        nodes: { ...graph.nodes },
+        rootNodeIds: [...graph.rootNodeIds],
+        ...(graph.collections ? { collections: graph.collections } : {}),
+    };
+    for (const [id, node] of Object.entries(out.nodes)) {
+        if (node.type !== 'site')
+            continue;
+        const childrenField = node.children;
+        if (!Array.isArray(childrenField))
+            continue;
+        const rehydrated = [];
+        for (const child of childrenField) {
+            if (typeof child === 'string') {
+                const target = out.nodes[child];
+                if (target && (target.type === 'building' || target.type === 'item')) {
+                    rehydrated.push(target);
+                }
+            }
+            else if (child && typeof child === 'object' && 'id' in child) {
+                rehydrated.push(child);
+            }
+        }
+        out.nodes[id] = {
+            ...node,
+            children: rehydrated,
+        };
+    }
+    return out;
+}
+/**
+ * Count how many nodes in a graph fail `AnyNode` validation. Used to keep the
+ * tool from returning silently corrupt variants.
+ */
+function countInvalidNodes(graph) {
+    let invalid = 0;
+    for (const node of Object.values(graph.nodes)) {
+        if (!AnyNodeSchema.safeParse(node).success)
+            invalid++;
+    }
+    return invalid;
+}
+export function registerGenerateVariants(server, bridge) {
+    server.registerTool('generate_variants', {
+        title: 'Generate variants',
+        description: 'Generate N variations of a base scene by forking and applying seeded mutations. Example: "give me 5 variations of this kitchen". If `save=true`, each variant is persisted via scene operations and returned with an id + URL; otherwise the graph is returned inline.',
+        inputSchema: generateVariantsInput,
+        outputSchema: generateVariantsOutput,
+    }, async ({ baseSceneId, count, vary, seed, save }) => {
+        // 1. Obtain the base SceneGraph.
+        let base;
+        let baseName = 'scene';
+        if (baseSceneId) {
+            const loaded = await bridge.loadStoredScene(baseSceneId);
+            if (!loaded) {
+                throwMcpError(ErrorCode.InvalidParams, 'scene_not_found', { id: baseSceneId });
+            }
+            base = loaded.graph;
+            baseName = loaded.name;
+        }
+        else {
+            base = bridge.exportSceneGraph();
+        }
+        // 2. Seed the RNG. Default seed is a time-ish number so runs vary, but
+        //    tests always pass a fixed seed for determinism.
+        const initialSeed = seed ?? Math.floor(Math.random() * 0xff_ff_ff_ff);
+        const mutations = vary;
+        const variants = [];
+        for (let i = 0; i < count; i++) {
+            // Each variant gets its own RNG stream derived from (seed + i) so
+            // results are deterministic per-index.
+            const rng = mulberry32(initialSeed + i);
+            let forked = forkSceneGraph(base);
+            for (const kind of mutations) {
+                forked = applyMutation(forked, rng, kind);
+            }
+            // Re-embed site children so variants match the SiteNode schema.
+            forked = rehydrateSiteChildren(forked);
+            const invalidCount = countInvalidNodes(forked);
+            if (invalidCount > 0) {
+                throwMcpError(ErrorCode.InternalError, `variant_invalid: variant ${i} produced ${invalidCount} invalid node(s)`, { index: i });
+            }
+            const nodeCount = Object.keys(forked.nodes).length;
+            const description = describeVariant(forked, mutations);
+            if (save) {
+                try {
+                    const meta = await bridge.saveScene({
+                        name: `${baseName}-variant-${i + 1}`,
+                        graph: forked,
+                    });
+                    variants.push({
+                        index: i,
+                        description,
+                        nodeCount,
+                        sceneId: meta.id,
+                        url: `/scene/${meta.id}`,
+                    });
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    throwMcpError(ErrorCode.InternalError, `save_failed: ${msg}`, { index: i });
+                }
+            }
+            else {
+                variants.push({ index: i, description, nodeCount, graph: forked });
+            }
+        }
+        const payload = { variants };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

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

@@ -0,0 +1,9 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SceneOperations } from '../../operations';
+/**
+ * Register the variant-generation MCP tools against shared scene operations.
+ */
+export declare function registerVariantTools(server: McpServer, bridge: SceneOperations): void;
+export { generateVariantsInput, generateVariantsOutput, registerGenerateVariants, } from './generate-variants';
+export { applyMutation, describeVariant, type MutationKind, mulberry32, type Rng, } from './mutations';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/variants/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAGvD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAErF;AAED,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EACL,aAAa,EACb,eAAe,EACf,KAAK,YAAY,EACjB,UAAU,EACV,KAAK,GAAG,GACT,MAAM,aAAa,CAAA"}

package/dist/tools/variants/index.js

@@ -0,0 +1,9 @@
+import { registerGenerateVariants } from './generate-variants';
+/**
+ * Register the variant-generation MCP tools against shared scene operations.
+ */
+export function registerVariantTools(server, bridge) {
+    registerGenerateVariants(server, bridge);
+}
+export { generateVariantsInput, generateVariantsOutput, registerGenerateVariants, } from './generate-variants';
+export { applyMutation, describeVariant, mulberry32, } from './mutations';

package/dist/tools/variants/mutations.d.ts

@@ -0,0 +1,18 @@
+import type { SceneGraph } from '@pascal-app/core/clone-scene-graph';
+/** Mutation kinds handled by `applyMutation`. */
+export type MutationKind = 'wall-thickness' | 'wall-height' | 'zone-labels' | 'room-proportions' | 'open-plan' | 'door-positions' | 'fence-style';
+/** Deterministic seeded RNG. */
+export type Rng = () => number;
+/**
+ * Tiny Park-Miller PRNG. Returns a function that produces uniformly
+ * distributed floats in [0, 1) without bitwise operators.
+ */
+export declare function mulberry32(seed: number): Rng;
+/** Pure: apply a single mutation and return a fresh graph. */
+export declare function applyMutation(graph: SceneGraph, rng: Rng, kind: MutationKind): SceneGraph;
+/**
+ * Human-readable summary of the mutations applied to a variant. Reads the
+ * interesting fields from the graph (e.g. first wall's thickness/height).
+ */
+export declare function describeVariant(graph: SceneGraph, mutations: readonly MutationKind[]): string;
+//# sourceMappingURL=mutations.d.ts.map

package/dist/tools/variants/mutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutations.d.ts","sourceRoot":"","sources":["../../../src/tools/variants/mutations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAA;AAGpE,iDAAiD;AACjD,MAAM,MAAM,YAAY,GACpB,gBAAgB,GAChB,aAAa,GACb,aAAa,GACb,kBAAkB,GAClB,WAAW,GACX,gBAAgB,GAChB,aAAa,CAAA;AAEjB,gCAAgC;AAChC,MAAM,MAAM,GAAG,GAAG,MAAM,MAAM,CAAA;AAE9B;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAO5C;AA0OD,8DAA8D;AAC9D,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,YAAY,GAAG,UAAU,CAiBzF;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,YAAY,EAAE,GAAG,MAAM,CAyB7F"}

package/dist/tools/variants/mutations.js

@@ -0,0 +1,324 @@
+/**
+ * Tiny Park-Miller PRNG. Returns a function that produces uniformly
+ * distributed floats in [0, 1) without bitwise operators.
+ */
+export function mulberry32(seed) {
+    let state = Math.trunc(Math.abs(seed)) % 2_147_483_647;
+    if (state === 0)
+        state = 1;
+    return () => {
+        state = (state * 16_807) % 2_147_483_647;
+        return (state - 1) / 2_147_483_646;
+    };
+}
+/** Pick a random element from a non-empty array. */
+function pickFrom(rng, values) {
+    const idx = Math.floor(rng() * values.length);
+    return values[Math.min(idx, values.length - 1)];
+}
+/** Shallow clone a scene graph: nodes are copied one level deep, node dict is fresh. */
+function cloneGraph(graph) {
+    const clonedNodes = {};
+    for (const [id, node] of Object.entries(graph.nodes)) {
+        // structuredClone so sub-objects (arrays, tuples, metadata) are independent.
+        clonedNodes[id] = structuredClone(node);
+    }
+    return {
+        nodes: clonedNodes,
+        rootNodeIds: [...graph.rootNodeIds],
+        ...(graph.collections ? { collections: structuredClone(graph.collections) } : {}),
+    };
+}
+const WALL_THICKNESS_OPTIONS = [0.1, 0.15, 0.2, 0.25];
+const WALL_HEIGHT_OPTIONS = [2.4, 2.6, 2.7, 3.0];
+const FENCE_STYLES = ['privacy', 'slat', 'rail'];
+/** Fisher–Yates shuffle in place using the provided RNG. */
+function shuffleInPlace(arr, rng) {
+    for (let i = arr.length - 1; i > 0; i--) {
+        const j = Math.floor(rng() * (i + 1));
+        const tmp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = tmp;
+    }
+}
+/**
+ * Compute 2D bounds (min/max x/z) of the first `site` node's polygon points,
+ * or `null` if no site is present.
+ */
+function siteBounds(graph) {
+    for (const node of Object.values(graph.nodes)) {
+        if (node.type !== 'site')
+            continue;
+        const pts = node.polygon?.points;
+        if (!pts || pts.length === 0)
+            continue;
+        let minX = Number.POSITIVE_INFINITY;
+        let maxX = Number.NEGATIVE_INFINITY;
+        let minZ = Number.POSITIVE_INFINITY;
+        let maxZ = Number.NEGATIVE_INFINITY;
+        for (const [x, z] of pts) {
+            if (x < minX)
+                minX = x;
+            if (x > maxX)
+                maxX = x;
+            if (z < minZ)
+                minZ = z;
+            if (z > maxZ)
+                maxZ = z;
+        }
+        if (!Number.isFinite(minX))
+            continue;
+        return { minX, maxX, minZ, maxZ };
+    }
+    return null;
+}
+/**
+ * Heuristic: a wall is a perimeter wall if either of its endpoints sits close
+ * to the site polygon's bounding rectangle (within `epsilon`). Returns `false`
+ * if there is no site polygon (treat everything as interior so the mutations
+ * still exercise something on partial scenes).
+ */
+function isPerimeterWall(wall, bounds, epsilon = 0.01) {
+    if (!(bounds && wall.start && wall.end))
+        return false;
+    const onBound = (x, z) => Math.abs(x - bounds.minX) <= epsilon ||
+        Math.abs(x - bounds.maxX) <= epsilon ||
+        Math.abs(z - bounds.minZ) <= epsilon ||
+        Math.abs(z - bounds.maxZ) <= epsilon;
+    const [sx, sz] = wall.start;
+    const [ex, ez] = wall.end;
+    return onBound(sx, sz) || onBound(ex, ez);
+}
+function applyWallThickness(graph, rng) {
+    const out = cloneGraph(graph);
+    for (const node of Object.values(out.nodes)) {
+        if (node.type !== 'wall')
+            continue;
+        node.thickness = pickFrom(rng, WALL_THICKNESS_OPTIONS);
+    }
+    return out;
+}
+function applyWallHeight(graph, rng) {
+    const out = cloneGraph(graph);
+    for (const node of Object.values(out.nodes)) {
+        if (node.type !== 'wall')
+            continue;
+        node.height = pickFrom(rng, WALL_HEIGHT_OPTIONS);
+    }
+    return out;
+}
+function applyZoneLabels(graph, rng) {
+    const out = cloneGraph(graph);
+    const zoneNodes = [];
+    for (const node of Object.values(out.nodes)) {
+        if (node.type === 'zone')
+            zoneNodes.push(node);
+    }
+    if (zoneNodes.length < 2)
+        return out;
+    const labels = zoneNodes.map((z) => z.name ?? '');
+    shuffleInPlace(labels, rng);
+    for (let i = 0; i < zoneNodes.length; i++) {
+        ;
+        zoneNodes[i].name = labels[i];
+    }
+    return out;
+}
+function applyRoomProportions(graph, rng) {
+    const out = cloneGraph(graph);
+    const bounds = siteBounds(out);
+    for (const node of Object.values(out.nodes)) {
+        if (node.type !== 'wall')
+            continue;
+        const wall = node;
+        if (!(wall.start && wall.end))
+            continue;
+        if (isPerimeterWall(wall, bounds))
+            continue;
+        // Nudge each endpoint by ±10% of its current value.
+        const nudge = (v) => v * (1 + (rng() * 2 - 1) * 0.1);
+        const clampX = (v) => bounds ? Math.min(bounds.maxX, Math.max(bounds.minX, v)) : v;
+        const clampZ = (v) => bounds ? Math.min(bounds.maxZ, Math.max(bounds.minZ, v)) : v;
+        const [sx, sz] = wall.start;
+        const [ex, ez] = wall.end;
+        wall.start = [clampX(nudge(sx)), clampZ(nudge(sz))];
+        wall.end = [clampX(nudge(ex)), clampZ(nudge(ez))];
+    }
+    return out;
+}
+function applyOpenPlan(graph, rng) {
+    const out = cloneGraph(graph);
+    const bounds = siteBounds(out);
+    const interiorWallIds = [];
+    for (const [id, node] of Object.entries(out.nodes)) {
+        if (node.type !== 'wall')
+            continue;
+        if (isPerimeterWall(node, bounds))
+            continue;
+        interiorWallIds.push(id);
+    }
+    if (interiorWallIds.length === 0)
+        return out;
+    const targetId = interiorWallIds[Math.floor(rng() * interiorWallIds.length)];
+    // Collect any openings attached to this wall so we can drop them too.
+    const attached = [];
+    for (const [attId, node] of Object.entries(out.nodes)) {
+        if (node.wallId === targetId)
+            attached.push(attId);
+    }
+    const removal = new Set([targetId, ...attached]);
+    // Drop from nodes.
+    for (const id of removal)
+        delete out.nodes[id];
+    // Drop from rootNodeIds (unlikely for walls, but consistent).
+    out.rootNodeIds = out.rootNodeIds.filter((id) => !removal.has(id));
+    // Drop references from any parent's `children` array.
+    for (const parent of Object.values(out.nodes)) {
+        if (!('children' in parent && Array.isArray(parent.children))) {
+            continue;
+        }
+        const children = parent.children;
+        parent.children = children.filter((child) => {
+            if (typeof child === 'string')
+                return !removal.has(child);
+            if (child && typeof child === 'object' && 'id' in child) {
+                return !removal.has(child.id);
+            }
+            return true;
+        });
+    }
+    return out;
+}
+function applyDoorPositions(graph, rng) {
+    const out = cloneGraph(graph);
+    // Group doors by their parent wall so we can space them out and skip collisions.
+    const doorsByWall = new Map();
+    for (const node of Object.values(out.nodes)) {
+        if (node.type !== 'door')
+            continue;
+        const wallId = node.wallId;
+        if (!wallId)
+            continue;
+        let list = doorsByWall.get(wallId);
+        if (!list) {
+            list = [];
+            doorsByWall.set(wallId, list);
+        }
+        list.push(node);
+    }
+    for (const [, doors] of doorsByWall) {
+        // Minimum separation along the parametric wall axis — rough keep-away to
+        // avoid obvious overlaps.
+        const minGap = 0.15;
+        const usedTs = [];
+        for (const door of doors) {
+            let attempts = 0;
+            let t = 0.5;
+            while (attempts < 8) {
+                t = 0.2 + rng() * 0.6; // [0.2, 0.8]
+                const collides = usedTs.some((u) => Math.abs(u - t) < minGap);
+                if (!collides)
+                    break;
+                attempts++;
+            }
+            // If we still collide after 8 attempts, skip this door (leave it alone).
+            if (usedTs.some((u) => Math.abs(u - t) < minGap))
+                continue;
+            usedTs.push(t);
+            door.wallT = t;
+        }
+    }
+    return out;
+}
+function applyFenceStyle(graph, rng) {
+    const out = cloneGraph(graph);
+    let i = 0;
+    for (const node of Object.values(out.nodes)) {
+        if (node.type !== 'fence')
+            continue;
+        // Use rng to choose a rotation offset so each call can produce a different
+        // starting point even when called multiple times with the same base.
+        const offset = Math.floor(rng() * FENCE_STYLES.length);
+        const style = FENCE_STYLES[(i + offset) % FENCE_STYLES.length];
+        node.style = style;
+        i++;
+    }
+    return out;
+}
+/** Pure: apply a single mutation and return a fresh graph. */
+export function applyMutation(graph, rng, kind) {
+    switch (kind) {
+        case 'wall-thickness':
+            return applyWallThickness(graph, rng);
+        case 'wall-height':
+            return applyWallHeight(graph, rng);
+        case 'zone-labels':
+            return applyZoneLabels(graph, rng);
+        case 'room-proportions':
+            return applyRoomProportions(graph, rng);
+        case 'open-plan':
+            return applyOpenPlan(graph, rng);
+        case 'door-positions':
+            return applyDoorPositions(graph, rng);
+        case 'fence-style':
+            return applyFenceStyle(graph, rng);
+    }
+}
+/**
+ * Human-readable summary of the mutations applied to a variant. Reads the
+ * interesting fields from the graph (e.g. first wall's thickness/height).
+ */
+export function describeVariant(graph, mutations) {
+    const parts = [];
+    if (mutations.includes('wall-thickness')) {
+        const t = firstWallField(graph, 'thickness');
+        if (t !== null)
+            parts.push(`wall thickness ${t}m`);
+    }
+    if (mutations.includes('wall-height')) {
+        const h = firstWallField(graph, 'height');
+        if (h !== null)
+            parts.push(`wall height ${h}m`);
+    }
+    if (mutations.includes('zone-labels')) {
+        const names = [];
+        for (const node of Object.values(graph.nodes)) {
+            if (node.type === 'zone')
+                names.push(node.name ?? '');
+        }
+        if (names.length > 0)
+            parts.push(`zones [${names.join(', ')}]`);
+    }
+    if (mutations.includes('room-proportions'))
+        parts.push('room proportions nudged');
+    if (mutations.includes('open-plan'))
+        parts.push('open-plan');
+    if (mutations.includes('door-positions'))
+        parts.push('doors repositioned');
+    if (mutations.includes('fence-style')) {
+        const s = firstFenceField(graph, 'style');
+        if (s !== null)
+            parts.push(`fence style ${s}`);
+    }
+    return parts.length > 0 ? parts.join(', ') : 'no-op';
+}
+function firstWallField(graph, field) {
+    for (const node of Object.values(graph.nodes)) {
+        if (node.type !== 'wall')
+            continue;
+        const v = node[field];
+        if (typeof v === 'number')
+            return v;
+    }
+    return null;
+}
+function firstFenceField(graph, field) {
+    for (const node of Object.values(graph.nodes)) {
+        if (node.type !== 'fence')
+            continue;
+        const v = node[field];
+        if (typeof v === 'string')
+            return v;
+    }
+    return null;
+}

package/dist/tools/vision/analyze-floorplan-image.d.ts

@@ -0,0 +1,33 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../../operations';
+/**
+ * Input shape for `analyze_floorplan_image`.
+ *
+ * `image` is either a base64-encoded payload (optionally prefixed with a
+ * `data:image/<mime>;base64,` URL) or an `http(s)` URL which we fetch and
+ * inline as base64 before forwarding to the MCP host via sampling.
+ */
+export declare const analyzeFloorplanImageInput: {
+    image: z.ZodString;
+    scaleHint: z.ZodOptional<z.ZodString>;
+};
+export declare const analyzeFloorplanImageOutput: {
+    walls: z.ZodArray<z.ZodObject<{
+        start: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        end: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        thickness: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    rooms: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        approximateAreaSqM: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    approximateDimensions: z.ZodObject<{
+        widthM: z.ZodNumber;
+        depthM: z.ZodNumber;
+    }, z.core.$strip>;
+    confidence: z.ZodNumber;
+};
+export declare function registerAnalyzeFloorplanImage(server: McpServer, _bridge: SceneOperations): void;
+//# sourceMappingURL=analyze-floorplan-image.d.ts.map

package/dist/tools/vision/analyze-floorplan-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-floorplan-image.d.ts","sourceRoot":"","sources":["../../../src/tools/vision/analyze-floorplan-image.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,kBAAkB,CAAA;AAEvD;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;;CAMtC,CAAA;AAED,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;CAoBvC,CAAA;AAgFD,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAiE/F"}