@vcad/mcp 0.10.0-main.133 → 0.10.0-main.135

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 ed9b701622258f961cdbb3fa2c2430c283a8fc5b at 2026-10-21T17:47:36.984Z. Source: https://github.com/ecto/vcad
+Built from b446cf64b98e8aa00e81db540574199f61784778 at 2026-10-22T11:55:20.128Z. Source: https://github.com/ecto/vcad

package/index.mjs

@@ -10867,18 +10867,95 @@ var init_delta = __esm({
   }
 });
 
+// ../engine/dist/scene-convert.js
+function wasmResultToScene(result) {
+  const toMesh = (m) => ({
+    positions: m.positions instanceof Float32Array ? m.positions : new Float32Array(m.positions),
+    indices: m.indices instanceof Uint32Array ? m.indices : new Uint32Array(m.indices),
+    normals: m.normals ? m.normals instanceof Float32Array ? m.normals : new Float32Array(m.normals) : void 0,
+    faceKinds: m.faceKinds ? m.faceKinds instanceof Uint8Array ? m.faceKinds : new Uint8Array(m.faceKinds) : void 0
+  });
+  return {
+    parts: result.parts.map((p) => ({ mesh: toMesh(p.mesh), material: p.material })),
+    partDefs: result.partDefs?.map((pd) => ({ id: pd.id, mesh: toMesh(pd.mesh) })),
+    instances: result.instances?.map((inst) => ({
+      instanceId: inst.instance_id,
+      partDefId: inst.part_def_id,
+      name: inst.name,
+      mesh: toMesh(inst.mesh),
+      material: inst.material,
+      transform: inst.transform
+    })),
+    clashes: result.clashes.map(toMesh),
+    failures: result.failures,
+    timing: result.timing
+  };
+}
+function postProcessEmbroidery(scene, doc, kernel2) {
+  const visibleRoots = doc.roots.filter((e) => e.visible !== false);
+  let changed = false;
+  const parts = scene.parts.map((p, i) => {
+    if (p.mesh.positions.length === 0 && i < visibleRoots.length) {
+      const emb = findEmbroideryPattern(visibleRoots[i].root, doc.nodes);
+      if (emb) {
+        changed = true;
+        const baseMesh = embroideryPatternToMeshWithKernel(emb.pattern, kernel2);
+        const mesh = transformMeshWithKernel(baseMesh, emb.transform, kernel2);
+        return { mesh, material: p.material };
+      }
+    }
+    return p;
+  });
+  return changed ? { ...scene, parts } : scene;
+}
+function postProcessSheetMetal(scene, doc, kernel2) {
+  const visibleRoots = doc.roots.filter((e) => e.visible !== false);
+  let changed = false;
+  const parts = scene.parts.map((p, i) => {
+    if (p.mesh.positions.length === 0 && i < visibleRoots.length) {
+      try {
+        const smPart = resolveSheetMetalPart(visibleRoots[i].root, doc.nodes, kernel2);
+        if (smPart) {
+          changed = true;
+          return { ...smPart, material: p.material };
+        }
+      } catch (e) {
+        console.warn(`[worker] sheet-metal eval failed at root[${i}]:`, e);
+      }
+    }
+    return p;
+  });
+  return changed ? { ...scene, parts } : scene;
+}
+function postProcessScene(scene, doc, kernel2) {
+  return postProcessSheetMetal(postProcessEmbroidery(scene, doc, kernel2), doc, kernel2);
+}
+var init_scene_convert = __esm({
+  "../engine/dist/scene-convert.js"() {
+    "use strict";
+    init_evaluate();
+  }
+});
+
 // ../engine/dist/engine-host.js
