@vcad/mcp 0.9.4-main.20 → 0.9.4-main.22

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 c5938bcd3843b4e600b28e18b5472d41337bd478 at 2026-07-25T14:49:15.914Z. Source: https://github.com/ecto/vcad
+Built from 34f31195abaa154019b219eda75a0e900b7ece93 at 2026-07-25T19:25:56.201Z. Source: https://github.com/ecto/vcad

package/index.mjs

@@ -40878,6 +40878,24 @@ var init_CHANGELOG = __esm({
             "run_drc"
           ]
         },
+        {
+          id: "2026-07-25-router-pair-connector-vias",
+          version: "0.9.4",
+          date: "2026-07-25",
+          category: "fix",
+          title: "Autoroute no longer routes traces through diff-pair vias",
+          summary: "Differential-pair breakout vias were written onto the board but never registered with the router's clearance oracle, so later nets were routed straight through the barrel.",
+          features: [
+            "pcb",
+            "routing",
+            "drc"
+          ],
+          mcpTools: [
+            "route_nets",
+            "route_diff_pair",
+            "run_drc"
+          ]
+        },
         {
           id: "2026-07-25-router-diff-pair-si",
           version: "0.9.4",
@@ -40899,6 +40917,45 @@ var init_CHANGELOG = __esm({
             "build_receipt"
           ]
         },
+        {
+          id: "2026-07-25-impedance-geometry-per-layer",
+          version: "0.9.4",
+          date: "2026-07-25",
+          category: "feat",
+          title: "Controlled-impedance geometry solved per layer",
+          summary: "A net class can declare a target impedance and vcad derives the trace and diff-pair width per layer from the board stackup \u2014 microstrip on the outers, stripline on the inners \u2014 with the router preferring layers where the geometry is impedance-correct.",
+          features: [
+            "pcb",
+            "autorouter",
+            "diff-pairs",
+            "signal-integrity",
+            "stackup"
+          ],
+          mcpTools: [
+            "route_nets",
+            "set_design_rules",
+            "set_stackup",
+            "calc_impedance",
+            "build_receipt"
+          ]
+        },
+        {
+          id: "2026-07-25-gerber-pad-rotation",
+          version: "0.9.4",
+          date: "2026-07-25",
+          category: "fix",
+          title: "Gerber export honours pad rotation",
+          summary: "Pads on rotated footprints are exported with the correct orientation; previously every non-square pad was flashed axis-aligned, shorting fine-pitch packages.",
+          features: [
+            "pcb",
+            "gerber",
+            "fabrication"
+          ],
+          mcpTools: [
+            "export_gerber",
+            "fab_prep"
+          ]
+        },
         {
           id: "2026-07-24-visionos-app",
           version: "0.9.4",
@@ -60734,16 +60791,61 @@ async function addCoil(args, opts) {
       if ("error" in lr) return fail2(`layers entry: ${lr.error}`);
     }
     const stitchVias = [];
-    const perLayerLen = segLength(pts);
+    const dTheta = sign * turns * 2 * Math.PI;
+    const spiralSteps = Math.max(2, Math.ceil(turns * segmentsPerTurn));
+    const drill = pcb.rules.defaultRules.viaDrill;
+    const holePitch = drill + 0.5 + 0.05;
+    const staggerR = Math.max(innerR, traceWidth);
+    const stagger = Math.min(Math.PI / 4, holePitch / (2 * staggerR));
+    const boundary = (li) => li < 0 ? theta0 + dTheta : theta0 - li * dTheta - sign * (li + 1) * stagger;
+    const layerPts = [];
+    for (let li = 0; li < layersIn.length; li++) {
+      const thetaFrom = boundary(li - 1);
+      const thetaTo = boundary(li);
+      const outward = li % 2 === 1;
+      const rFrom = outward ? innerR : outerR;
+      const rTo = outward ? outerR : innerR;
+      const lp = [];
+      for (let s = 0; s <= spiralSteps; s++) {
+        const t2 = s / spiralSteps;
+        const theta = thetaFrom + t2 * (thetaTo - thetaFrom);
+        const r = rFrom + t2 * (rTo - rFrom);
+        const p = {
+          x: round33(center.x + r * Math.cos(theta)),
+          y: round33(center.y + r * Math.sin(theta))
+        };
+        const prev = lp[lp.length - 1];
+        if (!prev || prev.x !== p.x || prev.y !== p.y) lp.push(p);
+      }
+      layerPts.push(lp);
+    }
+    if (innerLeadOut > 0) {
+      for (let li = 0; li + 1 < layersIn.length; li++) {
+        if (li % 2 !== 0) continue;
+        const end = layerPts[li][layerPts[li].length - 1];
+        const thetaEnd = boundary(li);
+        const tx = Math.sin(thetaEnd) * sign;
+        const ty = -Math.cos(thetaEnd) * sign;
+        const T = {
+          x: round33(end.x + tx * innerLeadOut),
+          y: round33(end.y + ty * innerLeadOut)
+        };
+        if (T.x !== end.x || T.y !== end.y) {
+          layerPts[li].push(T);
+          layerPts[li + 1].unshift(T);
+        }
+      }
+    }
     let totalLengthMm = 0;
     let totalTraces = 0;
     let totalResistance = 0;
     for (let li = 0; li < layersIn.length; li++) {
       const lyr = layersIn[li];
-      for (let i = 0; i + 1 < pts.length; i++) {
+      const lp = layerPts[li];
+      for (let i = 0; i + 1 < lp.length; i++) {
         pcb.traces.push({
-          start: pts[i],
-          end: pts[i + 1],
+          start: lp[i],
+          end: lp[i + 1],
           width: traceWidth,
           layer: lyr,
           net,
@@ -60751,12 +60853,12 @@ async function addCoil(args, opts) {
         });
         totalTraces++;
       }
-      totalLengthMm += perLayerLen;
+      const layerLen = segLength(lp);
+      totalLengthMm += layerLen;
       const cuT = pcb.stackup.layers.find((s) => s.layer === lyr)?.copperThickness ?? 0.035;
-      totalResistance += 168e-7 * perLayerLen / (traceWidth * cuT);
+      totalResistance += 168e-7 * layerLen / (traceWidth * cuT);
       if (li + 1 < layersIn.length) {
-        const atInner = li % 2 === 0;
-        const stitchPt = atInner ? pts[0] : pts[pts.length - 1];
+        const stitchPt = lp[lp.length - 1];
         pcb.vias.push({
           position: stitchPt,
           diameter: pcb.rules.defaultRules.viaDiameter,
@@ -60769,9 +60871,10 @@ async function addCoil(args, opts) {
         stitchVias.push({ position: stitchPt, startLayer: lyr, endLayer: layersIn[li + 1] });
       }
     }
-    const lastFreeInner = (layersIn.length - 1) % 2 === 0;
-    const terminalA = pts[pts.length - 1];
-    const terminalB = lastFreeInner ? pts[0] : pts[pts.length - 1];
+    const lastLp = layerPts[layerPts.length - 1];
+    const terminalA = layerPts[0][0];
+    const terminalB = lastLp[lastLp.length - 1];
+    const lastFreeInner = layersIn.length % 2 === 1;
     return {
       content: [
         {
@@ -60783,14 +60886,14 @@ async function addCoil(args, opts) {
             direction,
             layers_used: layersIn,
             multilayer: true,
-            note: "Multilayer stacked coil: `layer` and inner_via/via_to_layer ignored; layers stitched with alternating inner/outer vias.",
+            note: "Multilayer stacked coil: `layer` and inner_via/via_to_layer ignored. One continuous spiral in angle across the stack \u2014 the radius zigzags inner\u2194outer with a stitch via at each turnaround \u2014 so every layer circulates the same way and their fields add.",
             total_traces: totalTraces,
             total_length_mm: Math.round(totalLengthMm * 100) / 100,
             total_resistance_ohms: Math.round(totalResistance * 1e3) / 1e3,
             stitch_vias: stitchVias,
             terminals: { a: terminalA, b: terminalB },
-            inner_endpoint: pts[0],
-            outer_endpoint: pts[pts.length - 1],
+            inner_endpoint: lastFreeInner ? terminalB : layerPts[0][layerPts[0].length - 1],
+            outer_endpoint: terminalA,
             ...drcCap ? { drc_delta: await drcCap.finish() } : {},
             ...docResultPayload(ctx)
           })
@@ -78061,8 +78164,8 @@ var init_server3 = __esm({
     init_order_feed();
     init_animate();
     PKG_VERSION = (() => {
-      if ("0.9.4-main.20") {
-        return "0.9.4-main.20";
+      if ("0.9.4-main.22") {
+        return "0.9.4-main.22";
       }
       try {
         const req = createRequire2(import.meta.url);
@@ -78071,8 +78174,8 @@ var init_server3 = __esm({
         return "0.0.0";
       }
     })();
-    BUILD_SHA = "c5938bcd3843b4e600b28e18b5472d41337bd478";
-    BUILD_TIME = "2026-07-25T14:49:15.914Z";
+    BUILD_SHA = "34f31195abaa154019b219eda75a0e900b7ece93";
+    BUILD_TIME = "2026-07-25T19:25:56.201Z";
     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 = randomUUID6().slice(0, 8);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vcad/mcp",
-  "version": "0.9.4-main.20",
+  "version": "0.9.4-main.22",
   "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": "c5938bcd3843b4e600b28e18b5472d41337bd478",
-    "builtAt": "2026-07-25T14:49:15.914Z"
+    "sha": "34f31195abaa154019b219eda75a0e900b7ece93",
+    "builtAt": "2026-07-25T19:25:56.201Z"
   }
 }