@vcad/mcp 0.10.0-main.130 → 0.10.0-main.132

package/README.md

@@ -6,4 +6,4 @@ vcad's MCP server as a self-contained bundle (server + BRep kernel WASM).
 { "mcpServers": { "vcad": { "command": "npx", "args": ["-y", "@vcad/mcp"] } } }
 ```
 
-Built from 86e01dfe3474a2c82f179c81edd92f1efa97340b at 2026-10-21T16:21:11.937Z. Source: https://github.com/ecto/vcad
+Built from 362c46b798588ed58f200c9d529b3d11b2b2ff73 at 2026-10-21T17:31:51.205Z. Source: https://github.com/ecto/vcad

package/index.mjs

@@ -10867,6 +10867,173 @@ var init_delta = __esm({
   }
 });
 
+// ../engine/dist/engine-host.js
+function handleEngineRequest(host, req) {
+  try {
+    let envelope;
+    let bytes;
+    switch (req.op) {
+      case "init":
+        host.engine?.free();
+        host.engine = req.replica !== void 0 && host.Engine.withReplica ? host.Engine.withReplica(req.replica) : new host.Engine();
+        envelope = host.engine.stateEnvelope();
+        break;
+      case "load":
+        host.engine?.free();
+        host.engine = host.Engine.load(req.bytes);
+        envelope = host.engine.stateEnvelope();
+        break;
+      default: {
+        const engine2 = host.engine;
+        if (!engine2)
+          return { ok: false, message: "engine not initialized" };
+        if (req.op === "apply")
+          envelope = engine2.applyDelta(JSON.stringify(req.command));
+        else if (req.op === "applyTool")
+          envelope = engine2.applyToolDelta(req.tool, JSON.stringify(req.args));
+        else if (req.op === "state")
+          envelope = engine2.stateEnvelope();
+        else
+          bytes = engine2.save();
+      }
+    }
+    const engine = host.engine;
+    return {
+      ok: true,
+      envelope,
+      bytes,
+      hash: engine.stateHash(),
+      canUndo: engine.can_undo(),
+      canRedo: engine.can_redo()
+    };
+  } catch (e) {
+    return { ok: false, message: e instanceof Error ? e.message : String(e) };
+  }
+}
+function inProcessTransport(Engine2) {
+  const host = { Engine: Engine2, engine: null };
+  return {
+    request: async (req) => handleEngineRequest(host, req),
+    dispose: () => {
+      host.engine?.free();
+      host.engine = null;
+    }
+  };
+}
+function workerTransport(worker) {
+  let next = 0;
+  const pending2 = /* @__PURE__ */ new Map();
+  worker.addEventListener("message", (e) => {
+    const { id, response } = e.data;
+    pending2.get(id)?.(response);
+    pending2.delete(id);
+  });
+  return {
+    request: (req) => new Promise((resolve7) => {
+      const id = next++;
+      pending2.set(id, resolve7);
+      worker.postMessage({ id, req });
+    }),
+    dispose: () => worker.terminate()
+  };
+}
+var EngineHostError, DocumentEngineClient;
+var init_engine_host = __esm({
+  "../engine/dist/engine-host.js"() {
+    "use strict";
+    init_delta();
+    EngineHostError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "EngineHostError";
+      }
+    };
+    DocumentEngineClient = class {
+      transport;
+      view = null;
+      queue = Promise.resolve();
+      flags = { hash: "", canUndo: false, canRedo: false };
+      constructor(transport) {
+        this.transport = transport;
+      }
+      /** The current view (null before `init`/`load`). */
+      get state() {
+        return this.view;
+      }
+      get stateHash() {
+        return this.flags.hash;
+      }
+      get canUndo() {
+        return this.flags.canUndo;
+      }
+      get canRedo() {
+        return this.flags.canRedo;
+      }
+      /** Start an empty document. */
+      init(replica) {
+        return this.full({ op: "init", replica });
+      }
+      /** Restore a `save()` snapshot. */
+      load(bytes) {
+        return this.full({ op: "load", bytes });
+      }
+      /** Re-read the whole state (resynchronizes the view). */
+      refresh() {
+        return this.full({ op: "state" });
+      }
+      /** Apply a command; rejects with `EngineRefusal` when the engine refuses. */
+      apply(command) {
+        return this.delta({ op: "apply", command });
+      }
+      /** Lower and apply an AI tool call. */
+      applyTool(tool, args) {
+        return this.delta({ op: "applyTool", tool, args });
+      }
+      /** Snapshot the engine (document + history). */
+      save() {
+        return this.enqueue(async () => {
+          const r = this.check(await this.transport.request({ op: "save" }));
+          return r.bytes ?? new Uint8Array();
+        });
+      }
+      dispose() {
+        this.transport.dispose();
+        this.view = null;
+      }
+      full(req) {
+        return this.enqueue(async () => {
+          const r = this.check(await this.transport.request(req));
+          this.view = stateFromEnvelope(r.envelope);
+          return this.view;
+        });
+      }
+      delta(req) {
+        return this.enqueue(async () => {
+          const base = this.view;
+          if (!base)
+            throw new EngineHostError("engine not initialized");
+          const r = this.check(await this.transport.request(req));
+          const delta = parseDeltaEnvelope(r.envelope);
+          const { state, changes } = applyEngineDelta(base, delta);
+          this.view = state;
+          return { state, changes, createdFeatureId: delta.createdFeatureId, warnings: delta.warnings };
+        });
+      }
+      check(r) {
+        if (!r.ok)
+          throw new EngineHostError(r.message);
+        this.flags = { hash: r.hash, canUndo: r.canUndo, canRedo: r.canRedo };
+        return r;
+      }
+      enqueue(f) {
+        const run = this.queue.then(f, f);
+        this.queue = run.catch(() => void 0);
+        return run;
+      }
+    };
+  }
+});
+
 // ../engine/dist/sequence.js
 function requireWasm2() {
   const mod = getKernelWasmSync();
@@ -12023,7 +12190,9 @@ __export(dist_exports, {
   DEFAULT_NESTING_PARAMS: () => DEFAULT_NESTING_PARAMS,
   DEFAULT_SHOP_PROFILE: () => DEFAULT_SHOP_PROFILE,
   DependencyGraph: () => DependencyGraph,
+  DocumentEngineClient: () => DocumentEngineClient,
   Engine: () => Engine,
+  EngineHostError: () => EngineHostError,
   EngineRefusal: () => EngineRefusal,
   ExpressionEvalError: () => EvalError,
   ExpressionParseError: () => ParseError,
@@ -12055,6 +12224,7 @@ __export(dist_exports, {
   computeRatsnest: () => computeRatsnest,
   connectorsFromPcb: () => connectorsFromPcb,
   createCircuitSim: () => createCircuitSim,
+  createEngineWorker: () => createEngineWorker,
   critiqueRoute: () => critiqueRoute,
   decimateMeshGpu: () => decimateMeshGpu2,
   defaultParamsFor: () => defaultParamsFor,
@@ -12081,8 +12251,10 @@ __export(dist_exports, {
   getKernelWasmSync: () => getKernelWasmSync,
   getPcbDfmPack: () => getPcbDfmPack,
   getRayTracer: () => getRayTracer,
+  handleEngineRequest: () => handleEngineRequest,
   hashCsgOp: () => hashCsgOp,
   homogenizeMaterial: () => homogenizeMaterial,
+  inProcessTransport: () => inProcessTransport,
   initializeGpu: () => initializeGpu,
   initializeRayTracer: () => initializeRayTracer,
   inspectMolecule: () => inspectMolecule,
@@ -12150,8 +12322,12 @@ __export(dist_exports, {
   tryRunDrc: () => tryRunDrc,
   verifyReceipt: () => verifyReceipt,
   verifySubstitution: () => verifySubstitution,
+  workerTransport: () => workerTransport,
   writeXyz: () => writeXyz
 });
+function createEngineWorker() {
+  return new Worker(new URL("./engine-worker.js", import.meta.url), { type: "module" });
+}
 var SCENE_CACHE_MAX, Engine;
 var init_dist = __esm({
   "../engine/dist/index.js"() {
@@ -12168,6 +12344,7 @@ var init_dist = __esm({
     init_diff();
     init_solid_cache();
     init_delta();
+    init_engine_host();
     init_mesh_cache();
     init_dependency_graph();
     init_evaluate();
@@ -12315,6 +12492,7 @@ var init_dist = __esm({
           evaluateDocument: wasmModule7.evaluateDocument,
           evalVcadSource: wasmModule7.evalVcadSource,
           evalVcadSourceWithModules: wasmModule7.evalVcadSourceWithModules,
+          evalLoonDocument: wasmModule7.evalLoonDocument,
           evalVcadSourceParametric: wasmModule7.evalVcadSourceParametric,
           documentParameterGradient: wasmModule7.documentParameterGradient,
           documentSensitivities: wasmModule7.documentSensitivities,
@@ -13217,6 +13395,22 @@ var init_dist = __esm({
        * With an empty map this is exactly {@link evalVcadSource}. Returns null
        * if the kernel doesn't support module-aware loon evaluation.
        */
+      /**
+       * Evaluate loon source to a session document stamped with its provenance
+       * (`doc.source`: program, modules, origin dir/file, SHA-256), in the kernel.
+       * Null on kernels predating the export.
+       */
+      evalLoonDocument(source, modules, origin = {}) {
+        if (typeof this.kernel.evalLoonDocument !== "function")
+          return null;
+        const doc = JSON.parse(this.kernel.evalLoonDocument(source, JSON.stringify(modules), origin.baseDir, origin.path));
+        if (doc.source) {
+          doc.source.diverged ??= false;
+          doc.source.diverged_by ??= [];
+          doc.source.modules ??= {};
+        }
+        return doc;
+      }
       evalVcadSourceWithModules(source, modules) {
         if (!Object.keys(modules).length)
           return this.evalVcadSource(source);
@@ -41509,6 +41703,18 @@ var init_CHANGELOG = __esm({
             "cli"
           ]
         },
+        {
+          id: "2026-10-21-photoreal-cyclorama",
+          version: "0.10.0",
+          date: "2026-10-21",
+          category: "feat",
+          title: "Seamless cyclorama backdrop for photoreal renders",
+          summary: "--backdrop cyclorama (vcad render --cyclorama) puts the subject on a matte floor that curves into a back wall, with no horizon line or edge in frame.",
+          features: [
+            "photoreal",
+            "render"
+          ]
+        },
         {
           id: "2026-10-21-mac-sim-teardown-race",
           version: "0.10.0",
@@ -51528,79 +51734,8 @@ var init_loon_assets = __esm({
   }
 });
 
-// src/tools/source-provenance.ts
-import { createHash } from "node:crypto";
-import { readFileSync as readFileSync3 } from "node:fs";
-function sourceHash(text) {
-  return createHash("sha256").update(text, "utf8").digest("hex");
-}
-function attachLoonSource(doc, { text, modules, base_dir, path }) {
-  const source = {
-    language: "loon",
-    text,
-    modules: modules && Object.keys(modules).length ? { ...modules } : {},
-    hash: sourceHash(text),
-    diverged: false,
-    diverged_by: []
-  };
-  if (base_dir) source.base_dir = base_dir;
-  if (path) source.path = path;
-  doc.source = source;
-}
-function markSourceDiverged(documentId, tool) {
-  const src = documents.get(documentId)?.source;
-  if (!src) return false;
-  const firstTime = !src.diverged;
-  src.diverged = true;
-  const by = src.diverged_by ??= [];
-  if (by[by.length - 1] !== tool) by.push(tool);
-  if (by.length > MAX_DIVERGED_BY) by.splice(0, by.length - MAX_DIVERGED_BY);
-  return firstTime;
-}
-function sourceStatus(doc) {
-  const src = doc?.source;
-  if (!src) return { source_stale: false };
-  const path = src.path;
-  if (path) {
-    let onDisk = null;
-    try {
-      onDisk = readFileSync3(path, "utf8");
-    } catch {
-      return {
-        source_stale: true,
-        source_path: path,
-        reason: `The source file ${path} can no longer be read \u2014 this session is no longer backed by the file it was loaded from.`
-      };
-    }
-    if (sourceHash(onDisk) !== src.hash) {
-      return {
-        source_stale: true,
-        source_path: path,
-        reason: `${path} changed on disk since this session was evaluated from it \u2014 the session's geometry is from the OLD source. Re-load the file to pick up the edits.`
-      };
-    }
-  }
-  if (src.diverged) {
-    const by = src.diverged_by ?? [];
-    return {
-      source_stale: true,
-      ...path ? { source_path: path } : {},
-      reason: `This session has been edited directly (${by.join(", ") || "mutation"}), and those edits cannot round-trip back to loon. The stored source describes the document's ORIGIN, not its current state` + (path ? ` \u2014 saving would not reproduce ${path}, and re-evaluating ${path} would discard the edits.` : `.`)
-    };
-  }
-  return { source_stale: false, ...path ? { source_path: path } : {} };
-}
-var MAX_DIVERGED_BY;
-var init_source_provenance = __esm({
-  "src/tools/source-provenance.ts"() {
-    "use strict";
-    init_session_core();
-    MAX_DIVERGED_BY = 8;
-  }
-});
-
 // src/tools/loon.ts
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 import { delimiter, isAbsolute as isAbsolute3, join as join2, resolve as resolve2, sep as sep2 } from "node:path";
 function composeLoonProgram(input) {
   const { source, use_loons, loons } = input;
@@ -51626,7 +51761,7 @@ function readModule(base, name) {
     const file = resolve2(join2(root, ...name.split(".")) + ext);
     if (file !== root && !file.startsWith(root + sep2)) continue;
     try {
-      return readFileSync4(file, "utf8");
+      return readFileSync3(file, "utf8");
     } catch {
     }
   }
@@ -51693,11 +51828,10 @@ function evalCadLoon(input, engine) {
   const modules = composeLoonModules(input);
   let doc;
   try {
-    doc = engine.evalVcadSourceWithModules(source, modules);
+    doc = engine.evalLoonDocument(source, modules, { baseDir: base_dir });
   } catch (e) {
     throw explainEvalError(e, parsed, missingModules(source, modules));
   }
-  if (doc) attachLoonSource(doc, { text: source, modules, base_dir });
   if (!doc) {
     const text2 = Object.keys(modules).length ? "Error: this kernel build cannot resolve loon modules ([use ...]) \u2014 update the kernel, or inline the modules into `source`" : "Error: Loon evaluation not supported by this engine build";
     return { result: { content: [{ type: "text", text: text2 }] }, doc: null };
@@ -51771,7 +51905,6 @@ var init_loon = __esm({
     init_session_core();
     init_loon_assets();
     init_remote();
-    init_source_provenance();
     init_tool_def();
     createCadLoonSchema = {
       type: "object",
@@ -52427,7 +52560,7 @@ var init_session_store = __esm({
 });
 
 // src/tools/artifact-store.ts
-import { createHash as createHash2, randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 function ttlMs() {
   const raw = process.env.MCP_ARTIFACT_TTL_MS;
   const n = raw ? parseInt(raw, 10) : NaN;
@@ -52523,7 +52656,7 @@ function storeArtifact(files) {
   const manifest = stored.map((f) => ({
     file: f.name,
     bytes: f.buf.length,
-    sha256: createHash2("sha256").update(f.buf).digest("hex")
+    sha256: createHash("sha256").update(f.buf).digest("hex")
   }));
   const bytes = stored.reduce((n, f) => n + f.buf.length, 0);
   const expiresAt = now + ttlMs();
@@ -52658,7 +52791,7 @@ async function loadDurable(id) {
       manifest: Array.isArray(row.manifest) ? row.manifest : files.map((f) => ({
         file: f.name,
         bytes: f.buf.length,
-        sha256: createHash2("sha256").update(f.buf).digest("hex")
+        sha256: createHash("sha256").update(f.buf).digest("hex")
       })),
       bytes: typeof row.bytes === "number" ? row.bytes : files.reduce((n, f) => n + f.buf.length, 0),
       createdAt: row.created_at ? Date.parse(row.created_at) : Date.now(),
@@ -52718,6 +52851,64 @@ var init_artifact_store = __esm({
   }
 });
 
+// src/tools/source-provenance.ts
+import { createHash as createHash2 } from "node:crypto";
+import { readFileSync as readFileSync4 } from "node:fs";
+function sourceHash(text) {
+  return createHash2("sha256").update(text, "utf8").digest("hex");
+}
+function markSourceDiverged(documentId, tool) {
+  const src = documents.get(documentId)?.source;
+  if (!src) return false;
+  const firstTime = !src.diverged;
+  src.diverged = true;
+  const by = src.diverged_by ??= [];
+  if (by[by.length - 1] !== tool) by.push(tool);
+  if (by.length > MAX_DIVERGED_BY) by.splice(0, by.length - MAX_DIVERGED_BY);
+  return firstTime;
+}
+function sourceStatus(doc) {
+  const src = doc?.source;
+  if (!src) return { source_stale: false };
+  const path = src.path;
+  if (path) {
+    let onDisk = null;
+    try {
+      onDisk = readFileSync4(path, "utf8");
+    } catch {
+      return {
+        source_stale: true,
+        source_path: path,
+        reason: `The source file ${path} can no longer be read \u2014 this session is no longer backed by the file it was loaded from.`
+      };
+    }
+    if (sourceHash(onDisk) !== src.hash) {
+      return {
+        source_stale: true,
+        source_path: path,
+        reason: `${path} changed on disk since this session was evaluated from it \u2014 the session's geometry is from the OLD source. Re-load the file to pick up the edits.`
+      };
+    }
+  }
+  if (src.diverged) {
+    const by = src.diverged_by ?? [];
+    return {
+      source_stale: true,
+      ...path ? { source_path: path } : {},
+      reason: `This session has been edited directly (${by.join(", ") || "mutation"}), and those edits cannot round-trip back to loon. The stored source describes the document's ORIGIN, not its current state` + (path ? ` \u2014 saving would not reproduce ${path}, and re-evaluating ${path} would discard the edits.` : `.`)
+    };
+  }
+  return { source_stale: false, ...path ? { source_path: path } : {} };
+}
+var MAX_DIVERGED_BY;
+var init_source_provenance = __esm({
+  "src/tools/source-provenance.ts"() {
+    "use strict";
+    init_session_core();
+    MAX_DIVERGED_BY = 8;
+  }
+});
+
 // src/tools/session.ts
 import { writeFileSync as writeFileSync2, readFileSync as readFileSync5 } from "node:fs";
 import { dirname, resolve as resolve3 } from "node:path";
@@ -53034,18 +53225,12 @@ async function loadDocumentFromPath(path, store, engine) {
   const modules = composeLoonModules({ source: raw, base_dir: baseDir });
   let doc;
   try {
-    doc = engine.evalVcadSourceWithModules(raw, modules) ?? null;
+    doc = engine.evalLoonDocument(raw, modules, { baseDir, path: abs });
   } catch (e) {
     return fail2(`Loon evaluation of ${abs} failed: ${e.message}`);
   }
   if (!doc) return fail2(`Loon evaluation of ${abs} produced no document.`);
   const imports = assetNote(resolveLoonAssets(doc, { base_dir: baseDir }, engine));
-  attachLoonSource(doc, {
-    text: raw,
-    modules,
-    base_dir: baseDir,
-    path: abs
-  });
   const id = registerSession(doc);
   return {
     content: [
@@ -86876,8 +87061,8 @@ var init_server3 = __esm({
     init_order_feed();
     init_animate();
     PKG_VERSION = (() => {
-      if ("0.10.0-main.130") {
-        return "0.10.0-main.130";
+      if ("0.10.0-main.132") {
+        return "0.10.0-main.132";
       }
       try {
         const req = createRequire2(import.meta.url);
@@ -86886,8 +87071,8 @@ var init_server3 = __esm({
         return "0.0.0";
       }
     })();
-    BUILD_SHA = "86e01dfe3474a2c82f179c81edd92f1efa97340b";
-    BUILD_TIME = "2026-10-21T16:21:11.937Z";
+    BUILD_SHA = "362c46b798588ed58f200c9d529b3d11b2b2ff73";
+    BUILD_TIME = "2026-10-21T17:31:51.205Z";
     SHORT_SHA = BUILD_SHA === "unknown" ? "unknown" : BUILD_SHA.slice(0, 7);
     VERSION_WITH_BUILD = SHORT_SHA === "unknown" ? PKG_VERSION : `${PKG_VERSION}+${SHORT_SHA}`;
     INSTANCE_ID = randomUUID7().slice(0, 8);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vcad/mcp",
-  "version": "0.10.0-main.130",
+  "version": "0.10.0-main.132",
   "description": "vcad MCP server — parametric CAD + PCB design tools for AI agents (self-contained: bundled server + kernel WASM)",
   "license": "MIT",
   "type": "module",
@@ -19,7 +19,7 @@
   },
   "homepage": "https://vcad.io",
   "vcadBuild": {
-    "sha": "86e01dfe3474a2c82f179c81edd92f1efa97340b",
-    "builtAt": "2026-10-21T16:21:11.937Z"
+    "sha": "362c46b798588ed58f200c9d529b3d11b2b2ff73",
+    "builtAt": "2026-10-21T17:31:51.205Z"
   }
 }