+function resetEvaluator(host) {
+  host.evaluator?.free?.();
+  host.evaluator = null;
+}
 function handleEngineRequest(host, req) {
   try {
     let envelope;
     let bytes;
+    let scene;
     switch (req.op) {
       case "init":
+        resetEvaluator(host);
         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":
+        resetEvaluator(host);
         host.engine?.free();
         host.engine = host.Engine.load(req.bytes);
         envelope = host.engine.stateEnvelope();
@@ -10887,13 +10964,30 @@ function handleEngineRequest(host, req) {
         const engine2 = host.engine;
         if (!engine2)
           return { ok: false, message: "engine not initialized" };
+        if ((req.op === "apply" || req.op === "applyTool") && req.expectHash !== void 0 && engine2.stateHash() !== req.expectHash) {
+          return {
+            ok: true,
+            stale: true,
+            hash: engine2.stateHash(),
+            canUndo: engine2.can_undo(),
+            canRedo: engine2.can_redo()
+          };
+        }
         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
+        else if (req.op === "evaluate") {
+          if (!engine2.evaluateIncremental || !host.Evaluator) {
+            return { ok: false, message: "engine host cannot evaluate (kernel too old)" };
+          }
+          host.evaluator ??= new host.Evaluator();
+          const overlay = req.overlay ?? {};
+          const hasOverlay = Object.keys(overlay.parameters ?? {}).length > 0 || Object.keys(overlay.bindings ?? {}).length > 0;
+          scene = wasmResultToScene(engine2.evaluateIncremental(host.evaluator, hasOverlay ? JSON.stringify(overlay) : "", req.skipClashDetection ?? false));
+        } else
           bytes = engine2.save();
       }
     }
@@ -10902,6 +10996,7 @@ function handleEngineRequest(host, req) {
       ok: true,
       envelope,
       bytes,
+      scene,
       hash: engine.stateHash(),
       canUndo: engine.can_undo(),
       canRedo: engine.can_redo()
@@ -10910,16 +11005,31 @@ function handleEngineRequest(host, req) {
     return { ok: false, message: e instanceof Error ? e.message : String(e) };
   }
 }
-function inProcessTransport(Engine2) {
-  const host = { Engine: Engine2, engine: null };
+function inProcessTransport(Engine2, Evaluator) {
+  const host = { Engine: Engine2, engine: null, Evaluator };
   return {
     request: async (req) => handleEngineRequest(host, req),
     dispose: () => {
+      resetEvaluator(host);
       host.engine?.free();
       host.engine = null;
     }
   };
 }
+function sharedEngineTransport(getEngine, Evaluator) {
+  const ownerOnly = function() {
+    throw new Error("shared engine: the owner constructs engines");
+  };
+  const host = { Engine: ownerOnly, engine: null, Evaluator };
+  return {
+    request: async (req) => {
+      host.engine = getEngine();
+      const r = req.op === "init" || req.op === "load" ? { op: "state" } : req;
+      return handleEngineRequest(host, r);
+    },
+    dispose: () => resetEvaluator(host)
+  };
+}
 function workerTransport(worker) {
   let next = 0;
   const pending2 = /* @__PURE__ */ new Map();
@@ -10942,6 +11052,7 @@ var init_engine_host = __esm({
   "../engine/dist/engine-host.js"() {
     "use strict";
     init_delta();
+    init_scene_convert();
     EngineHostError = class extends Error {
       constructor(message) {
         super(message);
@@ -10989,6 +11100,25 @@ var init_engine_host = __esm({
       applyTool(tool, args) {
         return this.delta({ op: "applyTool", tool, args });
       }
+      /**
+       * Evaluate the hosted document where it lives (the worker, when the
+       * engine is in one) through the host's incremental evaluator: the
+       * document is never serialized and only what changed since the last
+       * evaluation is redone. Ordered after every command already sent, so the
+       * scene is of the state those commands produced. Pass `kernel` to run the
+       * TS post-passes (embroidery, sheet metal) against this client's view.
+       */
+      evaluate(opts = {}) {
+        return this.enqueue(async () => {
+          const r = this.check(await this.transport.request({
+            op: "evaluate",
+            overlay: opts.overlay,
+            skipClashDetection: opts.skipClashDetection
+          }));
+          const scene = r.scene;
+          return opts.kernel && this.view ? postProcessScene(scene, this.view.document, opts.kernel) : scene;
+        });
+      }
       /** Snapshot the engine (document + history). */
       save() {
         return this.enqueue(async () => {
@@ -11009,10 +11139,17 @@ var init_engine_host = __esm({
       }
       delta(req) {
         return this.enqueue(async () => {
-          const base = this.view;
-          if (!base)
+          if (!this.view)
             throw new EngineHostError("engine not initialized");
-          const r = this.check(await this.transport.request(req));
+          let r = this.check(await this.transport.request({ ...req, expectHash: this.flags.hash }));
+          if (r.stale) {
+            const full = this.check(await this.transport.request({ op: "state" }));
+            this.view = stateFromEnvelope(full.envelope);
+            r = this.check(await this.transport.request({ ...req, expectHash: this.flags.hash }));
+            if (r.stale)
+              throw new EngineHostError("engine changed during resync");
+          }
+          const base = this.view;
           const delta = parseDeltaEnvelope(r.envelope);
           const { state, changes } = applyEngineDelta(base, delta);
           this.view = state;
@@ -12310,6 +12447,7 @@ __export(dist_exports, {
   searchEcadParts: () => searchEcadParts,
   searchParts: () => searchParts,
   semanticDiff: () => semanticDiff,
+  sharedEngineTransport: () => sharedEngineTransport,
   solveDesignConstraints: () => solveDesignConstraints2,
   solveForwardKinematics: () => solveForwardKinematics2,
   stateFromEnvelope: () => stateFromEnvelope,
@@ -31847,6 +31985,7 @@ var init_document_store = __esm({
     init_esm2();
     init_wasm_singleton2();
     init_engine_command();
+    init_dist();
     init_sketch_constraint_persist();
     init_dist2();
     init_dist2();
@@ -31873,6 +32012,27 @@ var init_document_store = __esm({
       // CRDT bridge state
       _crdtEngine: null,
       _crdtEngineClass: null,
+      _engineClient: new DocumentEngineClient(sharedEngineTransport(() => get()._crdtEngine)),
+      dispatch: async (command) => {
+        const readOnly = useUiStore.getState().readOnlyShare;
+        if (readOnly) {
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new CustomEvent("vcad:fork-prompt", { detail: readOnly }));
+          }
+          return void 0;
+        }
+        const client = get()._engineClient;
+        if (!client.state)
+          await client.init();
+        const outcome = await client.apply(command);
+        for (const w of outcome.warnings)
+          console.warn(`[vcad] ${w}`);
+        set(applyLegacyResult({
+          document: outcome.state.document,
+          parts: outcome.state.parts
+        }));
+        return outcome.createdFeatureId;
+      },
       _initCrdt: (EngineClass) => {
         const existing = get()._crdtEngine;
         const existingClass = get()._crdtEngineClass;
@@ -31977,10 +32137,8 @@ var init_document_store = __esm({
           return "";
         }
       },
-      removePart: (partId) => {
-        const engine = get()._crdtEngine;
-        const result = applyCommand(engine, { type: "delete_feature", id: partId });
-        set(applyApiResult(result));
+      removePart: async (partId) => {
+        await get().dispatch({ type: "delete_feature", id: partId });
       },
       setTranslation: (partId, offset) => {
         const engine = get()._crdtEngine;
@@ -32064,10 +32222,8 @@ var init_document_store = __esm({
         const result = applyCommand(engine, { type: "set_param", id: partId, key: key3, value });
         set(applyLegacyResult(result));
       },
-      updateBooleanType: (partId, newType) => {
-        const engine = get()._crdtEngine;
-        const result = applyCommand(engine, { type: "set_param", id: partId, key: "boolean_type", value: crdtStr(newType) });
-        set(applyLegacyResult(result));
+      updateBooleanType: async (partId, newType) => {
+        await get().dispatch({ type: "set_param", id: partId, key: "boolean_type", value: crdtStr(newType) });
       },
       applyBoolean: (type, partIdA, partIdB) => {
         const engine = get()._crdtEngine;
@@ -32341,9 +32497,8 @@ var init_document_store = __esm({
           return null;
         }
       },
-      setThreadColor: (nodeId, threadIdx, color) => {
+      setThreadColor: async (nodeId, threadIdx, color) => {
         const state = get();
-        const engine = state._crdtEngine;
         const part = state.parts.find((p) => p.kind === "embroidery-pattern" && p.patternNodeId === nodeId);
         if (!part)
           return;
@@ -32353,12 +32508,10 @@ var init_document_store = __esm({
         const d = structuredClone(design);
         if (d.threads[threadIdx])
           d.threads[threadIdx].color = color;
-        const result = applyCommand(engine, { type: "set_param", id: part.id, key: "design", value: crdtStr(JSON.stringify(d)) });
-        set(applyLegacyResult(result));
+        await get().dispatch({ type: "set_param", id: part.id, key: "design", value: crdtStr(JSON.stringify(d)) });
       },
-      setThreadName: (nodeId, threadIdx, name) => {
+      setThreadName: async (nodeId, threadIdx, name) => {
         const state = get();
-        const engine = state._crdtEngine;
         const part = state.parts.find((p) => p.kind === "embroidery-pattern" && p.patternNodeId === nodeId);
         if (!part)
           return;
@@ -32368,8 +32521,7 @@ var init_document_store = __esm({
         const d = structuredClone(design);
         if (d.threads[threadIdx])
           d.threads[threadIdx].name = name;
-        const result = applyCommand(engine, { type: "set_param", id: part.id, key: "design", value: crdtStr(JSON.stringify(d)) });
-        set(applyLegacyResult(result));
+        await get().dispatch({ type: "set_param", id: part.id, key: "design", value: crdtStr(JSON.stringify(d)) });
       },
       setStitchGroupFillParams: (nodeId, groupIdx, params) => {
         const state = get();
@@ -32604,15 +32756,11 @@ var init_document_store = __esm({
         set(applyApiResult(result));
         return result.createdFeatureId ?? null;
       },
-      setPartMaterial: (partId, materialKey) => {
-        const engine = get()._crdtEngine;
-        const result = applyCommand(engine, { type: "set_material", id: partId, material: materialKey });
-        set(applyApiResult(result));
+      setPartMaterial: async (partId, materialKey) => {
+        await get().dispatch({ type: "set_material", id: partId, material: materialKey });
       },
-      renamePart: (partId, name) => {
-        const engine = get()._crdtEngine;
-        const result = applyCommand(engine, { type: "rename", id: partId, name });
-        set(applyApiResult(result));
+      renamePart: async (partId, name) => {
+        await get().dispatch({ type: "rename", id: partId, name });
       },
       undo: () => {
         const engine = get()._crdtEngine;
@@ -32645,10 +32793,8 @@ var init_document_store = __esm({
         const result = applyCommand(engine, { type: "set_param", id: instanceId, key: "transform", value: crdtStr(JSON.stringify(transform2)) });
         set(applyLegacyResult(result));
       },
-      setInstanceMaterial: (instanceId, materialKey) => {
-        const engine = get()._crdtEngine;
-        const result = applyCommand(engine, { type: "set_param", id: instanceId, key: "material", value: crdtStr(materialKey) });
-        set(applyLegacyResult(result));
+      setInstanceMaterial: async (instanceId, materialKey) => {
+        await get().dispatch({ type: "set_param", id: instanceId, key: "material", value: crdtStr(materialKey) });
       },
       setJointState: (jointId, jointState) => {
         const engine = get()._crdtEngine;
@@ -32719,10 +32865,8 @@ var init_document_store = __esm({
         const result = applyCommand(engine, { type: "delete_feature", id: instanceId });
         set(applyApiResult(result));
       },
-      deleteJoint: (jointId) => {
-        const engine = get()._crdtEngine;
-        const result = applyCommand(engine, { type: "delete_feature", id: jointId });
-        set(applyApiResult(result));
+      deleteJoint: async (jointId) => {
+        await get().dispatch({ type: "delete_feature", id: jointId });
       },
       setGroundInstance: (instanceId) => {
         const state = get();
@@ -32738,10 +32882,8 @@ var init_document_store = __esm({
         const result = applyCommand(engine, { type: "set_param", id: instanceId, key: "is_ground", value: crdtBool(true) });
         set(applyLegacyResult(result));
       },
-      renameInstance: (instanceId, name) => {
-        const engine = get()._crdtEngine;
-        const result = applyCommand(engine, { type: "set_param", id: instanceId, key: "name", value: crdtStr(name) });
-        set(applyLegacyResult(result));
+      renameInstance: async (instanceId, name) => {
+        await get().dispatch({ type: "set_param", id: instanceId, key: "name", value: crdtStr(name) });
       },
       setDocumentMeta: (id, name) => {
         set({ documentId: id, documentName: name });
@@ -32800,10 +32942,8 @@ var init_document_store = __esm({
           set(applyApiResult(envelope.result));
         return envelope;
       },
-      setPartVisible: (partId, visible) => {
-        const engine = get()._crdtEngine;
-        const result = applyCommand(engine, { type: "set_visible", id: partId, visible });
-        set(applyApiResult(result));
+      setPartVisible: async (partId, visible) => {
+        await get().dispatch({ type: "set_visible", id: partId, visible });
       },
       reorderPart: (partId, newIndex) => {
         const state = get();
@@ -41715,6 +41855,19 @@ var init_CHANGELOG = __esm({
             "lighting"
           ]
         },
+        {
+          id: "2026-10-21-photoreal-look-textures",
+          version: "0.10.0",
+          date: "2026-10-21",
+          category: "feat",
+          title: "Material looks and wood/fabric textures in photoreal",
+          summary: "--look applies render-time material overrides by material or part (colours, roughness, emission) plus procedural oak, fabric and triplanar image textures.",
+          features: [
+            "photoreal",
+            "render",
+            "materials"
+          ]
+        },
         {
           id: "2026-10-21-photoreal-focus-dist",
           version: "0.10.0",
@@ -87126,8 +87279,8 @@ var init_server3 = __esm({
     init_order_feed();
     init_animate();
     PKG_VERSION = (() => {
-      if ("0.10.0-main.133") {
-        return "0.10.0-main.133";
+      if ("0.10.0-main.135") {
+        return "0.10.0-main.135";
       }
       try {
         const req = createRequire2(import.meta.url);
@@ -87136,8 +87289,8 @@ var init_server3 = __esm({
         return "0.0.0";
       }
     })();
-    BUILD_SHA = "ed9b701622258f961cdbb3fa2c2430c283a8fc5b";
-    BUILD_TIME = "2026-10-21T17:47:36.984Z";
+    BUILD_SHA = "b446cf64b98e8aa00e81db540574199f61784778";
+    BUILD_TIME = "2026-10-22T11:55:20.128Z";
     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.133",
+  "version": "0.10.0-main.135",
   "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": "ed9b701622258f961cdbb3fa2c2430c283a8fc5b",
-    "builtAt": "2026-10-21T17:47:36.984Z"
+    "sha": "b446cf64b98e8aa00e81db540574199f61784778",
+    "builtAt": "2026-10-22T11:55:20.128Z"
   }
 }