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

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 5ba01b5a98082b32c94a94415030e2581bf3288e at 2026-10-21T16:56:57.309Z. 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();
@@ -86876,8 +87053,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.131") {
+        return "0.10.0-main.131";
       }
       try {
         const req = createRequire2(import.meta.url);
@@ -86886,8 +87063,8 @@ var init_server3 = __esm({
         return "0.0.0";
       }
     })();
-    BUILD_SHA = "86e01dfe3474a2c82f179c81edd92f1efa97340b";
-    BUILD_TIME = "2026-10-21T16:21:11.937Z";
+    BUILD_SHA = "5ba01b5a98082b32c94a94415030e2581bf3288e";
+    BUILD_TIME = "2026-10-21T16:56:57.309Z";
     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.131",
   "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": "5ba01b5a98082b32c94a94415030e2581bf3288e",
+    "builtAt": "2026-10-21T16:56:57.309Z"
   }
 }