@vcad/mcp 0.10.0-main.112 → 0.10.0-main.114

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 cdbfe885b0a0ed7b3492e33d7b2f4a1da4f3bd6c at 2026-10-20T22:45:38.715Z. Source: https://github.com/ecto/vcad
+Built from a680346430d6b8e6acd07ec8f2821f14ccd6a05f at 2026-10-20T23:26:44.068Z. Source: https://github.com/ecto/vcad

package/index.mjs

@@ -42019,6 +42019,21 @@ var init_CHANGELOG = __esm({
             "get_footprint"
           ]
         },
+        {
+          id: "2026-10-20-update-params-apply",
+          version: "0.10.0",
+          date: "2026-10-20",
+          category: "fix",
+          title: "AI updates to part dimensions actually apply",
+          summary: "An update like resizing a cube via size {x,y,z} reported success but changed nothing; nested params now map onto the part's real fields, and unknown params are refused.",
+          features: [
+            "engine",
+            "ai"
+          ],
+          mcpTools: [
+            "update"
+          ]
+        },
         {
           id: "2026-10-20-schematic-power-flags",
           version: "0.10.0",
@@ -42152,6 +42167,19 @@ var init_CHANGELOG = __esm({
             "find_alternatives"
           ]
         },
+        {
+          id: "2026-10-20-import-keeps-materials",
+          version: "0.10.0",
+          date: "2026-10-20",
+          category: "fix",
+          title: "Imported parts keep their material and visibility",
+          summary: "Opening a document through the engine reset every part's material to default and showed hidden parts; both now survive import and every later edit.",
+          features: [
+            "engine",
+            "import",
+            "materials"
+          ]
+        },
         {
           id: "2026-10-20-hierarchical-schematic-sheets",
           version: "0.10.0",
@@ -51371,6 +51399,64 @@ function setSessionScopeProvider(provider) {
 function activeDocuments() {
   return scopeProvider() ?? fallbackDocuments;
 }
+function versionsFor(map) {
+  let v = writeVersions.get(map);
+  if (!v) writeVersions.set(map, v = /* @__PURE__ */ new Map());
+  return v;
+}
+function bumpVersion(map, id) {
+  const v = versionsFor(map);
+  v.set(id, (v.get(id) ?? 0) + 1);
+}
+function safeFree(engine) {
+  try {
+    engine.free?.();
+  } catch {
+  }
+}
+function dropEngineIn(map, id) {
+  const cache2 = engineCaches.get(map);
+  const entry = cache2?.get(id);
+  if (!entry) return;
+  cache2.delete(id);
+  safeFree(entry.engine);
+}
+function markDocumentWritten(documentId) {
+  bumpVersion(activeDocuments(), documentId);
+}
+function takeCachedEngine(documentId, doc) {
+  const map = activeDocuments();
+  const cache2 = engineCaches.get(map);
+  const entry = cache2?.get(documentId);
+  if (!entry) return null;
+  cache2.delete(documentId);
+  if (entry.doc === doc && map.get(documentId) === doc && entry.version === (versionsFor(map).get(documentId) ?? 0)) {
+    return entry.engine;
+  }
+  safeFree(entry.engine);
+  return null;
+}
+function storeEngine(documentId, doc, engine) {
+  const map = activeDocuments();
+  if (map.get(documentId) !== doc) {
+    safeFree(engine);
+    return;
+  }
+  let cache2 = engineCaches.get(map);
+  if (!cache2) engineCaches.set(map, cache2 = /* @__PURE__ */ new Map());
+  const prev = cache2.get(documentId);
+  if (prev && prev.engine !== engine) safeFree(prev.engine);
+  cache2.set(documentId, { engine, doc, version: versionsFor(map).get(documentId) ?? 0 });
+}
+function dropEngine(documentId) {
+  dropEngineIn(activeDocuments(), documentId);
+}
+function freeScopeEngines(map) {
+  const cache2 = engineCaches.get(map);
+  if (!cache2) return;
+  for (const entry of cache2.values()) safeFree(entry.engine);
+  cache2.clear();
+}
 function randomSuffix() {
   const bytes = new Uint8Array(9);
   globalThis.crypto.getRandomValues(bytes);
@@ -51440,9 +51526,10 @@ function resolveDocInput(args, inlineKeys = ["document"]) {
 function cloneDoc(doc) {
   return JSON.parse(JSON.stringify(doc));
 }
-function recordHistorySnapshot(documentId) {
+function recordHistorySnapshot(documentId, toolName) {
   const doc = documents.get(documentId);
   if (!doc) return;
+  if (!toolName || !ENGINE_MANAGED_TOOLS.has(toolName)) markDocumentWritten(documentId);
   const stack = sessionHistory.get(documentId) ?? [];
   stack.push(cloneDoc(doc));
   if (stack.length > MAX_HISTORY) stack.shift();
@@ -51461,6 +51548,7 @@ function undoLastSnapshot(documentId) {
 }
 function clearHistory(documentId) {
   sessionHistory.delete(documentId);
+  dropEngine(documentId);
   lastChangedParts.delete(documentId);
   lastTriangleCount.delete(documentId);
 }
@@ -51478,7 +51566,7 @@ function recordTriangles(documentId, triangles) {
 function getLastTriangles(documentId) {
   return lastTriangleCount.get(documentId) ?? null;
 }
-var fallbackDocuments, scopeProvider, documents, nextId, BOOT_TOKEN_LEN, BOOT_TOKEN, durabilityProbe, documentEnterHooks, MAX_HISTORY, sessionHistory, lastChangedParts, lastTriangleCount;
+var fallbackDocuments, scopeProvider, documents, engineCaches, writeVersions, ENGINE_MANAGED_TOOLS, nextId, BOOT_TOKEN_LEN, BOOT_TOKEN, durabilityProbe, documentEnterHooks, MAX_HISTORY, sessionHistory, lastChangedParts, lastTriangleCount;
 var init_session_core = __esm({
   "src/tools/session-core.ts"() {
     "use strict";
@@ -51488,13 +51576,28 @@ var init_session_core = __esm({
     documents = {
       has: (id) => activeDocuments().has(id),
       get: (id) => activeDocuments().get(id),
-      set: (id, doc) => activeDocuments().set(id, doc),
-      delete: (id) => activeDocuments().delete(id),
-      clear: () => activeDocuments().clear(),
+      set: (id, doc) => {
+        const map = activeDocuments();
+        bumpVersion(map, id);
+        return map.set(id, doc);
+      },
+      delete: (id) => {
+        const map = activeDocuments();
+        dropEngineIn(map, id);
+        return map.delete(id);
+      },
+      clear: () => {
+        const map = activeDocuments();
+        freeScopeEngines(map);
+        map.clear();
+      },
       get size() {
         return activeDocuments().size;
       }
     };
+    engineCaches = /* @__PURE__ */ new WeakMap();
+    writeVersions = /* @__PURE__ */ new WeakMap();
+    ENGINE_MANAGED_TOOLS = /* @__PURE__ */ new Set(["create", "update", "delete", "set_material"]);
     nextId = 1;
     BOOT_TOKEN_LEN = 4;
     BOOT_TOKEN = randomSuffix().slice(0, BOOT_TOKEN_LEN);
@@ -53131,7 +53234,21 @@ function durabilityWarning() {
 }
 function runInSessionScope(user, fn) {
   if (!user) return fn();
-  return sessionScope.run({ documents: /* @__PURE__ */ new Map(), user }, fn);
+  const documents2 = /* @__PURE__ */ new Map();
+  const release = () => freeScopeEngines(documents2);
+  let out;
+  try {
+    out = sessionScope.run({ documents: documents2, user }, fn);
+  } catch (e) {
+    release();
+    throw e;
+  }
+  if (out && typeof out.then === "function") {
+    out.then(release, release);
+  } else {
+    release();
+  }
+  return out;
 }
 function currentUser() {
   return sessionScope.getStore()?.user ?? null;
@@ -55719,8 +55836,128 @@ function dispatchRegistryTool(toolName, args, engine) {
   }
   return result;
 }
-function runMutation(toolName, rawArgs, doc, documentId) {
+function toStableId(doc, v) {
+  if (typeof v !== "string" && typeof v !== "number") return v;
+  return rootForPartId(doc, v)?.partId ?? String(v);
+}
+function owningRootIndex(doc, nodeId) {
+  const exact = doc.roots.findIndex((r) => String(r.root) === nodeId);
+  if (exact >= 0) return exact;
+  return doc.roots.findIndex((r) => {
+    const stack = [r.root];
+    const seen = /* @__PURE__ */ new Set();
+    while (stack.length) {
+      const id = String(stack.pop());
+      if (id === nodeId) return true;
+      if (seen.has(id)) continue;
+      seen.add(id);
+      const op = doc.nodes[id]?.op;
+      if (!op) continue;
+      for (const k of ["child", "left", "right"]) if (op[k] !== void 0) stack.push(op[k]);
+      if (Array.isArray(op.children)) stack.push(...op.children);
+    }
+    return false;
+  });
+}
+function nodeRefToStableId(doc, v) {
+  if (typeof v === "number" || typeof v === "string" && /^\d+$/.test(v)) {
+    const idx = owningRootIndex(doc, String(v));
+    if (idx >= 0) return partIdForRoot(doc, idx);
+  }
+  return toStableId(doc, v);
+}
+function engineArgs(toolName, args, doc) {
+  const out = toolName === "create" ? applyParamDefaults({ ...args }) : { ...args };
+  if ("part_id" in out) out.part_id = toStableId(doc, out.part_id);
+  if (Array.isArray(out.part_ids)) out.part_ids = out.part_ids.map((v) => toStableId(doc, v));
+  if (out.parent_part_id !== void 0) out.parent_part_id = nodeRefToStableId(doc, out.parent_part_id);
+  if (toolName === "update" && out.node_id !== void 0) {
+    out.node_id = nodeRefToStableId(doc, out.node_id);
+  }
+  if (toolName === "create" && out.params && typeof out.params === "object") {
+    const params = { ...out.params };
+    for (const key3 of ["left", "right", "child"]) {
+      if (key3 in params) params[key3] = nodeRefToStableId(doc, params[key3]);
+    }
+    out.params = params;
+  }
+  return out;
+}
+function engineErrorMessage(toolName, args, err9) {
+  switch (err9.kind) {
+    case "unknown_id":
+      return `${toolName}: no part with id "${err9.id ?? "?"}"`;
+    case "invalid":
+      return enrichPlannerError(toolName, args, `${toolName}: ${err9.message ?? "invalid arguments"}`);
+    default:
+      return `${toolName}: ${err9.message ?? err9.kind}`;
+  }
+}
+function runMutationViaEngine(toolName, toolArgs, doc, documentId) {
+  if (!ENGINE_LOWERED_TOOLS.has(toolName)) return null;
+  if (process.env.VCAD_MCP_ENGINE_APPLY === "0") return null;
+  const wasm3 = getKernelWasmSync();
+  const factory = wasm3?.WasmDocumentEngine;
+  if (!factory || typeof factory.withReplica !== "function") return null;
+  const cachedEngine = takeCachedEngine(documentId, doc);
+  const engine = cachedEngine ?? factory.withReplica(0);
+  let keep = false;
+  try {
+    if (typeof engine.apply_tool !== "function") return null;
+    const deprecation = typeof toolArgs.part_id === "string" ? partIdDeprecation(toolArgs.part_id, rootForPartId(doc, toolArgs.part_id)) : void 0;
+    const args = engineArgs(toolName, toolArgs, doc);
+    if (!cachedEngine) engine.import_ir(JSON.stringify(doc));
+    const envelope = JSON.parse(engine.apply_tool(toolName, JSON.stringify(args)));
+    if (!envelope.ok || !envelope.result) {
+      const err9 = envelope.error ?? { kind: "invalid", message: "engine returned no result" };
+      if (err9.kind === "unsupported") return null;
+      throw new Error(engineErrorMessage(toolName, args, err9));
+    }
+    const next = envelope.result.document;
+    const parts = envelope.result.parts ?? [];
+    for (const p of parts) {
+      if (!p.name) continue;
+      const rootIdx = next.roots.findIndex((_, i) => next.partIds?.[String(next.roots[i].root)] === p.id);
+      const rootNode = rootIdx >= 0 ? next.nodes[String(next.roots[rootIdx].root)] : void 0;
+      if (rootNode && !rootNode.name) rootNode.name = p.name;
+    }
+    for (const k of Object.keys(doc)) delete doc[k];
+    Object.assign(doc, next);
+    storeEngine(documentId, doc, engine);
+    keep = true;
+    const warnings = [...envelope.result.warnings ?? [], ...deprecation ? [deprecation] : []];
+    const payload = { document_id: documentId };
+    if (toolName === "delete") {
+      payload.removed = args.part_id;
+    } else if (toolName === "set_material") {
+      payload.part_id = args.part_id ?? args.part_ids;
+      payload.material = toolArgs.material;
+    } else {
+      const partId = envelope.result.createdFeatureId ?? (typeof args.part_id === "string" ? args.part_id : void 0);
+      if (partId) {
+        payload.part_id = partId;
+        const part = parts.find((p) => p.id === partId);
+        const root = rootForPartId(doc, partId);
+        const nodeId = part?.primitiveNodeId ?? root?.entry.root;
+        if (nodeId !== void 0) payload.node_id = nodeId;
+      }
+    }
+    if (envelope.result.consumedPartIds?.length) {
+      payload.consumed_part_ids = envelope.result.consumedPartIds;
+    }
+    if (warnings.length) payload.warnings = warnings;
+    return { content: [{ type: "text", text: JSON.stringify(payload) }] };
+  } finally {
+    if (!keep) engine.free?.();
+  }
+}
+function runMutation(toolName, rawArgs, doc, documentId, opts = {}) {
   const toolArgs = normalizeNodeRefs(toolName, rawArgs, doc);
+  if (opts.engine !== false) {
+    const viaEngine = runMutationViaEngine(toolName, toolArgs, doc, documentId);
+    if (viaEngine) return viaEngine;
+  }
+  if (documentId) markDocumentWritten(documentId);
   if (toolName === "delete") {
     const partId = String(toolArgs.part_id ?? "");
     if (!partId) throw new Error("delete: missing `part_id`");
@@ -55905,13 +56142,15 @@ function childrenOf(op) {
       return [];
   }
 }
-var BROWSER_ONLY_TOOLS, DEFERRED_TOOLS, READ_ONLY_REGISTRY_TOOLS, MCP_DESCRIPTIONS, CREATE_PARAM_DEFAULTS, CREATE_PARAM_HINTS, NODE_REF_PARAM_KEYS;
+var BROWSER_ONLY_TOOLS, DEFERRED_TOOLS, READ_ONLY_REGISTRY_TOOLS, MCP_DESCRIPTIONS, CREATE_PARAM_DEFAULTS, CREATE_PARAM_HINTS, NODE_REF_PARAM_KEYS, ENGINE_LOWERED_TOOLS;
 var init_registry_dispatch = __esm({
   "src/tools/registry-dispatch.ts"() {
     "use strict";
     init_dist3();
     init_session2();
+    init_session_core();
     init_part_ids2();
+    init_dist();
     init_pose();
     init_integrity();
     init_measure();
@@ -55967,6 +56206,26 @@ var init_registry_dispatch = __esm({
       edge_blend: '{child: nodeId, edges: {type: "All"} | {type: "Near", point: {x,y,z}} | {type: "Direction", axis: {x,y,z}, tol_deg}, profile: {type: "Constant", size, shape} | {type: "Keyed", keys: [{t, size, shape}]}} \u2014 shape 0 = chamfer, 1 = fillet; size in mm'
     };
     NODE_REF_PARAM_KEYS = ["child", "left", "right", "sketch"];
+    ENGINE_LOWERED_TOOLS = /* @__PURE__ */ new Set([
+      "create",
+      "update",
+      "delete",
+      "set_material",
+      "linear_pattern",
+      "circular_pattern",
+      "mirror",
+      "translate",
+      "rotate",
+      "scale",
+      "union",
+      "difference",
+      "intersection",
+      "fillet",
+      "chamfer",
+      "shell",
+      "tube",
+      "polyline_tube"
+    ]);
   }
 });
 
@@ -58041,7 +58300,10 @@ function applyOps(doc, ops, documentId) {
         name,
         resolveSymbolicRefs(args, createdIds, i, doc),
         doc,
-        documentId
+        documentId,
+        // Legacy planner: "@N" and raw numeric child refs address the
+        // planner's node numbering (see runMutation).
+        { engine: false }
       );
     } catch (err9) {
       throw new BatchOpError(i, name, err9);
@@ -86871,7 +87133,7 @@ async function createServer(existingEngine, context = { user: null }) {
         }
       }
       if (incomingId && name !== "undo" && def?.behavior.writesDoc && documents.has(incomingId)) {
-        recordHistorySnapshot(incomingId);
+        recordHistorySnapshot(incomingId, name);
       }
       const runTool = async () => {
         if (!def) {
@@ -87229,8 +87491,8 @@ var init_server3 = __esm({
     init_order_feed();
     init_animate();
     PKG_VERSION = (() => {
-      if ("0.10.0-main.112") {
-        return "0.10.0-main.112";
+      if ("0.10.0-main.114") {
+        return "0.10.0-main.114";
       }
       try {
         const req = createRequire2(import.meta.url);
@@ -87239,8 +87501,8 @@ var init_server3 = __esm({
         return "0.0.0";
       }
     })();
-    BUILD_SHA = "cdbfe885b0a0ed7b3492e33d7b2f4a1da4f3bd6c";
-    BUILD_TIME = "2026-10-20T22:45:38.715Z";
+    BUILD_SHA = "a680346430d6b8e6acd07ec8f2821f14ccd6a05f";
+    BUILD_TIME = "2026-10-20T23:26:44.068Z";
     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.112",
+  "version": "0.10.0-main.114",
   "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": "cdbfe885b0a0ed7b3492e33d7b2f4a1da4f3bd6c",
-    "builtAt": "2026-10-20T22:45:38.715Z"
+    "sha": "a680346430d6b8e6acd07ec8f2821f14ccd6a05f",
+    "builtAt": "2026-10-20T23:26:44.068Z"
   }
 }

package/vcad_kernel_wasm_bg.wasm

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/vcad_kernel_wasm_bg.wasm
-size: 35340760 bytes
-sha256: e9098257eb46c289fd8d98352eacdb6b9cb8bbc76aca2ba3db7b1bfff3d8a83a
+size: 35323488 bytes
+sha256: 3a4f66bfab16cafe28c6409cd71c6dedcf0a910a856e0649adcff9dce4b7db5a