@pascal-app/mcp 1.0.3 → 1.0.5

package/dist/transports/http.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 export type HttpTransportHandle = {
     /** Host interface the server is listening on. */
     host: string;
@@ -28,10 +28,16 @@ export type HttpTransportOptions = {
 /**
  * Attach an `McpServer` to a Streamable HTTP transport bound to a local port.
  *
- * Uses the SDK's Node-flavored `StreamableHTTPServerTransport`, which accepts
+ * Uses the SDK's `NodeStreamableHTTPServerTransport`, which accepts
  * `IncomingMessage`/`ServerResponse` directly via `handleRequest(req, res)`.
  * A new session ID is generated per connection (stateful mode).
  *
+ * Serves the 2025 sessionful protocol only: a negotiating client falls back
+ * to it, and a client pinned to 2026-07-28 is refused. The SDK serves
+ * 2026-07-28 over HTTP per request (`createMcpHandler`), with a fresh server
+ * from the factory each time, and every server here owns its own scene, so a
+ * session is what keeps one client's scene between calls.
+ *
  * Listens on `127.0.0.1:<port>` (pass `0` for an ephemeral port in tests). The
  * returned handle exposes the actual bound port and a `close()` that stops
  * the underlying Node HTTP server. To bind a public interface, pass `host` and

package/dist/transports/http.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/transports/http.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAUxE,MAAM,MAAM,mBAAmB,GAAG;IAChC,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAA;IACZ,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAA;IACZ,8DAA8D;IAC9D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,0EAA0E;IAC1E,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,uFAAuF;IACvF,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB,8DAA8D;IAC9D,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,8EAA8E;IAC9E,MAAM,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAA;CACjD,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,WAAW,CAC/B,eAAe,EAAE,MAAM,SAAS,EAChC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,mBAAmB,CAAC,CA2G9B"}
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/transports/http.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAS7D,MAAM,MAAM,mBAAmB,GAAG;IAChC,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAA;IACZ,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAA;IACZ,8DAA8D;IAC9D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,0EAA0E;IAC1E,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,uFAAuF;IACvF,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB,8DAA8D;IAC9D,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,8EAA8E;IAC9E,MAAM,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAA;CACjD,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,WAAW,CAC/B,eAAe,EAAE,MAAM,SAAS,EAChC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,mBAAmB,CAAC,CA2G9B"}

package/dist/transports/http.js

@@ -1,6 +1,6 @@
 import { randomUUID, timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { NodeStreamableHTTPServerTransport } from '@modelcontextprotocol/node';
 const DEFAULT_HOST = '127.0.0.1';
 const DEFAULT_RATE_LIMIT_PER_MINUTE = 120;
 const WINDOW_MS = 60_000;
@@ -9,10 +9,16 @@ const ALLOWED_HEADERS = 'authorization, content-type, mcp-session-id, mcp-protoc
 /**
  * Attach an `McpServer` to a Streamable HTTP transport bound to a local port.
  *
- * Uses the SDK's Node-flavored `StreamableHTTPServerTransport`, which accepts
+ * Uses the SDK's `NodeStreamableHTTPServerTransport`, which accepts
  * `IncomingMessage`/`ServerResponse` directly via `handleRequest(req, res)`.
  * A new session ID is generated per connection (stateful mode).
  *
+ * Serves the 2025 sessionful protocol only: a negotiating client falls back
+ * to it, and a client pinned to 2026-07-28 is refused. The SDK serves
+ * 2026-07-28 over HTTP per request (`createMcpHandler`), with a fresh server
+ * from the factory each time, and every server here owns its own scene, so a
+ * session is what keeps one client's scene between calls.
+ *
  * Listens on `127.0.0.1:<port>` (pass `0` for an ephemeral port in tests). The
  * returned handle exposes the actual bound port and a `close()` that stops
  * the underlying Node HTTP server. To bind a public interface, pass `host` and
@@ -66,7 +72,7 @@ export async function connectHttp(createMcpServer, port, options = {}) {
         let transport = sessionId ? transports.get(sessionId) : undefined;
         if (!transport && req.method === 'POST' && !sessionId) {
             let createdTransport;
-            createdTransport = new StreamableHTTPServerTransport({
+            createdTransport = new NodeStreamableHTTPServerTransport({
                 sessionIdGenerator: () => randomUUID(),
                 onsessioninitialized: (id) => {
                     transports.set(id, createdTransport);

package/dist/transports/stdio.d.ts

@@ -1,14 +1,20 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
+import { type ServeStdioOptions, type StdioServerHandle } 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 declare function connectStdio(server: McpServer): Promise<void>;
+export declare function connectStdio(createServer: () => McpServer, options?: Pick<ServeStdioOptions, 'transport' | 'onerror'>): StdioServerHandle;
 //# sourceMappingURL=stdio.d.ts.map

package/dist/transports/stdio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../src/transports/stdio.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE;;;;;;;;;;GAUG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAGnE"}
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../src/transports/stdio.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EAEvB,MAAM,oCAAoC,CAAA;AAE3C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,YAAY,EAAE,MAAM,SAAS,EAC7B,OAAO,GAAE,IAAI,CAAC,iBAAiB,EAAE,WAAW,GAAG,SAAS,CAAM,GAC7D,iBAAiB,CAKnB"}

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/dist/version.d.ts

@@ -1,2 +1,7 @@
+/**
+ * The package version, for the server's handshake. Read from package.json
+ * at runtime under Node (and Bun) without a static `node:fs` import, so the
+ * server entry also bundles for the browser, where the editor runs it in-page.
+ */
 export declare const version: string;
 //# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,QAMT,CAAA"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,OAAO,QACkE,CAAA"}

package/dist/version.js

@@ -1,3 +1,17 @@
-import { readFileSync } from 'node:fs';
-export const version = process.env.PASCAL_MCP_VERSION ??
-    JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+/**
+ * The package version, for the server's handshake. Read from package.json
+ * at runtime under Node (and Bun) without a static `node:fs` import, so the
+ * server entry also bundles for the browser, where the editor runs it in-page.
+ */
+export const version = (typeof process !== 'undefined' && process.env?.PASCAL_MCP_VERSION) || readVersion();
+function readVersion() {
+    try {
+        const fs = globalThis.process?.getBuiltinModule?.('node:fs');
+        if (!fs)
+            return '0.0.0';
+        return JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+    }
+    catch {
+        return '0.0.0';
+    }
+}

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,14 +39,14 @@ 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({
-      name: 'create_wall',
+      name: 'add_wall',
       arguments: {
         levelId,
         start: [0, 0],
@@ -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

@@ -157,36 +157,34 @@ them by name:
 
 ### 5. Cut doors and windows
 
-The agent uses `cut_opening` to add entry doors on each interior partition
-and windows on the south and east façades:
+The agent uses `add_door` for the entry doors on each interior partition and
+`add_window` for the windows on the south and east façades:
 
 ```jsonc
-// tool: cut_opening  (called once per opening)
+// tool: add_window  (called once per window)
 {
-  "name": "cut_opening",
+  "name": "add_window",
   "arguments": {
     "wallId": "wall-south",       // perimeter wall [0,0] → [10,0]
-    "type": "window",
-    "position": 0.25,             // 25% along centerline
+    "t": 0.25,                    // 25% along centerline
     "width": 1.2,
     "height": 1.2
   }
 }
-// → { "openingId": "window-south-1" }
+// → { "windowId": "window-south-1", ... }
 ```
 
 ```jsonc
 {
-  "name": "cut_opening",
+  "name": "add_door",
   "arguments": {
     "wallId": "wall-bed1",        // partition wall to Bedroom 1
-    "type": "door",
-    "position": 0.4,
+    "t": 0.4,
     "width": 0.9,
     "height": 2.1
   }
 }
-// → { "openingId": "door-bed1" }
+// → { "doorId": "door-bed1", ... }
 ```
 
 The agent repeats this for Bedroom 2's door, the bathroom door, and two
@@ -195,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:
@@ -237,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,8 +108,8 @@ 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
-wall, and issues `cut_opening` — no extra wiring needed.
+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.
@@ -129,16 +128,15 @@ Bedroom polygons from the floorplan rooms.
 
 ### 4. Cut the identified openings
 
-For each window the vision tool reported, the agent calls `cut_opening`
+For each window the vision tool reported, the agent calls `add_window`
 against the corresponding perimeter wall:
 
 ```jsonc
 {
-  "name": "cut_opening",
+  "name": "add_window",
   "arguments": {
     "wallId": "wall-south",
-    "type": "window",
-    "position": 0.5,
+    "t": 0.5,
     "width": 1.4,
     "height": 1.5
   }
@@ -149,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.
@@ -178,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.3",
+  "version": "1.0.5",
   "description": "Model Context Protocol server for Pascal 3D editor",
+  "mcpName": "app.pascal/editor",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -35,6 +36,11 @@
       "types": "./dist/bridge/index.d.ts",
       "import": "./dist/bridge/index.js",
       "default": "./dist/bridge/index.js"
+    },
+    "./tools/*": {
+      "types": "./dist/tools/*.d.ts",
+      "import": "./dist/tools/*.js",
+      "default": "./dist/tools/*.js"
     }
   },
   "bin": {
@@ -47,7 +53,7 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "tsc --build && bun ../../scripts/fix-node-esm-imports.ts ../core/dist && bun ../../scripts/fix-node-esm-imports.ts dist",
+    "build": "tsc --build && bun ../../scripts/fix-node-esm-imports.ts ../core/dist && bun ../../scripts/fix-node-esm-imports.ts ../geometry-script/dist && bun ../../scripts/fix-node-esm-imports.ts dist",
     "dev": "tsgo --build --watch",
     "start": "bun dist/bin/pascal-mcp.js",
     "test": "bun test",
@@ -56,18 +62,22 @@
     "prepublishOnly": "bun run build && bun test && bun run smoke:node"
   },
   "peerDependencies": {
-    "@pascal-app/core": "^1.0.3"
+    "@pascal-app/core": "^1.0.5"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "@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.5",
+    "@pascal-app/lingo": "^0.5.0",
+    "zod": ">=4.6.7 <4.7"
   },
   "devDependencies": {
-    "@pascal-app/core": "^1.0.3",
+    "@modelcontextprotocol/client": "^2.3.1",
+    "@pascal-app/core": "^1.0.5",
     "@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/create-level.d.ts

@@ -1,21 +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 createLevelInput: {
-    buildingId: z.ZodString;
-    elevation: z.ZodOptional<z.ZodNumber>;
-    height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    label: z.ZodOptional<z.ZodString>;
-};
-export declare const createLevelOutput: {
-    persistence: z.ZodOptional<z.ZodObject<{
-        status: z.ZodEnum<{
-            unbound: "unbound";
-            events_unsupported: "events_unsupported";
-        }>;
-        warning: z.ZodString;
-    }, z.core.$strip>>;
-    levelId: z.ZodString;
-};
-export declare function registerCreateLevel(server: McpServer, bridge: SceneOperations): void;
-//# sourceMappingURL=create-level.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"create-level.d.ts","sourceRoot":"","sources":["../../src/tools/create-level.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAIxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAOpD,eAAO,MAAM,gBAAgB;;;;;CAW5B,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;CAG7B,CAAA;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgDpF"}

package/dist/tools/create-level.js

@@ -1,63 +0,0 @@
-import { DEFAULT_LEVEL_HEIGHT } from '@pascal-app/core';
-import { LevelNode } from '@pascal-app/core/schema';
-import { z } from 'zod';
-import { ADDITIVE_TOOL_ANNOTATIONS } from './annotations.js';
-import { ErrorCode, throwMcpError } from './errors.js';
-import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
-import { measurement } from './measurement.js';
-import { NodeIdSchema } from './schemas.js';
-export const createLevelInput = {
-    buildingId: NodeIdSchema,
-    elevation: z
-        .number()
-        .optional()
-        .describe("Legacy parameter; new levels are appended above the building's current top level."),
-    height: measurement('length', 'm', {
-        min: 0,
-        description: 'Stored floor-to-floor storey height.',
-    }).optional(),
-    label: z.string().optional(),
-};
-export const createLevelOutput = {
-    levelId: z.string(),
-    ...liveSyncOutput,
-};
-export function registerCreateLevel(server, bridge) {
-    server.registerTool('create_level', {
-        title: 'Create level',
-        description: "Append a new level above the given building's current top level. height is stored as the level's floor-to-floor storey height.",
-        inputSchema: createLevelInput,
-        outputSchema: createLevelOutput,
-        annotations: ADDITIVE_TOOL_ANNOTATIONS,
-    }, async ({ buildingId, height, label }) => {
-        const parent = bridge.getNode(buildingId);
-        if (!parent) {
-            throwMcpError(ErrorCode.InvalidParams, `Building not found: ${buildingId}`);
-        }
-        if (parent.type !== 'building') {
-            throwMcpError(ErrorCode.InvalidParams, `Node ${buildingId} is a ${parent.type}, expected building`);
-        }
-        const metadata = {};
-        if (label !== undefined)
-            metadata.label = label;
-        const existingOrdinals = bridge
-            .getChildren(buildingId)
-            .filter((node) => node.type === 'level')
-            .map((node) => node.level);
-        const nextOrdinal = Math.max(-1, ...existingOrdinals) + 1;
-        const levelNode = LevelNode.parse({
-            level: nextOrdinal,
-            height: height ?? DEFAULT_LEVEL_HEIGHT,
-            children: [],
-            ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
-            ...(label !== undefined ? { name: label } : {}),
-        });
-        const id = bridge.createNode(levelNode, buildingId);
-        const persistence = await publishLiveSceneSnapshot(bridge, 'create_level');
-        const payload = { levelId: id, ...persistencePayload(persistence) };
-        return {
-            content: [{ type: 'text', text: JSON.stringify(payload) }],
-            structuredContent: payload,
-        };
-    });
-}

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

@@ -1,22 +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 createWallInput: {
-    levelId: z.ZodString;
-    start: z.ZodArray<z.ZodNumber>;
-    end: z.ZodArray<z.ZodNumber>;
-    thickness: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-};
-export declare const createWallOutput: {
-    persistence: z.ZodOptional<z.ZodObject<{
-        status: z.ZodEnum<{
-            unbound: "unbound";
-            events_unsupported: "events_unsupported";
-        }>;
-        warning: z.ZodString;
-    }, z.core.$strip>>;
-    wallId: z.ZodString;
-};
-export declare function registerCreateWall(server: McpServer, bridge: SceneOperations): void;
-//# sourceMappingURL=create-wall.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"create-wall.d.ts","sourceRoot":"","sources":["../../src/tools/create-wall.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAOpD,eAAO,MAAM,eAAe;;;;;;CAS3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;CAG5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAiDnF"}