@vcad/mcp 0.9.4-main.71 → 0.9.4-main.73

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 db132e1acce8719160880940ad8f1445aaf18354 at 2026-08-16T20:09:58.430Z. Source: https://github.com/ecto/vcad
+Built from c94448044a725e430c38faf507027d5a10b2c68d at 2026-08-17T23:42:23.328Z. Source: https://github.com/ecto/vcad

package/index.mjs

@@ -10874,6 +10874,46 @@ async function parseKicadPcb2(content) {
     return null;
   }
 }
+function importBindings(wasm3) {
+  const mod = wasm3;
+  const bind = (name) => {
+    const fn = mod[name];
+    if (typeof fn !== "function") {
+      throw new Error(`Altium import is unavailable: this kernel WASM build predates ${name}. Rebuild the kernel WASM (npm run build -w vcad-kernel-wasm) or update @vcad/mcp.`);
+    }
+    return fn;
+  };
+  return {
+    parseAltiumAsciiPcb: (content) => bind("parseAltiumAsciiPcb")(content),
+    parseAltiumPcbDoc: (bytes) => bind("parseAltiumPcbDoc")(bytes),
+    parseAltiumPcbLib: (bytes) => bind("parseAltiumPcbLib")(bytes),
+    parseEagleBrd: (content) => bind("parseEagleBrd")(content)
+  };
+}
+async function parseEagleBrd(content) {
+  const wasm3 = await loadEcadWasm();
+  if (!wasm3)
+    return null;
+  return importBindings(wasm3).parseEagleBrd(content);
+}
+async function parseAltiumAsciiPcb(content) {
+  const wasm3 = await loadEcadWasm();
+  if (!wasm3)
+    return null;
+  return importBindings(wasm3).parseAltiumAsciiPcb(content);
+}
+async function parseAltiumPcbDoc(bytes) {
+  const wasm3 = await loadEcadWasm();
+  if (!wasm3)
+    return null;
+  return importBindings(wasm3).parseAltiumPcbDoc(bytes);
+}
+async function parseAltiumPcbLib(bytes) {
+  const wasm3 = await loadEcadWasm();
+  if (!wasm3)
+    return null;
+  return importBindings(wasm3).parseAltiumPcbLib(bytes);
+}
 async function exportKicadPcb2(pcb) {
   const wasm3 = await loadEcadWasm();
   if (!wasm3)
@@ -11719,7 +11759,11 @@ __export(dist_exports, {
   mountingHolesFromPcb: () => mountingHolesFromPcb,
   netContinuity: () => netContinuity,
   outlineAabb: () => outlineAabb,
+  parseAltiumAsciiPcb: () => parseAltiumAsciiPcb,
+  parseAltiumPcbDoc: () => parseAltiumPcbDoc,
+  parseAltiumPcbLib: () => parseAltiumPcbLib,
   parseBindingKey: () => parseBindingKey,
+  parseEagleBrd: () => parseEagleBrd,
   parseExpression: () => parse,
   parseKicadPcb: () => parseKicadPcb2,
   parseXyz: () => parseXyz,
@@ -41547,6 +41591,26 @@ var init_CHANGELOG = __esm({
     CHANGELOG_default = {
       $schema: "./changelog.schema.json",
       entries: [
+        {
+          id: "2026-08-17-altium-pcb-import",
+          version: "0.9.4",
+          date: "2026-08-17",
+          category: "feat",
+          title: "Altium and Eagle PCB import",
+          summary: "Import Altium .PcbDoc boards (native binary or ASCII) and .PcbLib libraries, plus Eagle .brd boards, straight into a live session.",
+          features: [
+            "pcb",
+            "import",
+            "ecad",
+            "altium",
+            "eagle"
+          ],
+          mcpTools: [
+            "import_altium",
+            "import_altium_library",
+            "import_eagle"
+          ]
+        },
         {
           id: "2026-08-16-render-z-up",
           version: "0.9.4",
@@ -41559,6 +41623,81 @@ var init_CHANGELOG = __esm({
             "rendering"
           ]
         },
+        {
+          id: "2026-08-16-render-hidden-lines",
+          version: "0.9.4",
+          date: "2026-08-16",
+          category: "fix",
+          title: "SVG renders draw complete, actually-dashed hidden lines",
+          summary: "Hidden edges on curved features were mostly deleted and the survivors drew solid, leaving a stray line across the part; they now run the full occluded length as proper dashes.",
+          features: [
+            "rendering",
+            "drafting"
+          ]
+        },
+        {
+          id: "2026-08-16-render-annotation-scaling",
+          version: "0.9.4",
+          date: "2026-08-16",
+          category: "fix",
+          title: "Render overlays stay readable at any size",
+          summary: "The axes gizmo, part labels and dimensions now scale with the canvas instead of staying 1024px-sized, dimension lines clear round parts, and labels no longer land on the geometry they name.",
+          features: [
+            "rendering",
+            "drafting"
+          ],
+          mcpTools: [
+            "render_view"
+          ]
+        },
+        {
+          id: "2026-08-16-render-aa-and-depth-cue",
+          version: "0.9.4",
+          date: "2026-08-16",
+          category: "fix",
+          title: "Smoother renders: anti-aliasing and a per-pixel depth cue",
+          summary: "Isometric renders anti-alias their silhouettes and linework, flat faces no longer break into hard tonal wedges at triangle boundaries, and edge strokes sit on their geometry instead of half a stroke off.",
+          features: [
+            "rendering",
+            "tessellation"
+          ],
+          mcpTools: [
+            "render_view"
+          ]
+        },
+        {
+          id: "2026-08-16-loon-sheet-metal-bindings",
+          version: "0.9.4",
+          date: "2026-08-16",
+          category: "feat",
+          title: "Loon can author sheet metal, faceting and imports",
+          summary: "Sheet-metal chains, pinned segment counts and vendor STEP/STL imports are now expressible in loon, so a bent part carries its bends and unfolds exactly instead of having them inferred back out of the solid.",
+          features: [
+            "loon",
+            "sheet-metal",
+            "import",
+            "tessellation"
+          ],
+          mcpTools: [
+            "create_cad_loon",
+            "sheet_metal_unfold",
+            "flat_pattern_from_solid"
+          ]
+        },
+        {
+          id: "2026-08-16-cli-sheet-metal-fold",
+          version: "0.9.4",
+          date: "2026-08-16",
+          category: "fix",
+          title: "Sheet-metal parts export from the CLI again",
+          summary: "vcad info/export and vcad-render now fold sheet-metal chains \u2014 including jogs and bend relief \u2014 instead of reporting zero triangles, and a root that fails to evaluate says why.",
+          features: [
+            "sheet-metal",
+            "cli",
+            "loon",
+            "export"
+          ]
+        },
         {
           id: "2026-08-16-cli-loon-input-everywhere",
           version: "0.9.4",
@@ -49705,7 +49844,21 @@ var init_loon_macros = __esm({
       "type",
       "assembly",
       "part",
-      "instance"
+      "instance",
+      "cylinder-n",
+      "sphere-n",
+      "cone-n",
+      "torus-n",
+      "import-step",
+      "import-step-body",
+      "import-mesh",
+      "import-mesh-scaled",
+      "sheet-base-flange-rect",
+      "sheet-base-flange",
+      "sheet-edge-flange",
+      "sheet-jog",
+      "sheet-hem",
+      "sheet-bend-relief"
     ]);
     registry2 = /* @__PURE__ */ new Map();
     hydrated = false;
@@ -50088,12 +50241,27 @@ function createCadLoon(input, engine) {
     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 { content: [{ type: "text", text: text2 }] };
   }
-  const text = format === "json" ? JSON.stringify(doc, null, 2) : toVCode2(doc);
+  const { text, fellBack } = serializeDocument2(doc, format);
   const content = [{ type: "text", text }];
+  if (fellBack) {
+    content.push({
+      type: "text",
+      text: `Note: returned the JSON IR instead of VCode \u2014 this document uses ops VCode cannot express (${fellBack}). The document itself is complete and every downstream tool works on it; only the compact text form is unavailable.`
+    });
+  }
   const note = parametricNote(source, modules, engine, doc);
   if (note) content.push({ type: "text", text: note });
   return { content };
 }
+function serializeDocument2(doc, format) {
+  if (format === "json") return { text: JSON.stringify(doc, null, 2), fellBack: null };
+  try {
+    return { text: toVCode2(doc), fellBack: null };
+  } catch (e) {
+    const why = e instanceof Error ? e.message : String(e);
+    return { text: JSON.stringify(doc, null, 2), fellBack: why };
+  }
+}
 function parametricNote(source, modules, engine, doc) {
   const names = Object.keys(doc.parameters ?? {}).sort();
   if (!names.length) return null;
@@ -50189,7 +50357,7 @@ var init_loon = __esm({
       {
         name: "create_cad_loon",
         pack: null,
-        description: 'The preferred authoring tool for whole parts and multi-feature models \u2014 one call, full vocabulary. Create a CAD document from loon source code. Loon is a Lisp-like language for parametric CAD \u2014 the FULL modeling vocabulary (patterns, sketches, extrude/revolve/sweep/loft, assemblies) is available here even where no dedicated MCP tool exists. For incremental single-node edits to an open session, use create/update/delete instead.\n\nPrimitives: [cube x y z], [cylinder r h], [sphere r], [cone r-bottom r-top h], [torus major-r minor-r], [wedge x y z], [prism sides radius height]\nBooleans (subject-last): [difference tool subject], [union other subject], [intersection other subject]\nTransforms (subject-last): [translate x y z s], [rotate rx ry rz s], [scale sx sy sz s], [mirror ox oy oz nx ny nz s] (plane through the origin point with that normal) \u2014 plus the axis sugar [mirror-x s] / [mirror-y s] / [mirror-z s], which mirror through the origin, negating that one coordinate. NEVER hand-mirror by negating coordinates; use these.\nFeatures: [fillet r s], [chamfer d s], [shell t s]\nPatterns (subject-last): [linear-pattern dx dy dz count spacing s], [circular-pattern ox oy oz ax ay az count angle s] \u2014 e.g. a bolt circle is [circular-pattern 0 0 0 0 0 1 6 360 bolt-hole]\nSymmetric patterns (subject-last): [mirror-pattern nx ny nz s] and its sugar [mirror-pattern-x s] / -y / -z union a solid with its mirror image (a left/right pair in one expression, so the halves can\'t drift apart); [quad-pattern s] is the 4-fold X-and-Y version \u2014 a quadruped\'s legs, a 4-post frame, a vehicle chassis\nSketches: [sketch ox oy oz xx xy xz yx yy yz #[segments]] with [line x1 y1 x2 y2] and [arc x1 y1 x2 y2 cx cy ccw]\nSketch ops (sketch-last): [extrude dx dy dz sk], [revolve aox aoy aoz adx ady adz angle sk], [sweep-line sx sy sz ex ey ez sk], [sweep-helix radius pitch height turns sk], [loft #[sk1 sk2 \u2026]], [loft-closed #[sk1 sk2 \u2026]]\nAssemblies: [assembly #[parts] #[instances] #[joints] ground-id] with [part name solid "material"], [instance name part-name x y z], [revolute-joint \u2026], [prismatic-joint \u2026], [fixed-joint \u2026], [ball-joint \u2026]\nAssembly symmetry: author ONE side as an assembly, then [mirror-group-x "-r" side] (or -y / -z) returns it plus a mirrored, suffixed copy \u2014 parts reflected, placements and joint anchors mirrored, and joint axes flipped by the correct rule (a hinge across its own mirror normal keeps its axis; the other two flip), so the same joint state drives both sides symmetrically. Splice it back with [assembly-join chassis mirrored]. NEVER hand-mirror an assembly.\nPipe: [pipe [cube 50 30 5] [difference [cylinder 3 10]] [fillet 1.0]]\nLet bindings: [let body [cube 50 30 5]] \u2014 note these are inlined and do NOT survive into the document; use [defparam ...] for a value you want to change later\nParameters (survive into the document and are settable afterwards with set_parameters, and differentiable with parameter_gradient): [defparam pitch_axis_x 310.0], [defparam wall "bore * 0.2"] for derived values, plus optional :unit/:min/:max/:description. Names must be identifier-safe (underscores, not dashes)\nDatums \u2014 named reference geometry, so two parts cannot each hold their own copy of a shared plane: [datum-plane "femur_inner" y 131.0], [datum-axis "pitch" x 0 0 310], [datum-point "hip" 0 0 310], read back with [datum "femur_inner"], [datum+ "femur_inner" 3.0] (3 mm outboard), [datum-x/-y/-z "pitch"]\nStacks \u2014 declarative packing, where each running clearance is a named value instead of an arbitrary number: [stack y "leg" 131.0 [lane "femur_inner" 5.0] [gap "idler_run" 1.0] [lane "idler_boss" 3.0]] declares datum planes leg_femur_inner_lo/_hi, leg_idler_boss_lo/_hi and leg_end; widening leg_idler_run slides everything outboard of it\nScene: [root solid "material-name"], with [material name r g b metallic roughness] to define one\nModules: [use bracket] then [bracket.plate] \u2014 multi-file projects work here, with sources passed in `modules` (or read from `base_dir`); [use bracket :as b] aliases, [use bracket [plate]] imports selectively, and `pub` in a module picks what it exports',
+        description: 'The preferred authoring tool for whole parts and multi-feature models \u2014 one call, full vocabulary. Create a CAD document from loon source code. Loon is a Lisp-like language for parametric CAD \u2014 the FULL modeling vocabulary (patterns, sketches, extrude/revolve/sweep/loft, assemblies) is available here even where no dedicated MCP tool exists. For incremental single-node edits to an open session, use create/update/delete instead.\n\nPrimitives: [cube x y z], [cylinder r h], [sphere r], [cone r-bottom r-top h], [torus major-r minor-r], [wedge x y z], [prism sides radius height]. Segment count is the kernel default (32); pin it with [cylinder-n r h n] / [sphere-n r n] / [cone-n rb rt h n] / [torus-n R r n] where the facets are load-bearing (a bore that must accept a real shaft)\nImports \u2014 place a purchased part instead of approximating it, so fit checks test the real envelope and not one you invented: [import-step "vendor/x6-60.step"], [import-step-body path index] for a multi-body file, [import-mesh "part.stl"], [import-mesh-scaled sx sy sz path]. Relative paths resolve against base_dir / the module source\nSheet metal (subject-last, so it threads through pipe) \u2014 author a cut-and-bent part as a bend chain and it KEEPS its bends, so sheet_metal_unfold is exact instead of inferred back out of a solid by flat_pattern_from_solid: [sheet-base-flange-rect width depth thickness "al-soft"] (or [sheet-base-flange #[x0 y0 \u2026] #[holes] t material] for an arbitrary outline) then [sheet-edge-flange edge length angle-deg s], [sheet-jog edge offset length s], [sheet-hem edge length s], [sheet-bend-relief s]. `edge` is an outline index, or "south"/"east"/"north"/"west" on a rectangular base flange (edge 0 is the -Y edge, CCW from there). Each has an -at form taking panel id, radius, direction ("up"/"down") and K-factor, where 0.0 means the default; -shop variants resolve every bend through a shop table. Sheet nodes are a bend graph, NOT solids \u2014 never union, transform or fillet them\nBooleans (subject-last): [difference tool subject], [union other subject], [intersection other subject]\nTransforms (subject-last): [translate x y z s], [rotate rx ry rz s], [scale sx sy sz s], [mirror ox oy oz nx ny nz s] (plane through the origin point with that normal) \u2014 plus the axis sugar [mirror-x s] / [mirror-y s] / [mirror-z s], which mirror through the origin, negating that one coordinate. NEVER hand-mirror by negating coordinates; use these.\nFeatures: [fillet r s], [chamfer d s], [shell t s]\nPatterns (subject-last): [linear-pattern dx dy dz count spacing s], [circular-pattern ox oy oz ax ay az count angle s] \u2014 e.g. a bolt circle is [circular-pattern 0 0 0 0 0 1 6 360 bolt-hole]\nSymmetric patterns (subject-last): [mirror-pattern nx ny nz s] and its sugar [mirror-pattern-x s] / -y / -z union a solid with its mirror image (a left/right pair in one expression, so the halves can\'t drift apart); [quad-pattern s] is the 4-fold X-and-Y version \u2014 a quadruped\'s legs, a 4-post frame, a vehicle chassis\nSketches: [sketch ox oy oz xx xy xz yx yy yz #[segments]] with [line x1 y1 x2 y2] and [arc x1 y1 x2 y2 cx cy ccw]\nSketch ops (sketch-last): [extrude dx dy dz sk], [revolve aox aoy aoz adx ady adz angle sk], [sweep-line sx sy sz ex ey ez sk], [sweep-helix radius pitch height turns sk], [loft #[sk1 sk2 \u2026]], [loft-closed #[sk1 sk2 \u2026]]\nAssemblies: [assembly #[parts] #[instances] #[joints] ground-id] with [part name solid "material"], [instance name part-name x y z], [revolute-joint \u2026], [prismatic-joint \u2026], [fixed-joint \u2026], [ball-joint \u2026]\nAssembly symmetry: author ONE side as an assembly, then [mirror-group-x "-r" side] (or -y / -z) returns it plus a mirrored, suffixed copy \u2014 parts reflected, placements and joint anchors mirrored, and joint axes flipped by the correct rule (a hinge across its own mirror normal keeps its axis; the other two flip), so the same joint state drives both sides symmetrically. Splice it back with [assembly-join chassis mirrored]. NEVER hand-mirror an assembly.\nPipe: [pipe [cube 50 30 5] [difference [cylinder 3 10]] [fillet 1.0]]\nLet bindings: [let body [cube 50 30 5]] \u2014 note these are inlined and do NOT survive into the document; use [defparam ...] for a value you want to change later\nParameters (survive into the document and are settable afterwards with set_parameters, and differentiable with parameter_gradient): [defparam pitch_axis_x 310.0], [defparam wall "bore * 0.2"] for derived values, plus optional :unit/:min/:max/:description. Names must be identifier-safe (underscores, not dashes)\nDatums \u2014 named reference geometry, so two parts cannot each hold their own copy of a shared plane: [datum-plane "femur_inner" y 131.0], [datum-axis "pitch" x 0 0 310], [datum-point "hip" 0 0 310], read back with [datum "femur_inner"], [datum+ "femur_inner" 3.0] (3 mm outboard), [datum-x/-y/-z "pitch"]\nStacks \u2014 declarative packing, where each running clearance is a named value instead of an arbitrary number: [stack y "leg" 131.0 [lane "femur_inner" 5.0] [gap "idler_run" 1.0] [lane "idler_boss" 3.0]] declares datum planes leg_femur_inner_lo/_hi, leg_idler_boss_lo/_hi and leg_end; widening leg_idler_run slides everything outboard of it\nScene: [root solid "material-name"], with [material name r g b metallic roughness] to define one\nModules: [use bracket] then [bracket.plate] \u2014 multi-file projects work here, with sources passed in `modules` (or read from `base_dir`); [use bracket :as b] aliases, [use bracket [plate]] imports selectively, and `pub` in a module picks what it exports',
         inputSchema: createCadLoonSchema,
         handler: async (args, ctx) => {
           const useLoons = Array.isArray(args.use_loons) ? args.use_loons : void 0;
@@ -55430,6 +55598,8 @@ var init_tool_metadata = __esm({
       import_step: { title: "Import STEP", annotations: RW },
       import_urdf: { title: "Import URDF", annotations: RW },
       import_kicad: { title: "Import KiCad", annotations: RW },
+      import_altium: { title: "Import Altium", annotations: RW },
+      import_altium_library: { title: "Import Altium Library", annotations: RO },
       import_eagle: { title: "Import EAGLE", annotations: RW },
       open_in_browser: { title: "Open in Browser", annotations: RW },
       // ── Physics gym ────────────────────────────────────────────────────────
@@ -78436,10 +78606,72 @@ function readSource(input, label) {
   }
   throw new Error("Provide either `filename` or `content_base64`");
 }
+function readSourceBytes(input, label) {
+  const { filename, content_base64 } = input;
+  if (content_base64) {
+    const buf = Buffer.from(content_base64, "base64");
+    if (buf.length === 0) throw new Error("content_base64 decoded to zero bytes");
+    if (buf.length > MAX_PCB_BYTES) {
+      throw new Error(`${label} content exceeds the ${MAX_PCB_BYTES} byte limit`);
+    }
+    return buf;
+  }
+  if (filename) {
+    if (isRemoteDeployment()) {
+      throw new Error(
+        `This hosted server has no filesystem access \u2014 pass the ${label} contents as \`content_base64\` instead of \`filename\`.`
+      );
+    }
+    const filepath = resolveWithinRoot(
+      filename,
+      process.env.VCAD_MCP_EXPORT_DIR ?? process.cwd()
+    );
+    if (!existsSync5(filepath)) throw new Error(`${label} file not found`);
+    const stat = statSync3(filepath);
+    if (!stat.isFile()) throw new Error(`${label} path is not a regular file`);
+    if (stat.size > MAX_PCB_BYTES) {
+      throw new Error(`${label} file exceeds the ${MAX_PCB_BYTES} byte limit`);
+    }
+    return readFileSync8(filepath);
+  }
+  throw new Error("Provide either `filename` or `content_base64`");
+}
+function registerBoard(pcb, name) {
+  const doc = createDocument();
+  doc.nodes["1"] = {
+    id: 1,
+    name,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    op: { type: "PcbBoard", board: pcb }
+  };
+  doc.roots.push({ root: 1, material: "__pcb_fr4__" });
+  doc.materials["__pcb_fr4__"] = {
+    name: "__pcb_fr4__",
+    color: [0.05, 0.35, 0.15],
+    roughness: 0.6,
+    metallic: 0
+  };
+  return registerSession(doc);
+}
+function boardSummary(pcb) {
+  return {
+    footprints: pcb.footprints.length,
+    nets: pcb.nets.length,
+    outline_vertices: pcb.outline?.vertices?.length ?? 0,
+    traces: pcb.traces.length,
+    vias: pcb.vias.length,
+    zones: pcb.zones.length,
+    design_rules: {
+      trace_width: pcb.rules?.defaultRules?.traceWidth,
+      clearance: pcb.rules?.defaultRules?.clearance,
+      via_diameter: pcb.rules?.defaultRules?.viaDiameter
+    }
+  };
+}
 function boardName(input) {
   if (input.name) return input.name;
   if (input.filename) {
-    return input.filename.replace(/^.*[/\\]/, "").replace(/\.kicad_pcb$/i, "");
+    return input.filename.replace(/^.*[/\\]/, "").replace(/\.(kicad_pcb|pcbdoc|pcblib|brd)$/i, "");
   }
   return "Imported board";
 }
@@ -78464,21 +78696,7 @@ async function importKicad(input) {
       "KiCad parsing is unavailable (kernel WASM is missing parseKicadPcb) or the file produced no board."
     );
   }
-  const doc = createDocument();
-  doc.nodes["1"] = {
-    id: 1,
-    name: boardName(args),
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    op: { type: "PcbBoard", board: pcb }
-  };
-  doc.roots.push({ root: 1, material: "__pcb_fr4__" });
-  doc.materials["__pcb_fr4__"] = {
-    name: "__pcb_fr4__",
-    color: [0.05, 0.35, 0.15],
-    roughness: 0.6,
-    metallic: 0
-  };
-  const documentId = registerSession(doc);
+  const documentId = registerBoard(pcb, boardName(args));
   const onlyPlacement = pcb.traces.length === 0 && pcb.vias.length === 0;
   return {
     content: [
@@ -78487,19 +78705,7 @@ async function importKicad(input) {
         text: JSON.stringify({
           success: true,
           document_id: documentId,
-          summary: {
-            footprints: pcb.footprints.length,
-            nets: pcb.nets.length,
-            outline_vertices: pcb.outline?.vertices?.length ?? 0,
-            traces: pcb.traces.length,
-            vias: pcb.vias.length,
-            zones: pcb.zones.length,
-            design_rules: {
-              trace_width: pcb.rules?.defaultRules?.traceWidth,
-              clearance: pcb.rules?.defaultRules?.clearance,
-              via_diameter: pcb.rules?.defaultRules?.viaDiameter
-            }
-          },
+          summary: boardSummary(pcb),
           ...onlyPlacement ? {
             note: "Placement + netlist only \u2014 the file carried no routed copper."
           } : {}
@@ -78508,12 +78714,138 @@ async function importKicad(input) {
     ]
   };
 }
-function importEagle(_input) {
-  return importError(
-    "Eagle (.brd) import is not yet supported. Export your board from Eagle as KiCad (File > Export > KiCad .kicad_pcb) and use import_kicad instead."
-  );
+function isCompoundFile(bytes) {
+  return bytes.length >= 8 && bytes.subarray(0, 8).equals(Buffer.from([208, 207, 17, 224, 161, 177, 26, 225]));
+}
+async function importAltium(input) {
+  const args = input ?? {};
+  let bytes;
+  try {
+    bytes = readSourceBytes(args, "Altium");
+  } catch (e) {
+    return importError(e instanceof Error ? e.message : String(e));
+  }
+  const binary = isCompoundFile(bytes);
+  let pcb;
+  try {
+    pcb = binary ? await parseAltiumPcbDoc(new Uint8Array(bytes)) : await parseAltiumAsciiPcb(bytes.toString("utf8"));
+  } catch (e) {
+    return importError(
+      `Could not parse the Altium ${binary ? "binary" : "ASCII"} .PcbDoc: ` + (e instanceof Error ? e.message : String(e))
+    );
+  }
+  if (!pcb) {
+    return importError(
+      "Altium parsing is unavailable (kernel WASM is missing parseAltiumPcbDoc)."
+    );
+  }
+  const documentId = registerBoard(pcb, boardName(args));
+  const onlyPlacement = pcb.traces.length === 0 && pcb.vias.length === 0;
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          document_id: documentId,
+          source_format: binary ? "PcbDoc (binary)" : "PcbDoc (ASCII)",
+          summary: boardSummary(pcb),
+          ...onlyPlacement ? { note: "Placement + netlist only \u2014 the file carried no routed copper." } : {},
+          ...binary ? {
+            note_binary: "Binary .PcbDoc record layouts are reconstructed, not specified by Altium, and are validated against real open-hardware projects. Geometry that decoded implausibly fails the import outright rather than importing wrong, but spot-check with render_pcb before fabricating. Copper pours and text are not imported."
+          } : {}
+        })
+      }
+    ]
+  };
+}
+async function importAltiumLibrary(input) {
+  const args = input ?? {};
+  let bytes;
+  try {
+    bytes = readSourceBytes(args, "Altium library");
+  } catch (e) {
+    return importError(e instanceof Error ? e.message : String(e));
+  }
+  let lib;
+  try {
+    lib = await parseAltiumPcbLib(new Uint8Array(bytes));
+  } catch (e) {
+    return importError(
+      `Could not parse the Altium .PcbLib: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+  if (!lib) {
+    return importError(
+      "Altium parsing is unavailable (kernel WASM is missing parseAltiumPcbLib)."
+    );
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          footprint_count: lib.footprints.length,
+          footprints: lib.footprints.map((f) => ({
+            name: f.name,
+            pad_count: f.pads.length,
+            pads: f.pads.map((p) => ({
+              number: p.number,
+              type: p.pad_type,
+              position: p.position,
+              rotation: p.rotation,
+              drill: p.drill?.diameter ?? null
+            }))
+          }))
+        })
+      }
+    ]
+  };
+}
+async function importEagle(input) {
+  const args = input ?? {};
+  let content;
+  try {
+    content = readSource(args, "Eagle");
+  } catch (e) {
+    return importError(e instanceof Error ? e.message : String(e));
+  }
+  if (!content.includes("<eagle") && !content.includes("<board")) {
+    return importError(
+      "This does not look like an Eagle XML .brd file. Eagle 5 and earlier wrote a binary .brd \u2014 open it in Eagle 6+ (which converts it to XML) and save, then import that."
+    );
+  }
+  let pcb;
+  try {
+    pcb = await parseEagleBrd(content);
+  } catch (e) {
+    return importError(
+      `Could not parse the Eagle .brd: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+  if (!pcb) {
+    return importError(
+      "Eagle parsing is unavailable (kernel WASM is missing parseEagleBrd)."
+    );
+  }
+  const documentId = registerBoard(pcb, boardName(args));
+  const onlyPlacement = pcb.traces.length === 0 && pcb.vias.length === 0;
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          document_id: documentId,
+          summary: boardSummary(pcb),
+          ...onlyPlacement ? { note: "Placement + netlist only \u2014 the file carried no routed copper." } : {}
+        })
+      }
+    ]
+  };
 }
-var MAX_PCB_BYTES, importKicadSchema, importEagleSchema, toolDefs46;
+var MAX_PCB_BYTES, importKicadSchema, importAltiumSchema, importAltiumLibrarySchema, importEagleSchema, toolDefs46;
 var init_import_pcb = __esm({
   "src/tools/import-pcb.ts"() {
     "use strict";
@@ -78541,16 +78873,50 @@ var init_import_pcb = __esm({
         }
       }
     };
+    importAltiumSchema = {
+      type: "object",
+      properties: {
+        filename: {
+          type: "string",
+          description: "Path to a .PcbDoc file on the server filesystem (relative to VCAD_MCP_EXPORT_DIR or cwd). Native binary and ASCII exports are both accepted. On hosted servers pass content_base64 instead."
+        },
+        content_base64: {
+          type: "string",
+          description: "Base64-encoded .PcbDoc contents (preferred for hosted servers)."
+        },
+        name: {
+          type: "string",
+          description: "Board name for display (default: filename without extension)."
+        }
+      }
+    };
+    importAltiumLibrarySchema = {
+      type: "object",
+      properties: {
+        filename: {
+          type: "string",
+          description: "Path to a .PcbLib footprint library (binary or ASCII)."
+        },
+        content_base64: {
+          type: "string",
+          description: "Base64-encoded .PcbLib contents."
+        }
+      }
+    };
     importEagleSchema = {
       type: "object",
       properties: {
         filename: {
           type: "string",
-          description: "Path to a .brd file (Eagle XML format)."
+          description: "Path to a .brd file (Eagle XML, Eagle 6+)."
         },
         content_base64: {
           type: "string",
-          description: "Base64-encoded .brd contents."
+          description: "Base64-encoded .brd contents (preferred for hosted servers)."
+        },
+        name: {
+          type: "string",
+          description: "Board name for display (default: filename without extension)."
         }
       }
     };
@@ -78563,13 +78929,29 @@ var init_import_pcb = __esm({
         handler: async (a) => await importKicad(a),
         behavior: behavior({ writesDoc: true, geometry: true })
       },
+      {
+        name: "import_altium",
+        pack: "ecad",
+        description: "Import an Altium .PcbDoc board into a live session \u2014 board outline, footprints with pads + nets, design rules, and any routed traces/vias. Accepts both the native binary file and an ASCII export (detected automatically). Returns a document_id ready for render_pcb, run_drc, get_pad_positions, route_nets, and export_gerber. The binary path fails closed on record layouts it cannot decode rather than importing a partially-correct board. Pass content_base64 on hosted servers.",
+        inputSchema: importAltiumSchema,
+        handler: async (a) => await importAltium(a),
+        behavior: behavior({ writesDoc: true, geometry: true })
+      },
+      {
+        name: "import_altium_library",
+        pack: "ecad",
+        description: "Read an Altium .PcbLib footprint library (binary or ASCII) and return its footprint patterns with pads, shapes, and drills. A library is not a board, so no document_id is minted.",
+        inputSchema: importAltiumLibrarySchema,
+        handler: async (a) => await importAltiumLibrary(a),
+        behavior: behavior({})
+      },
       {
         name: "import_eagle",
         pack: "ecad",
-        description: "Import an Eagle .brd file (not yet supported). Export your board from Eagle as KiCad (.kicad_pcb) and use import_kicad instead.",
+        description: "Import an Eagle .brd board (XML, Eagle 6+) into a live session \u2014 board outline, packages placed as footprints with pads, signals as nets, and any hand-routed traces/vias. Returns a document_id ready for render_pcb, run_drc, get_pad_positions, route_nets, and export_gerber. Pass content_base64 on hosted servers.",
         inputSchema: importEagleSchema,
-        handler: (a) => importEagle(a),
-        behavior: behavior({})
+        handler: async (a) => await importEagle(a),
+        behavior: behavior({ writesDoc: true, geometry: true })
       }
     ];
   }
@@ -83601,8 +83983,8 @@ var init_server3 = __esm({
     init_order_feed();
     init_animate();
     PKG_VERSION = (() => {
-      if ("0.9.4-main.71") {
-        return "0.9.4-main.71";
+      if ("0.9.4-main.73") {
+        return "0.9.4-main.73";
       }
       try {
         const req = createRequire2(import.meta.url);
@@ -83611,8 +83993,8 @@ var init_server3 = __esm({
         return "0.0.0";
       }
     })();
-    BUILD_SHA = "db132e1acce8719160880940ad8f1445aaf18354";
-    BUILD_TIME = "2026-08-16T20:09:58.430Z";
+    BUILD_SHA = "c94448044a725e430c38faf507027d5a10b2c68d";
+    BUILD_TIME = "2026-08-17T23:42:23.328Z";
     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);
@@ -83808,6 +84190,8 @@ var init_server3 = __esm({
       "import_step",
       "import_urdf",
       "import_kicad",
+      "import_altium",
+      "import_altium_library",
       "import_eagle",
       "open_in_browser",
       // ── Physics gym ────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vcad/mcp",
-  "version": "0.9.4-main.71",
+  "version": "0.9.4-main.73",
   "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": "db132e1acce8719160880940ad8f1445aaf18354",
-    "builtAt": "2026-08-16T20:09:58.430Z"
+    "sha": "c94448044a725e430c38faf507027d5a10b2c68d",
+    "builtAt": "2026-08-17T23:42:23.328Z"
   }
 }