@pascal-app/mcp 1.0.4 → 1.0.6

package/dist/transports/stdio.js

@@ -1,16 +1,23 @@
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { serveStdio, } from '@modelcontextprotocol/server/stdio';
 /**
- * Attach an `McpServer` to the stdio transport.
+ * Serve Pascal over stdio from a server factory.
  *
- * The server takes ownership of stdin/stdout for JSON-RPC messaging. Callers
- * must send any operator logging to stderr (not stdout) to avoid corrupting
- * the protocol stream.
+ * The SDK negotiates the protocol era per connection: a client that opens with
+ * the 2025 `initialize` handshake and one that opens with the 2026-07-28
+ * `server/discover` probe are both served. A server handed to
+ * `StdioServerTransport` directly would answer only the first. The factory can
+ * be called twice on one connection (a discarded probe instance, then the
+ * instance that serves it), so it must build a fresh, unconnected server each
+ * time.
  *
- * Resolves once the transport is started. The underlying transport keeps the
- * process alive as long as stdin is open, so callers typically just `await`
- * this and then let the event loop run.
+ * The connection owns stdin/stdout for JSON-RPC messaging. Callers must send
+ * any operator logging to stderr (not stdout) to avoid corrupting the protocol
+ * stream. The process stays alive while stdin is open; the connection tears
+ * itself down when stdin reaches end-of-file.
  */
-export async function connectStdio(server) {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
+export function connectStdio(createServer, options = {}) {
+    return serveStdio(createServer, {
+        onerror: (error) => console.error('[pascal-mcp] stdio transport error', error),
+        ...options,
+    });
 }

package/examples/coordinate-conventions-demo.md

@@ -19,43 +19,42 @@ A flat ground level with four demos, plus a labelled compass at the
 origin so the world axes are unambiguous regardless of which viewport
 you're in.
 
-| Section | What | Why |
-|---|---|---|
-| Reference compass at the origin | 12 m `+X` and `+Z` axis bars with arrowhead tips, short `-X` / `-Z` stubs, an origin marker, plus zone labels naming each component of `[x, z]`. | Establishes which way `+X` and `+Z` actually point in world space, independent of viewport rotation. |
-| **Demo A** at world `(18, 0)` | Axis-aligned 6 m × 4 m rectangle. | Baseline that matches the only example currently in `examples/generate-apartment.md` style (`[0,0] → [10,0]`). |
-| **Demo B** at world `(18, 10)` | The proposed README example, **verbatim**: `polygon: [[0,0],[5.196,3.0],[3.196,6.464],[-2.0,3.464]]` at this offset. | Programmatically verified to be a 6 m × 4 m rectangle whose first edge is heading 30° CCW from `+X` (side lengths 6/4/6/4 m to 4 dp, `AB · AD = 0`, heading = 30.0007°). Confirms the README's worked example produces the geometry it claims. |
-| **Demo C** at world `(0, 22)` and `(10, 22)` | An **L** authored on a north-up page (page-+x right, page-+y up) drawn at half scale and faded; alongside it, the same L pasted into `[x, z]` **uncorrected**, drawn at full scale and vivid. | Makes the external-coordinate gotcha visual: the author's page-+y direction lands on world +Z, which does not correspond to "screen-up" in any of Pascal's viewports. |
-| **Demo D** at world `(22, 22)` and `(32, 22)` | Same pairing for the L with its second coordinate reflected (`z → 5 − z`) before paste. | Makes plain that z-reflection only "corrects" a true mirror; Pascal's viewports apply a *rotation*, so the reflection produces a mirror-image of Demo C rather than a page-correct L. |
-| Takeaway band on the south edge | Short labels summarising the convention. | Self-documenting; readable in any viewport without an external README. |
+| Section                                       | What                                                                                                                                                                                          | Why                                                                                                                                                                                                                                            |
+| --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Reference compass at the origin               | 12 m `+X` and `+Z` axis bars with arrowhead tips, short `-X` / `-Z` stubs, an origin marker, plus zone labels naming each component of `[x, z]`.                                              | Establishes which way `+X` and `+Z` actually point in world space, independent of viewport rotation.                                                                                                                                           |
+| **Demo A** at world `(18, 0)`                 | Axis-aligned 6 m × 4 m rectangle.                                                                                                                                                             | Baseline that matches the only example currently in `examples/generate-apartment.md` style (`[0,0] → [10,0]`).                                                                                                                                 |
+| **Demo B** at world `(18, 10)`                | The proposed README example, **verbatim**: `polygon: [[0,0],[5.196,3.0],[3.196,6.464],[-2.0,3.464]]` at this offset.                                                                          | Programmatically verified to be a 6 m × 4 m rectangle whose first edge is heading 30° CCW from `+X` (side lengths 6/4/6/4 m to 4 dp, `AB · AD = 0`, heading = 30.0007°). Confirms the README's worked example produces the geometry it claims. |
+| **Demo C** at world `(0, 22)` and `(10, 22)`  | An **L** authored on a north-up page (page-+x right, page-+y up) drawn at half scale and faded; alongside it, the same L pasted into `[x, z]` **uncorrected**, drawn at full scale and vivid. | Makes the external-coordinate gotcha visual: the author's page-+y direction lands on world +Z, which does not correspond to "screen-up" in any of Pascal's viewports.                                                                          |
+| **Demo D** at world `(22, 22)` and `(32, 22)` | Same pairing for the L with its second coordinate reflected (`z → 5 − z`) before paste.                                                                                                       | Makes plain that z-reflection only "corrects" a true mirror; Pascal's viewports apply a _rotation_, so the reflection produces a mirror-image of Demo C rather than a page-correct L.                                                          |
+| Takeaway band on the south edge               | Short labels summarising the convention.                                                                                                                                                      | Self-documenting; readable in any viewport without an external README.                                                                                                                                                                         |
 
 ## What it confirms
 
 Open the scene in Pascal (or render it from the JSON) and you can read
 each claim directly off the geometry:
-
 1. **`[x, z] → world (x, 0, z)` is exact, no sign flip.** Demo A and
    Demo B both sit flat on the floor at Y = 0; their polygon vertices
    round-trip through `save_scene` / `get_scene` byte-identical to what
-   was authored (graph hash matches, see `validate_scene` output).
+   was authored (graph hash matches, see `save_scene` output).
 
 2. **Demo B is the rectangle the README says it is.** A simple analytic
    check on its 4 vertices yields side lengths 6, 4, 6, 4 m (to 4 dp)
    with the first edge at 30.0007° from +X and perpendicular adjacent
    edges. No rendering required.
 
-3. **External page coordinates *rotate* (not mirror) when pasted as
+3. **External page coordinates _rotate_ (not mirror) when pasted as
    `[x, z]` and viewed in Pascal.** Inspecting Demo C in the 2-D plan
    panel: the page-up L lands rotated 90° clockwise, so the author's
    "stem-up, foot-bottom-right" reads as "stem-on-right, foot-along-top"
    on screen. Inspecting Demo D right next to it: the z-reflected
-   variant lands as the *mirror* of Demo C — neither matches a
+   variant lands as the _mirror_ of Demo C — neither matches a
    page-correct L. That demonstrates why "reflect across the axis" is
    the wrong corrective for an issue that is, in this viewport, a
    rotation.
 
 4. **The 3-D "top-down" snap is offset 45° from world axes by default.**
    Viewing the scene in 3-D and snapping to top-down from the default
-   iso camera shows the rectangular site polygon as a *diamond* (its
+   iso camera shows the rectangular site polygon as a _diamond_ (its
    long edges are diagonals on screen, not axis-aligned). That's the
    camera's "up" vector being inherited from the iso start; once you
    orbit to a true axis-aligned top-down it goes away. The label

package/examples/embed-in-agent.ts

@@ -10,8 +10,7 @@
  *   bun run packages/mcp/examples/embed-in-agent.ts
  */
 
-import { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js'
+import { Client, InMemoryTransport } from '@modelcontextprotocol/client'
 import { createPascalMcpServer, SceneBridge } from '@pascal-app/mcp'
 
 async function main(): Promise<void> {
@@ -40,10 +39,10 @@ async function main(): Promise<void> {
 
   // 5. Find the default level, create a 5 m wall, and undo it.
   const levels = await client.callTool({
-    name: 'find_nodes',
+    name: 'find_by_type',
     arguments: { type: 'level' },
   })
-  const levelId = (levels.structuredContent as { nodes: Array<{ id: string }> }).nodes[0]?.id
+  const levelId = (levels.structuredContent as { results: Array<{ id: string }> }).results[0]?.id
 
   if (levelId) {
     const created = await client.callTool({
@@ -63,8 +62,8 @@ async function main(): Promise<void> {
   }
 
   // 6. Validate and export.
-  const validation = await client.callTool({ name: 'validate_scene', arguments: {} })
-  console.log('validation:', validation.structuredContent)
+  const verification = await client.callTool({ name: 'verify_scene', arguments: {} })
+  console.log('verification:', verification.structuredContent)
 
   const exported = await client.callTool({
     name: 'export_json',

package/examples/generate-apartment.md

@@ -193,14 +193,14 @@ more windows on the east façade.
 ### 6. Validate and report
 
 ```jsonc
-// tool: validate_scene
-{ "name": "validate_scene", "arguments": {} }
+// tool: verify_scene
+{ "name": "verify_scene", "arguments": {} }
 ```
 
 Response:
 
 ```jsonc
-{ "valid": true, "errors": [] }
+{ "valid": true, "issues": [], "hasIssues": false, … }
 ```
 
 The agent then reads the scene summary for its response to the user:
@@ -235,6 +235,6 @@ Zustand store, the user can `undo` the change if they dislike it:
 - Mutations batch inside a single `apply_patch` so that `undo` rolls back
   the whole logical change.
 - Zones are not walls — they're polygon annotations that make later queries
-  (`find_nodes({ zoneId })`) and planning steps much easier for the agent.
+  (`find_by_type({ zoneId })`) and planning steps much easier for the agent.
 - The agent never needs to speak to `@pascal-app/viewer`: everything the
   host sees flows through tools + resources + prompts.

package/examples/photo-to-scene.md

@@ -33,7 +33,6 @@ The agent reads the attachment as a data URI and issues a single tool call:
 ```
 
 Optional knobs:
-
 - `save` (default `true`) — if `false`, the response includes `graph`
   inline instead of persisting to the `SceneStore`.
 - `defaultWallThickness` (default `0.2` m) — used when the vision model
@@ -56,7 +55,7 @@ Optional knobs:
    re-parsed with `AnyNode.safeParse`; invalid ones are dropped with a
    warning appended to `notes`.
 4. `bridge.setScene(...)` swaps the live scene so any follow-up MCP call
-   (`find_nodes`, `measure`, `apply_patch`, ...) operates on the new
+   (`find_by_type`, `measure`, `apply_patch`, ...) operates on the new
    geometry.
 5. If `save: true`, the graph is persisted via `SceneStore.save` and the
    response carries `sceneId` + `url: /scene/<id>`.
@@ -109,7 +108,7 @@ operate on it without reloading:
 
 > **User:** add a door on the south wall between Living and Kitchen.
 
-The agent calls `find_nodes({ type: "wall" })`, picks the appropriate
+The agent calls `find_by_type({ type: "wall" })`, picks the appropriate
 wall, and issues `add_door` — no extra wiring needed.
 
 ## Takeaways

package/examples/renovate-from-photos.md

@@ -12,7 +12,6 @@ tools to propose a renovation plan grounded in real photos.
 ## The brief
 
 The user drops four photos into the chat:
-
 1. A floorplan PDF page (exported as PNG).
 2. A photo of the current living room.
 3. A photo of the current kitchen.
@@ -148,7 +147,6 @@ against the corresponding perimeter wall:
 
 Guided by the reference photo's analysis (bright neutrals, open plan,
 minimal furnishing), the agent proposes a single logical patch:
-
 - Remove the partition wall between Living and Kitchen.
 - Relocate the kitchen island further west.
 - Delete the bulky TV unit item; leave the sofa and coffee table.
@@ -177,9 +175,9 @@ The user can walk back with `undo`; `redo` returns them to the proposal.
 ### 6. Sanity-check
 
 ```jsonc
-// tool: validate_scene
-{ "name": "validate_scene", "arguments": {} }
-// → { "valid": true, "errors": [] }
+// tool: verify_scene
+{ "name": "verify_scene", "arguments": {} }
+// → { "valid": true, "issues": [], "hasIssues": false, … }
 
 // tool: check_collisions
 { "name": "check_collisions", "arguments": { "levelId": "level-1" } }

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@pascal-app/mcp",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Model Context Protocol server for Pascal 3D editor",
+  "mcpName": "app.pascal/editor",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -61,19 +62,22 @@
     "prepublishOnly": "bun run build && bun test && bun run smoke:node"
   },
   "peerDependencies": {
-    "@pascal-app/core": "^1.0.4"
+    "@pascal-app/core": "^1.0.6"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "@pascal-app/geometry-script": "^1.0.4",
-    "@pascal-app/lingo": "^0.2.0",
-    "zod": ">=4.5.4 <4.6"
+    "@hono/node-server": "^1.19.15",
+    "@modelcontextprotocol/node": "^2.1.1",
+    "@modelcontextprotocol/server": "^2.3.1",
+    "@pascal-app/geometry-script": "^1.0.6",
+    "@pascal-app/lingo": "^0.5.0",
+    "zod": ">=4.6.7 <4.7"
   },
   "devDependencies": {
-    "@pascal-app/core": "^1.0.4",
+    "@modelcontextprotocol/client": "^2.3.1",
+    "@pascal-app/core": "^1.0.6",
     "@pascal/typescript-config": "*",
-    "@types/node": "^22.19.20",
-    "typescript": "6.0.3"
+    "@types/node": "^26.6.5",
+    "typescript": "7.0.2"
   },
   "keywords": [
     "mcp",

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

@@ -1,17 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import type { SceneOperations } from '../operations/index.js';
-export declare const describeNodeInput: {
-    id: z.ZodString;
-};
-export declare const describeNodeOutput: {
-    id: z.ZodString;
-    type: z.ZodString;
-    parentId: z.ZodNullable<z.ZodString>;
-    ancestryIds: z.ZodArray<z.ZodString>;
-    childrenIds: z.ZodArray<z.ZodString>;
-    properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    description: z.ZodString;
-};
-export declare function registerDescribeNode(server: McpServer, bridge: SceneOperations): void;
-//# sourceMappingURL=describe-node.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"describe-node.d.ts","sourceRoot":"","sources":["../../src/tools/describe-node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAIxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD,eAAO,MAAM,iBAAiB;;CAE7B,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;CAQ9B,CAAA;AA4CD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAiDrF"}

package/dist/tools/describe-node.js

@@ -1,99 +0,0 @@
-import { floorFootprintName, getLevelDisplayName, resolveCeilingHeight } from '@pascal-app/core';
-import { wallResolvedHeight } from '@pascal-app/core/agent-operations';
-import { z } from 'zod';
-import { READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
-import { ErrorCode, throwMcpError } from './errors.js';
-import { NodeIdSchema } from './schemas.js';
-export const describeNodeInput = {
-    id: NodeIdSchema,
-};
-export const describeNodeOutput = {
-    id: z.string(),
-    type: z.string(),
-    parentId: z.string().nullable(),
-    ancestryIds: z.array(z.string()),
-    childrenIds: z.array(z.string()),
-    properties: z.record(z.string(), z.unknown()),
-    description: z.string(),
-};
-/**
- * Build a short, human-readable one-liner describing the node.
- * Covers the common shapes; falls back to a generic sentence otherwise.
- */
-function describe(node, bridge) {
-    switch (node.type) {
-        case 'wall': {
-            const [x1, z1] = node.start;
-            const [x2, z2] = node.end;
-            const t = node.thickness ?? 0.1;
-            const h = wallResolvedHeight(bridge.getNodes(), node);
-            return `Wall from (${x1},${z1}) to (${x2},${z2}), thickness ${t.toFixed(2)}m, height ${h.toFixed(2)}m`;
-        }
-        case 'level':
-            return getLevelDisplayName(node);
-        case 'building': {
-            const [x, y, z] = node.position;
-            return `Building at (${x},${y},${z})`;
-        }
-        case 'site':
-            return `Site with ${node.polygon?.points.length ?? 0}-sided property line`;
-        case 'zone':
-            return `Zone "${node.name}" with ${node.polygon.length} vertices`;
-        case 'slab':
-            return node.plateRole === 'base'
-                ? `Floor footprint "${floorFootprintName(bridge.getNodes(), node)}" with ${node.polygon.length} vertices`
-                : `Slab with ${node.polygon.length} vertices`;
-        case 'ceiling':
-            return `Ceiling with ${node.polygon.length} vertices, height ${resolveCeilingHeight(node, bridge.getNodes()).toFixed(2)}m`;
-        case 'door':
-            return `Door (${node.width.toFixed(2)}m x ${node.height.toFixed(2)}m)`;
-        case 'window':
-            return `Window (${node.width.toFixed(2)}m x ${node.height.toFixed(2)}m)`;
-        case 'item': {
-            const [x, y, z] = node.position;
-            return `Item "${node.asset.name}" at (${x},${y},${z})`;
-        }
-        default:
-            return `${node.type} node`;
-    }
-}
-export function registerDescribeNode(server, bridge) {
-    server.registerTool('describe_node', {
-        title: 'Describe node',
-        description: 'Return a structured summary of a node including its ancestry, children IDs, key properties, and a short human description.',
-        inputSchema: describeNodeInput,
-        outputSchema: describeNodeOutput,
-        annotations: READ_ONLY_TOOL_ANNOTATIONS,
-    }, async ({ id }) => {
-        const node = bridge.getNode(id);
-        if (!node) {
-            throwMcpError(ErrorCode.InvalidParams, `Node not found: ${id}`);
-        }
-        // Ancestry minus self.
-        const ancestry = bridge.getAncestry(id);
-        const ancestryIds = ancestry.slice(1).map((n) => n.id);
-        const children = bridge.getChildren(id);
-        const childrenIds = children.map((n) => n.id);
-        const n = node;
-        const properties = n.type === 'wall'
-            ? {
-                ...n,
-                resolvedHeight: wallResolvedHeight(bridge.getNodes(), n),
-                heightIsExplicit: n.height !== undefined,
-            }
-            : n;
-        const payload = {
-            id: n.id,
-            type: n.type,
-            parentId: (n.parentId ?? null),
-            ancestryIds,
-            childrenIds,
-            properties: properties,
-            description: describe(n, bridge),
-        };
-        return {
-            content: [{ type: 'text', text: JSON.stringify(payload) }],
-            structuredContent: payload,
-        };
-    });
-}

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

@@ -1,16 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import type { SceneOperations } from '../operations/index.js';
-export declare const findNodesInput: {
-    type: z.ZodOptional<z.ZodString>;
-    parentId: z.ZodOptional<z.ZodString>;
-    levelId: z.ZodOptional<z.ZodString>;
-    zoneId: z.ZodOptional<z.ZodString>;
-    sourceId: z.ZodOptional<z.ZodString>;
-    sourceIdPrefix: z.ZodOptional<z.ZodString>;
-};
-export declare const findNodesOutput: {
-    nodes: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-};
-export declare function registerFindNodes(server: McpServer, bridge: SceneOperations): void;
-//# sourceMappingURL=find-nodes.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"find-nodes.d.ts","sourceRoot":"","sources":["../../src/tools/find-nodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAKxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAOpD,eAAO,MAAM,cAAc;;;;;;;CAyB1B,CAAA;AAED,eAAO,MAAM,eAAe;;CAE3B,CAAA;AAmHD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAuFlF"}

package/dist/tools/find-nodes.js

@@ -1,204 +0,0 @@
-import { measurementCentroid, nodeRegistry } from '@pascal-app/core';
-import { nodeLevelFrame, transformPoint } from '@pascal-app/core/procedural-items';
-import { AnyNode, nodeKindOf } from '@pascal-app/core/schema';
-import { pointInPolygon } from '@pascal-app/core/spatial-grid';
-import { z } from 'zod';
-import { READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
-import { ErrorCode, throwMcpError } from './errors.js';
-import { NodeIdSchema } from './schemas.js';
-const CORE_NODE_KINDS = AnyNode.options.map(nodeKindOf);
-export const findNodesInput = {
-    type: z
-        .string()
-        .min(1)
-        .optional()
-        .describe(`Node kind: a core kind (${CORE_NODE_KINDS.join(', ')}) or a plugin kind such as "fixture:bench".`),
-    parentId: NodeIdSchema.optional(),
-    levelId: NodeIdSchema.optional(),
-    zoneId: NodeIdSchema.optional(),
-    sourceId: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Exact match on any import source id of the node: provenance.refs[].id or legacy metadata.sourceIds. Characters outside printable ASCII also match their percent-encoded form.'),
-    sourceIdPrefix: z
-        .string()
-        .min(1)
-        .optional()
-        .describe('Prefix match on any import source id of the node (provenance.refs[].id or legacy metadata.sourceIds).'),
-};
-export const findNodesOutput = {
-    nodes: z.array(z.record(z.string(), z.unknown())),
-};
-/**
- * A source id as importers must write it for typed provenance: printable
- * ASCII kept, every other character percent-encoded as UTF-8 bytes.
- */
-function encodeSourceId(id) {
-    let out = '';
-    for (const char of id) {
-        if (/^[\x20-\x7E]$/.test(char)) {
-            out += char;
-            continue;
-        }
-        for (const byte of new TextEncoder().encode(char)) {
-            out += `%${byte.toString(16).toUpperCase().padStart(2, '0')}`;
-        }
-    }
-    return out;
-}
-/** A node's import source ids: typed `provenance.refs[].id`, then legacy `metadata.sourceIds`. */
-function nodeSourceIds(node) {
-    const typed = (node.provenance?.refs ?? []).map((ref) => ref.id);
-    const legacy = node.metadata?.sourceIds;
-    return Array.isArray(legacy)
-        ? [...typed, ...legacy.filter((id) => typeof id === 'string')]
-        : typed;
-}
-function centre(points) {
-    if (points.length === 0)
-        return null;
-    const area = measurementCentroid(points.map(([x, z]) => [x, 0, z]));
-    if (area)
-        return [area[0], area[2]];
-    let cx = 0;
-    let cz = 0;
-    for (const [x, z] of points) {
-        cx += x;
-        cz += z;
-    }
-    return [cx / points.length, cz / points.length];
-}
-function boundsCentre3(points) {
-    if (points.length === 0)
-        return null;
-    const centre = [0, 0, 0];
-    for (let axis = 0; axis < 3; axis++) {
-        const values = points.map((p) => p[axis]);
-        centre[axis] = (Math.min(...values) + Math.max(...values)) / 2;
-    }
-    return centre;
-}
-/**
- * The node's plan point in its level's frame, for zone filtering: a polygon's
- * area centroid, a segment's midpoint, a path's centre, or the origin of a
- * positioned node resolved through its hosts by core's `nodeLevelFrame` (a
- * window in its wall, a module in its cabinet); blocks and imported meshes
- * use their vertex-bounds centre, transformed in 3D before projecting.
- * Frames are plan-only (no slab support or floor lift, which only move
- * heights) and `frames` is shared across one query, so each host resolves once.
- */
-function levelPlanPoint(node, nodes, frames) {
-    const n = node;
-    if (Array.isArray(n.polygon))
-        return centre(n.polygon);
-    if (Array.isArray(n.start) && Array.isArray(n.end)) {
-        const [x1, z1] = n.start;
-        const [x2, z2] = n.end;
-        return [(x1 + x2) / 2, (z1 + z2) / 2];
-    }
-    if (Array.isArray(n.path)) {
-        const path = boundsCentre3(n.path);
-        return path ? [path[0], path[2]] : null;
-    }
-    if (!Array.isArray(n.position))
-        return null;
-    let frame;
-    try {
-        frame = nodeLevelFrame(node.id, nodes, undefined, { cache: frames, planOnly: true });
-    }
-    catch {
-        return null;
-    }
-    const local = node.type === 'block'
-        ? boundsCentre3(node.topology.vertices.map((v) => v.position))
-        : node.type === 'imported-mesh'
-            ? boundsCentre3(node.primitives.flatMap((primitive) => {
-                const out = [];
-                for (let i = 0; i + 2 < primitive.positions.length; i += 3) {
-                    out.push([
-                        primitive.positions[i],
-                        primitive.positions[i + 1],
-                        primitive.positions[i + 2],
-                    ]);
-                }
-                return out;
-            }))
-            : null;
-    const [x, , z] = transformPoint(frame, local ?? [0, 0, 0]);
-    return [x, z];
-}
-/** Node kinds `type` accepts: core kinds, registered plugin kinds, and kinds in the scene. */
-function knownNodeKinds(nodes) {
-    const kinds = new Set(CORE_NODE_KINDS);
-    for (const node of Object.values(nodes))
-        kinds.add(node.type);
-    return kinds;
-}
-export function registerFindNodes(server, bridge) {
-    server.registerTool('find_nodes', {
-        title: 'Find nodes',
-        description: 'Find nodes matching any combination of type, parentId, levelId, zoneId, sourceId or sourceIdPrefix filters. sourceId / sourceIdPrefix match the ids an importer recorded for the source elements: provenance.refs[].id, or legacy metadata.sourceIds.',
-        inputSchema: findNodesInput,
-        outputSchema: findNodesOutput,
-        annotations: READ_ONLY_TOOL_ANNOTATIONS,
-    }, async (args) => {
-        const { type, parentId, levelId, zoneId, sourceId, sourceIdPrefix } = args;
-        // Delegate type/parent/level filtering to the bridge.
-        const baseFilter = {};
-        if (type !== undefined) {
-            if (!(knownNodeKinds(bridge.getNodes()).has(type) || nodeRegistry.get(type))) {
-                throwMcpError(ErrorCode.InvalidParams, `unknown node type "${type}": not a core kind, a registered plugin kind or a kind in this scene`);
-            }
-            baseFilter.type = type;
-        }
-        if (parentId !== undefined)
-            baseFilter.parentId = parentId;
-        if (levelId !== undefined)
-            baseFilter.levelId = levelId;
-        let results = bridge.findNodes(baseFilter);
-        if (sourceId !== undefined || sourceIdPrefix !== undefined) {
-            // Legacy ids may be stored raw, typed-provenance ones percent-encoded.
-            const exact = sourceId === undefined ? [] : [sourceId, encodeSourceId(sourceId)];
-            const prefixes = sourceIdPrefix === undefined ? [] : [sourceIdPrefix, encodeSourceId(sourceIdPrefix)];
-            results = results.filter((n) => {
-                const ids = nodeSourceIds(n);
-                if (sourceId !== undefined && !ids.some((id) => exact.includes(id)))
-                    return false;
-                if (sourceIdPrefix !== undefined &&
-                    !ids.some((id) => prefixes.some((prefix) => id.startsWith(prefix)))) {
-                    return false;
-                }
-                return true;
-            });
-        }
-        // Zone filter: nodes on the zone's level whose level-frame plan point
-        // falls inside the zone polygon.
-        if (zoneId) {
-            const zone = bridge.getNode(zoneId);
-            if (zone?.type !== 'zone') {
-                // Unknown zoneId → return empty list rather than throw; matches
-                // typical "filter" semantics.
-                results = [];
-            }
-            else {
-                const nodes = bridge.getNodes();
-                const frames = new Map();
-                const zoneLevelId = bridge.resolveLevelId(zone.id);
-                results = results.filter((n) => {
-                    if (bridge.resolveLevelId(n.id) !== zoneLevelId)
-                        return false;
-                    const pt = levelPlanPoint(n, nodes, frames);
-                    return pt !== null && pointInPolygon(pt[0], pt[1], zone.polygon);
-                });
-            }
-        }
-        const payload = {
-            nodes: results,
-        };
-        return {
-            content: [{ type: 'text', text: JSON.stringify(payload) }],
-            structuredContent: payload,
-        };
-    });
-}

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

@@ -1,34 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import type { SceneOperations } from '../operations/index.js';
-export declare const placeDesignInput: {
-    design: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
-    hostId: z.ZodString;
-    position: z.ZodArray<z.ZodNumber>;
-    rotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    side: z.ZodOptional<z.ZodEnum<{
-        front: "front";
-        back: "back";
-    }>>;
-    surfaceId: z.ZodOptional<z.ZodString>;
-    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    name: z.ZodOptional<z.ZodString>;
-    id: z.ZodOptional<z.ZodString>;
-};
-export declare const placeDesignOutput: {
-    project: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    unsaved: z.ZodOptional<z.ZodString>;
-    persistence: z.ZodOptional<z.ZodObject<{
-        status: z.ZodEnum<{
-            unbound: "unbound";
-            events_unsupported: "events_unsupported";
-        }>;
-        warning: z.ZodString;
-    }, z.core.$strip>>;
-    designId: z.ZodString;
-    parentId: z.ZodString;
-    surfaceId: z.ZodNullable<z.ZodString>;
-};
-export declare function registerPlaceDesign(server: McpServer, bridge: SceneOperations): void;
-//# sourceMappingURL=place-design.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"place-design.d.ts","sourceRoot":"","sources":["../../src/tools/place-design.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAOpD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;CA8B5B,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;CAK7B,CAAA;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAyDpF"}