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

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 c94448044a725e430c38faf507027d5a10b2c68d at 2026-08-17T23:42:23.328Z. Source: https://github.com/ecto/vcad
+Built from 89230349e9d445891fbcb1efd7f0cc9425ba972e at 2026-08-25T23:30:10.326Z. Source: https://github.com/ecto/vcad

package/index.mjs

@@ -225,6 +225,10 @@ __export(vcad_kernel_wasm_exports, {
   op_shell: () => op_shell,
   op_sweep_helix: () => op_sweep_helix,
   op_sweep_line: () => op_sweep_line,
+  parseAltiumAsciiPcb: () => parseAltiumAsciiPcb,
+  parseAltiumPcbDoc: () => parseAltiumPcbDoc,
+  parseAltiumPcbLib: () => parseAltiumPcbLib,
+  parseEagleBrd: () => parseEagleBrd,
   parseKicadPcb: () => parseKicadPcb,
   parseVCode: () => parseVCode,
   parseVcadFile: () => parseVcadFile,
@@ -2443,6 +2447,42 @@ function op_sweep_line(profile_json, start, end, twist_angle, scale_start, scale
   }
   return Solid.__wrap(ret[0]);
 }
+function parseAltiumAsciiPcb(content) {
+  const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.parseAltiumAsciiPcb(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function parseAltiumPcbDoc(bytes) {
+  const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.parseAltiumPcbDoc(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function parseAltiumPcbLib(bytes) {
+  const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.parseAltiumPcbLib(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
+function parseEagleBrd(content) {
+  const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.parseEagleBrd(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return takeFromExternrefTable0(ret[0]);
+}
 function parseKicadPcb(content) {
   const ptr0 = passStringToWasm0(content, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
   const len0 = WASM_VECTOR_LEN;
@@ -4665,7 +4705,7 @@ function __wbg_get_imports() {
           const a = state0.a;
           state0.a = 0;
           try {
-            return wasm_bindgen_fdb3f87e5dacef0f___convert__closures_____invoke___wasm_bindgen_fdb3f87e5dacef0f___JsValue__wasm_bindgen_fdb3f87e5dacef0f___JsValue_____(a, state0.b, arg02, arg12);
+            return wasm_bindgen_22639e9cee8fd77e___convert__closures_____invoke___wasm_bindgen_22639e9cee8fd77e___JsValue__wasm_bindgen_22639e9cee8fd77e___JsValue_____(a, state0.b, arg02, arg12);
           } finally {
             state0.a = a;
           }
@@ -5300,11 +5340,11 @@ function __wbg_get_imports() {
       arg0.writeTexture(arg1, arg2, arg3, arg4);
     },
     __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_fdb3f87e5dacef0f___closure__destroy___dyn_core_9b3796e30d99ddb7___ops__function__FnMut__wgpu_43013bc91c6d6b83___backend__webgpu__webgpu_sys__gen_GpuUncapturedErrorEvent__GpuUncapturedErrorEvent____Output_______, wasm_bindgen_fdb3f87e5dacef0f___convert__closures_____invoke___wgpu_43013bc91c6d6b83___backend__webgpu__webgpu_sys__gen_GpuUncapturedErrorEvent__GpuUncapturedErrorEvent_____);
+      const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_22639e9cee8fd77e___closure__destroy___dyn_core_f0fd674eaa06beef___ops__function__FnMut__wgpu_56e928f2b7a75f7a___backend__webgpu__webgpu_sys__gen_GpuUncapturedErrorEvent__GpuUncapturedErrorEvent____Output_______, wasm_bindgen_22639e9cee8fd77e___convert__closures_____invoke___wgpu_56e928f2b7a75f7a___backend__webgpu__webgpu_sys__gen_GpuUncapturedErrorEvent__GpuUncapturedErrorEvent_____);
       return ret;
     },
     __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_fdb3f87e5dacef0f___closure__destroy___dyn_core_9b3796e30d99ddb7___ops__function__FnMut__wasm_bindgen_fdb3f87e5dacef0f___JsValue____Output_______, wasm_bindgen_fdb3f87e5dacef0f___convert__closures_____invoke___wasm_bindgen_fdb3f87e5dacef0f___JsValue_____);
+      const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen_22639e9cee8fd77e___closure__destroy___dyn_core_f0fd674eaa06beef___ops__function__FnMut__wasm_bindgen_22639e9cee8fd77e___JsValue____Output_______, wasm_bindgen_22639e9cee8fd77e___convert__closures_____invoke___wasm_bindgen_22639e9cee8fd77e___JsValue_____);
       return ret;
     },
     __wbindgen_cast_0000000000000003: function(arg0) {
@@ -5378,14 +5418,14 @@ function __wbg_get_imports() {
     "./vcad_kernel_wasm_bg.js": import0
   };
 }
-function wasm_bindgen_fdb3f87e5dacef0f___convert__closures_____invoke___wgpu_43013bc91c6d6b83___backend__webgpu__webgpu_sys__gen_GpuUncapturedErrorEvent__GpuUncapturedErrorEvent_____(arg0, arg1, arg2) {
-  wasm.wasm_bindgen_fdb3f87e5dacef0f___convert__closures_____invoke___wgpu_43013bc91c6d6b83___backend__webgpu__webgpu_sys__gen_GpuUncapturedErrorEvent__GpuUncapturedErrorEvent_____(arg0, arg1, arg2);
+function wasm_bindgen_22639e9cee8fd77e___convert__closures_____invoke___wgpu_56e928f2b7a75f7a___backend__webgpu__webgpu_sys__gen_GpuUncapturedErrorEvent__GpuUncapturedErrorEvent_____(arg0, arg1, arg2) {
+  wasm.wasm_bindgen_22639e9cee8fd77e___convert__closures_____invoke___wgpu_56e928f2b7a75f7a___backend__webgpu__webgpu_sys__gen_GpuUncapturedErrorEvent__GpuUncapturedErrorEvent_____(arg0, arg1, arg2);
 }
-function wasm_bindgen_fdb3f87e5dacef0f___convert__closures_____invoke___wasm_bindgen_fdb3f87e5dacef0f___JsValue_____(arg0, arg1, arg2) {
-  wasm.wasm_bindgen_fdb3f87e5dacef0f___convert__closures_____invoke___wasm_bindgen_fdb3f87e5dacef0f___JsValue_____(arg0, arg1, arg2);
+function wasm_bindgen_22639e9cee8fd77e___convert__closures_____invoke___wasm_bindgen_22639e9cee8fd77e___JsValue_____(arg0, arg1, arg2) {
+  wasm.wasm_bindgen_22639e9cee8fd77e___convert__closures_____invoke___wasm_bindgen_22639e9cee8fd77e___JsValue_____(arg0, arg1, arg2);
 }
-function wasm_bindgen_fdb3f87e5dacef0f___convert__closures_____invoke___wasm_bindgen_fdb3f87e5dacef0f___JsValue__wasm_bindgen_fdb3f87e5dacef0f___JsValue_____(arg0, arg1, arg2, arg3) {
-  wasm.wasm_bindgen_fdb3f87e5dacef0f___convert__closures_____invoke___wasm_bindgen_fdb3f87e5dacef0f___JsValue__wasm_bindgen_fdb3f87e5dacef0f___JsValue_____(arg0, arg1, arg2, arg3);
+function wasm_bindgen_22639e9cee8fd77e___convert__closures_____invoke___wasm_bindgen_22639e9cee8fd77e___JsValue__wasm_bindgen_22639e9cee8fd77e___JsValue_____(arg0, arg1, arg2, arg3) {
+  wasm.wasm_bindgen_22639e9cee8fd77e___convert__closures_____invoke___wasm_bindgen_22639e9cee8fd77e___JsValue__wasm_bindgen_22639e9cee8fd77e___JsValue_____(arg0, arg1, arg2, arg3);
 }
 function addToExternrefTable0(obj) {
   const idx = wasm.__externref_table_alloc();
@@ -10890,25 +10930,25 @@ function importBindings(wasm3) {
     parseEagleBrd: (content) => bind("parseEagleBrd")(content)
   };
 }
-async function parseEagleBrd(content) {
+async function parseEagleBrd2(content) {
   const wasm3 = await loadEcadWasm();
   if (!wasm3)
     return null;
   return importBindings(wasm3).parseEagleBrd(content);
 }
-async function parseAltiumAsciiPcb(content) {
+async function parseAltiumAsciiPcb2(content) {
   const wasm3 = await loadEcadWasm();
   if (!wasm3)
     return null;
   return importBindings(wasm3).parseAltiumAsciiPcb(content);
 }
-async function parseAltiumPcbDoc(bytes) {
+async function parseAltiumPcbDoc2(bytes) {
   const wasm3 = await loadEcadWasm();
   if (!wasm3)
     return null;
   return importBindings(wasm3).parseAltiumPcbDoc(bytes);
 }
-async function parseAltiumPcbLib(bytes) {
+async function parseAltiumPcbLib2(bytes) {
   const wasm3 = await loadEcadWasm();
   if (!wasm3)
     return null;
@@ -11759,11 +11799,11 @@ __export(dist_exports, {
   mountingHolesFromPcb: () => mountingHolesFromPcb,
   netContinuity: () => netContinuity,
   outlineAabb: () => outlineAabb,
-  parseAltiumAsciiPcb: () => parseAltiumAsciiPcb,
-  parseAltiumPcbDoc: () => parseAltiumPcbDoc,
-  parseAltiumPcbLib: () => parseAltiumPcbLib,
+  parseAltiumAsciiPcb: () => parseAltiumAsciiPcb2,
+  parseAltiumPcbDoc: () => parseAltiumPcbDoc2,
+  parseAltiumPcbLib: () => parseAltiumPcbLib2,
   parseBindingKey: () => parseBindingKey,
-  parseEagleBrd: () => parseEagleBrd,
+  parseEagleBrd: () => parseEagleBrd2,
   parseExpression: () => parse,
   parseKicadPcb: () => parseKicadPcb2,
   parseXyz: () => parseXyz,
@@ -41591,6 +41631,76 @@ var init_CHANGELOG = __esm({
     CHANGELOG_default = {
       $schema: "./changelog.schema.json",
       entries: [
+        {
+          id: "2026-08-25-measure-joint-sweep",
+          version: "0.9.4",
+          date: "2026-08-25",
+          category: "feat",
+          title: "measure sweeps a mechanism's range of motion",
+          summary: "measure now takes joint_state and sweep: the worst distance across a joint's travel plus the full per-pose margin curve; check_clearance gains include_samples and out-of-limits warnings.",
+          features: [
+            "measure",
+            "clearance",
+            "assembly",
+            "joints",
+            "kinematics"
+          ],
+          mcpTools: [
+            "measure",
+            "check_clearance"
+          ]
+        },
+        {
+          id: "2026-08-19-photoreal-animation",
+          version: "0.9.4",
+          date: "2026-08-19",
+          category: "perf",
+          title: "Photoreal animation evaluates geometry once",
+          summary: "vcad-render --photoreal --animate poses a jointed assembly over a timeline, evaluating the document once for the whole sequence instead of once per frame.",
+          details: "A joint-animated assembly is the same parts in different places, so the expensive half of a photoreal render \u2014 evaluating the parametric DAG into BReps and building a BVH over each part \u2014 belongs outside the frame loop. --animate puts it there: evaluate once, build one BLAS per part, then per frame solve forward kinematics (the same vcad-eval solver the app's assembly mode and the MCP timeline use), hand each object its new object\u2192world transform, and rebuild only the top-level acceleration structure before tracing. Poses come from the document's own timeline, or from a keyframe file with a joint-track shorthand; joints resolve by id or by authored name and a name that matches nothing fails with the list that does. The camera is framed on the union of every pose, so the subject never swims or clips. Frames land as frame_NNNN.png in the -o directory and are muxed to H.264 when ffmpeg is on PATH. On a 35-part machine at 640px/16spp the once-only evaluation was 215s against ~85s of tracing per frame \u2014 previously repaid in full on every frame.",
+          features: [
+            "rendering",
+            "photoreal",
+            "animation",
+            "assemblies",
+            "joints",
+            "cli"
+          ]
+        },
+        {
+          id: "2026-08-19-loon-modules-and-root-cache",
+          version: "0.9.4",
+          date: "2026-08-19",
+          category: "feat",
+          title: "Loon lib path and a content-addressed evaluation cache",
+          summary: "[use] modules resolve next to the file then on $VCAD_LOON_PATH, identically in vcad, vcad-render and MCP; evaluated root meshes are cached on disk keyed by expression + kernel build.",
+          features: [
+            "loon",
+            "modules",
+            "cache",
+            "cli",
+            "render"
+          ],
+          mcpTools: [
+            "load_document",
+            "create_cad_loon"
+          ]
+        },
+        {
+          id: "2026-08-19-builtin-material-library",
+          version: "0.9.4",
+          date: "2026-08-19",
+          category: "feat",
+          title: "Renders know the standard material names",
+          summary: 'A part named "aluminum" or "copper" with no [material] block rendered as clay grey; named materials now resolve to a built-in PBR library.',
+          details: `Hand-written .loon documents name a material rather than define one \u2014 [root frame-rails "aluminum"] and nothing else \u2014 so the document's materials table stayed empty and every part fell through to the path tracer's default clay. The renderer now resolves an undeclared name against a built-in library of ~40 well-known materials (metals with measured F0 reflectance, plastics, composites, organics), case- and separator-insensitive so abs-black and abs_black are one material. Document-declared materials always win. Both the photoreal and drafting paths resolve through the same table, so their hues agree.`,
+          features: [
+            "rendering",
+            "photoreal",
+            "materials",
+            "loon"
+          ]
+        },
         {
           id: "2026-08-17-altium-pcb-import",
           version: "0.9.4",
@@ -50177,7 +50287,7 @@ var init_source_provenance = __esm({
 
 // src/tools/loon.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join2, resolve as resolve2, sep as sep2 } from "node:path";
+import { delimiter, isAbsolute as isAbsolute2, join as join2, resolve as resolve2, sep as sep2 } from "node:path";
 function composeLoonProgram(input) {
   const { source, use_loons, loons } = input;
   const names = [
@@ -50208,12 +50318,18 @@ function readModule(base, name) {
   }
   return null;
 }
+function loonLibDirs(env = process.env) {
+  const raw = env.VCAD_LOON_PATH;
+  if (!raw) return [];
+  return raw.split(delimiter).filter((d) => d.length > 0);
+}
 function composeLoonModules(input) {
   const { source, loons, modules, base_dir } = input;
   const map = {};
   for (const m of loons ?? []) map[m.name] = m.source;
   Object.assign(map, modules ?? {});
-  if (base_dir) {
+  const dirs = [...base_dir ? [base_dir] : [], ...loonLibDirs()];
+  if (dirs.length) {
     const pending2 = [
       ...importedNames(source),
       ...Object.values(map).flatMap(importedNames)
@@ -50223,7 +50339,11 @@ function composeLoonModules(input) {
       const name = pending2.pop();
       if (seen.has(name) || map[name]) continue;
       seen.add(name);
-      const src = readModule(base_dir, name);
+      let src = null;
+      for (const dir of dirs) {
+        src = readModule(dir, name);
+        if (src !== null) break;
+      }
       if (src === null) continue;
       map[name] = src;
       pending2.push(...importedNames(src));
@@ -53142,8 +53262,129 @@ var init_inspect = __esm({
   }
 });
 
-// src/tools/measure.ts
-function evaluateParts(doc, engine) {
+// src/tools/sweep.ts
+function worseThan(a, b) {
+  if (a.intersecting !== b.intersecting) return a.intersecting;
+  return a.distance < b.distance;
+}
+function parseSweep(raw) {
+  if (raw === void 0 || raw === null) return {};
+  if (!Array.isArray(raw)) {
+    return { error: "`sweep` must be an array of {joint, from, to, steps} axes." };
+  }
+  const sweep = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") {
+      return { error: "Each `sweep` axis must be an object {joint, from, to, steps}." };
+    }
+    const e = entry;
+    const joint = typeof e.joint === "string" ? e.joint.trim() : "";
+    const from = Number(e.from);
+    const to = Number(e.to);
+    const steps = Number(e.steps);
+    if (!joint || !Number.isFinite(from) || !Number.isFinite(to) || !Number.isFinite(steps)) {
+      return {
+        error: "Each `sweep` axis needs a `joint` id/name plus numeric `from`, `to`, and `steps`."
+      };
+    }
+    sweep.push({ joint, from, to, steps });
+  }
+  return sweep.length > 0 ? { sweep } : {};
+}
+function jointLimits(kind) {
+  const k = kind;
+  if (!k) return void 0;
+  if (k.type === "Revolute" || k.type === "Slider") return k.limits;
+  return void 0;
+}
+function jointUnit(kind) {
+  return kind?.type === "Slider" ? "mm" : "deg";
+}
+function resolveSweepAxes(doc, axes) {
+  const joints = doc.joints ?? [];
+  const resolved = [];
+  const warnings = [];
+  for (const axis of axes) {
+    const wanted = String(axis.joint);
+    const found = joints.find((j) => j.id === wanted) ?? joints.find((j) => j.name === wanted);
+    if (!found) {
+      const available = joints.map((j) => `${j.id}${j.name ? ` (${j.name})` : ""}`).join(", ");
+      return { error: `No joint with id or name "${wanted}". Available: ${available || "none"}` };
+    }
+    if (!Number.isFinite(axis.from) || !Number.isFinite(axis.to)) {
+      return { error: `Sweep axis "${wanted}" needs finite \`from\` and \`to\`.` };
+    }
+    const steps = Math.trunc(axis.steps);
+    if (!Number.isFinite(steps) || steps < 1) {
+      return { error: `Sweep axis "${wanted}" needs \`steps\` >= 1.` };
+    }
+    const limits = jointLimits(found.kind);
+    if (limits) {
+      const [lo, hi] = limits;
+      const lowest = Math.min(axis.from, axis.to);
+      const highest = Math.max(axis.from, axis.to);
+      if (lowest < lo || highest > hi) {
+        warnings.push(
+          `sweep axis "${found.id}"${found.name ? ` ("${found.name}")` : ""} spans [${lowest}, ${highest}] ${jointUnit(found.kind)}, outside its declared limits [${lo}, ${hi}] \u2014 the swept range includes poses the joint cannot reach, so the reported worst case may not be physically attainable.`
+        );
+      }
+    }
+    resolved.push({ joint: found.id, from: axis.from, to: axis.to, steps });
+  }
+  if (resolved.length === 0) return { error: "`sweep` needs at least one joint axis." };
+  const total = resolved.reduce((n, a) => n * (a.steps + 1), 1);
+  if (total > MAX_SWEEP_POSES) {
+    return {
+      error: `Sweep grid is ${total} poses (limit ${MAX_SWEEP_POSES}). Lower \`steps\` or sweep fewer joints at once.`
+    };
+  }
+  return { axes: resolved, ...warnings.length > 0 ? { warnings } : {} };
+}
+function poseGrid(axes) {
+  let poses = [[]];
+  for (const axis of axes) {
+    const n = Math.trunc(axis.steps);
+    const next = [];
+    for (const pose of poses) {
+      for (let i = 0; i <= n; i++) {
+        const state = axis.from + (axis.to - axis.from) * i / n;
+        next.push([...pose, { joint: axis.joint, state }]);
+      }
+    }
+    poses = next;
+  }
+  return poses;
+}
+function roundPose(pose) {
+  return pose.map((p) => ({ joint: p.joint, state: round6(p.state) }));
+}
+function poseTransforms(doc, poses) {
+  const joints = doc.joints ?? [];
+  const byId = new Map(joints.map((j) => [j.id, j]));
+  const saved = joints.map((j) => j.state);
+  try {
+    return poses.map((pose) => {
+      for (const { joint, state } of pose) {
+        const j = byId.get(joint);
+        if (j) j.state = state;
+      }
+      return solveForwardKinematics2(doc);
+    });
+  } finally {
+    joints.forEach((j, i) => {
+      j.state = saved[i];
+    });
+  }
+}
+function placeMesh(mesh, transform2) {
+  if (!transform2) return mesh;
+  return transformMesh(mesh, {
+    translate: transform2.translation,
+    rotate: transform2.rotation,
+    scale: transform2.scale
+  });
+}
+function poseableParts(doc, engine) {
   const scene = engine.evaluate(doc);
   const visibleRoots = doc.roots.filter((e) => e.visible !== false);
   const partMaterials = doc.part_materials;
@@ -53151,31 +53392,78 @@ function evaluateParts(doc, engine) {
   for (let i = 0; i < scene.parts.length && i < visibleRoots.length; i++) {
     const root = visibleRoots[i];
     const rootId = String(root.root);
+    const node = doc.nodes[rootId];
     const mesh = scene.parts[i].mesh;
     if (!mesh || mesh.positions.length === 0) continue;
-    const node = doc.nodes[rootId];
     out.push({
       id: rootId,
       name: node?.name ?? void 0,
       material: root.material ?? partMaterials?.[rootId] ?? void 0,
-      mesh
+      localMesh: mesh
     });
   }
   for (const inst of scene.instances ?? []) {
-    const mesh = inst.transform ? transformMesh(inst.mesh, {
-      translate: inst.transform.translation,
-      rotate: inst.transform.rotation,
-      scale: inst.transform.scale
-    }) : inst.mesh;
-    if (!mesh || mesh.positions.length === 0) continue;
+    if (!inst.mesh || inst.mesh.positions.length === 0) continue;
     out.push({
       id: inst.instanceId,
       name: inst.name ?? void 0,
+      localMesh: inst.mesh,
+      transform: inst.transform ?? void 0,
+      instanceId: inst.instanceId
+    });
+  }
+  return out;
+}
+function placeParts(parts, worldTransforms) {
+  const out = [];
+  for (const p of parts) {
+    const transform2 = (p.instanceId ? worldTransforms?.get(p.instanceId) : void 0) ?? p.transform;
+    const mesh = placeMesh(p.localMesh, transform2);
+    if (!mesh || mesh.positions.length === 0) continue;
+    out.push({
+      id: p.id,
+      ...p.name ? { name: p.name } : {},
+      ...p.material ? { material: p.material } : {},
       mesh
     });
   }
   return out;
 }
+var MAX_SWEEP_POSES, MAX_SWEEP_SAMPLES, round6, sweepSchemaProp;
+var init_sweep = __esm({
+  "src/tools/sweep.ts"() {
+    "use strict";
+    init_dist();
+    MAX_SWEEP_POSES = 4096;
+    MAX_SWEEP_SAMPLES = 256;
+    round6 = (v) => Math.round(v * 1e6) / 1e6;
+    sweepSchemaProp = {
+      type: "array",
+      description: "Range-of-motion sweep: drive these joints across their travel and report the WORST pose, not the authored one. Each axis is {joint, from, to, steps}; multiple axes form a Cartesian grid (capped at 4096 poses). Endpoints outside a joint's declared limits are reported as warnings, not clamped. Joint states are restored afterwards \u2014 the sweep never edits the document.",
+      items: {
+        type: "object",
+        properties: {
+          joint: { type: "string", description: "Joint id or name to drive." },
+          from: {
+            type: "number",
+            description: "Start of travel (degrees for revolute, mm for prismatic)."
+          },
+          to: { type: "number", description: "End of travel." },
+          steps: {
+            type: "number",
+            description: "Number of intervals; steps + 1 poses are sampled."
+          }
+        },
+        required: ["joint", "from", "to", "steps"]
+      }
+    };
+  }
+});
+
+// src/tools/measure.ts
+function evaluateParts(doc, engine) {
+  return placeParts(poseableParts(doc, engine));
+}
 function findPart(candidates, wanted) {
   return candidates.find((c) => c.id === wanted) ?? candidates.find((c) => c.name === wanted);
 }
@@ -53325,6 +53613,96 @@ function measureResult(doc, engine, partIds) {
     note: "Distance is negative when the parts overlap (penetration depth). Measured from evaluated tessellations \u2014 accuracy is tessellation-bound."
   };
 }
+function measureSweepResult(doc, engine, partIds, sweep) {
+  if (partIds.length !== 2) {
+    throw new MeasureError(
+      `\`sweep\` measures the distance between TWO parts across a range of motion \u2014 ${partIds.length} part id was given. Pass two \`part_ids\`, or drop \`sweep\` (a single part's bbox/volume/center of mass is a per-pose property; use \`joint_state\` to read it at one pose).`
+    );
+  }
+  let base;
+  try {
+    base = poseableParts(doc, engine);
+  } catch (e) {
+    throw new MeasureError(e instanceof Error ? e.message : String(e));
+  }
+  const pick2 = (wanted) => {
+    const found = base.find((p) => p.id === wanted) ?? base.find((p) => p.name === wanted);
+    if (!found) {
+      const available = base.map((p) => `${p.id}${p.name ? ` (${p.name})` : ""}`).join(", ") || "none";
+      throw new MeasureError(
+        `No part with id or name "${wanted}". Available: ${available}`
+      );
+    }
+    return found;
+  };
+  const [pa, pb] = partIds.map((id) => pick2(String(id)));
+  if (pa.id === pb.id) {
+    throw new MeasureError(
+      `measure needs two distinct parts \u2014 "${pa.id}" was given twice.`
+    );
+  }
+  const { axes, warnings, error: error2 } = resolveSweepAxes(doc, sweep);
+  if (error2 || !axes) throw new MeasureError(error2 ?? "sweep could not be resolved");
+  const poses = poseGrid(axes);
+  let transforms;
+  try {
+    transforms = poseTransforms(doc, poses);
+  } catch (e) {
+    throw new MeasureError(e instanceof Error ? e.message : String(e));
+  }
+  const keepSamples = poses.length <= MAX_SWEEP_SAMPLES;
+  const samples = [];
+  let worst2;
+  for (let i = 0; i < poses.length; i++) {
+    const placed = placeParts([pa, pb], transforms[i]);
+    if (placed.length < 2) {
+      throw new MeasureError(
+        "One of the parts has an empty mesh at some pose \u2014 nothing to measure."
+      );
+    }
+    let r;
+    try {
+      r = engine.meshClearance(placed[0].mesh, placed[1].mesh);
+    } catch (e) {
+      throw new MeasureError(e instanceof Error ? e.message : String(e));
+    }
+    if (keepSamples) {
+      samples.push({
+        pose: roundPose(poses[i]),
+        distance_mm: r6(r.distance),
+        intersecting: r.intersecting
+      });
+    }
+    if (!worst2 || worseThan(r, worst2.r)) {
+      worst2 = { r, pose: poses[i], a: placed[0], b: placed[1] };
+    }
+  }
+  if (!worst2) throw new MeasureError("Sweep produced no poses to measure.");
+  const distance = r6(worst2.r.distance);
+  return {
+    mode: "sweep",
+    distance_mm: distance,
+    contact: distance <= 0,
+    intersecting: worst2.r.intersecting,
+    worst_pose: roundPose(worst2.pose),
+    poses_checked: poses.length,
+    sweep: axes,
+    closest_points: {
+      a: worst2.r.pointA.map(r6),
+      b: worst2.r.pointB.map(r6)
+    },
+    parts: {
+      a: partSnapshot(worst2.a),
+      b: partSnapshot(worst2.b)
+    },
+    ...keepSamples ? { samples } : {
+      samples_omitted: true,
+      samples_note: `Sweep grid is ${poses.length} poses (over the ${MAX_SWEEP_SAMPLES}-pose sample cap) \u2014 the per-pose margin curve was omitted. Lower \`steps\` to get it.`
+    },
+    ...warnings && warnings.length > 0 ? { sweep_warnings: warnings } : {},
+    note: "`distance_mm` is the WORST (minimum) distance over the swept range, not the authored pose; negative means the parts overlap there (penetration depth). `parts` bboxes are those of the worst pose. Measured from evaluated tessellations \u2014 accuracy is tessellation-bound. Joint states are restored: a sweep never edits the document."
+  };
+}
 function measure(args, engine) {
   const documentId = String(args.document_id ?? "");
   if (!documentId) {
@@ -53336,20 +53714,33 @@ function measure(args, engine) {
       "Pass `part_ids` as an array of one or two part ids (or part names)."
     );
   }
+  const { sweep, error: sweepParseError } = parseSweep(args.sweep);
+  if (sweepParseError) return err(sweepParseError);
+  let stored;
+  try {
+    stored = getSession(documentId);
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
   let doc;
+  let pose;
   try {
-    doc = getSession(documentId);
+    ({ doc, pose } = applyJointState(stored, args.joint_state));
   } catch (e) {
     return err(e instanceof Error ? e.message : String(e));
   }
   let payload;
   try {
-    payload = measureResult(doc, engine, partIds);
+    payload = sweep && sweep.length > 0 ? measureSweepResult(doc, engine, partIds, sweep) : measureResult(doc, engine, partIds);
   } catch (e) {
     if (e instanceof MeasureError) return err(e.message);
     throw e;
   }
-  const body = { document_id: documentId, ...payload };
+  const body = {
+    document_id: documentId,
+    ...pose ? { pose } : {},
+    ...payload
+  };
   return {
     content: [{ type: "text", text: JSON.stringify(body) }],
     structuredContent: { measure: body, document_id: documentId }
@@ -53365,10 +53756,11 @@ var r6, point, MeasureError, measureSchema, toolDefs6;
 var init_measure = __esm({
   "src/tools/measure.ts"() {
     "use strict";
-    init_dist();
     init_inspect();
     init_session_core();
     init_tool_def();
+    init_pose();
+    init_sweep();
     r6 = (v) => Math.round(v * 1e6) / 1e6;
     point = (p) => ({
       x: r6(p.x),
@@ -53388,7 +53780,9 @@ var init_measure = __esm({
           type: "array",
           items: { type: "string" },
           description: "One or two part ids (or part names). One id \u2192 that part's bbox, volume, and center of mass. Two ids \u2192 the minimum distance between them (0/negative = contact/overlap) plus each part's bbox."
-        }
+        },
+        joint_state: jointStateSchemaProp,
+        sweep: sweepSchemaProp
       },
       required: ["document_id", "part_ids"]
     };
@@ -53396,7 +53790,7 @@ var init_measure = __esm({
       {
         name: "measure",
         pack: null,
-        description: "Measure geometry in an open session. Pass `part_ids` with two ids to get the minimum distance between those parts (0/negative = contact/overlap) plus each part's world-space bounding box; pass one id to get that part's bbox, volume, and center of mass. Complements `inspect_cad` (whole-document aggregate) and `check_clearance` (named, persisted air-gap assertions). Distances are measured from evaluated tessellations, so accuracy is tessellation-bound.",
+        description: "Measure geometry in an open session. Pass `part_ids` with two ids to get the minimum distance between those parts (0/negative = contact/overlap) plus each part's world-space bounding box; pass one id to get that part's bbox, volume, and center of mass. Pass `joint_state` (joint id or name \u2192 degrees, mm for sliders) to measure a jointed assembly at one real pose instead of the stored one. Pass `sweep` \u2014 [{joint, from, to, steps}] \u2014 with TWO part ids to drive the mechanism through its range of motion and get the WORST (minimum) distance over the whole travel, the pose that realizes it (`worst_pose`), and `samples`: the full per-pose margin curve, so you can see where the clearance collapses rather than only that it does (omitted above 256 poses). Sweep endpoints outside a joint's declared limits are reported in `sweep_warnings`, not clamped; joint states are always restored, so a sweep never edits the document. Complements `inspect_cad` (whole-document aggregate) and `check_clearance` (named, persisted air-gap assertions with pass/fail and whole-document audits). Distances are measured from evaluated tessellations \u2014 swept poses re-place those same meshes \u2014 so accuracy is tessellation-bound.",
         inputSchema: measureSchema,
         handler: (a, c) => measure(a, c.engine),
         behavior: behavior({})
@@ -57947,51 +58341,6 @@ function clearanceHolds(distanceMm, minMm, allowContact, intersecting = false) {
   if (intersecting) return false;
   return distanceMm >= minMm || allowContact && clearanceVerdict(distanceMm) === "touching";
 }
-function worseThan(a, b) {
-  if (a.intersecting !== b.intersecting) return a.intersecting;
-  return a.distance < b.distance;
-}
-function placeMesh(mesh, transform2) {
-  if (!transform2) return mesh;
-  return transformMesh(mesh, {
-    translate: transform2.translation,
-    rotate: transform2.rotation,
-    scale: transform2.scale
-  });
-}
-function poseableParts(doc, engine) {
-  const scene = engine.evaluate(doc);
-  const visibleRoots = doc.roots.filter((e) => e.visible !== false);
-  const out = [];
-  for (let i = 0; i < scene.parts.length && i < visibleRoots.length; i++) {
-    const rootId = visibleRoots[i].root;
-    const node = doc.nodes[String(rootId)];
-    const mesh = scene.parts[i].mesh;
-    if (!mesh || mesh.positions.length === 0) continue;
-    out.push({ id: String(rootId), name: node?.name ?? void 0, localMesh: mesh });
-  }
-  for (const inst of scene.instances ?? []) {
-    if (!inst.mesh || inst.mesh.positions.length === 0) continue;
-    out.push({
-      id: inst.instanceId,
-      name: inst.name ?? void 0,
-      localMesh: inst.mesh,
-      transform: inst.transform ?? void 0,
-      instanceId: inst.instanceId
-    });
-  }
-  return out;
-}
-function placeParts(parts, worldTransforms) {
-  const out = [];
-  for (const p of parts) {
-    const transform2 = (p.instanceId ? worldTransforms?.get(p.instanceId) : void 0) ?? p.transform;
-    const mesh = placeMesh(p.localMesh, transform2);
-    if (!mesh || mesh.positions.length === 0) continue;
-    out.push({ id: p.id, ...p.name ? { name: p.name } : {}, mesh });
-  }
-  return out;
-}
 function resolveGroup(candidates, ids) {
   const parts = /* @__PURE__ */ new Map();
   const missing = [];
@@ -58003,67 +58352,6 @@ function resolveGroup(candidates, ids) {
   }
   return { parts: [...parts.values()], missing };
 }
-function resolveSweepAxes(doc, axes) {
-  const joints = doc.joints ?? [];
-  const resolved = [];
-  for (const axis of axes) {
-    const wanted = String(axis.joint);
-    const found = joints.find((j) => j.id === wanted) ?? joints.find((j) => j.name === wanted);
-    if (!found) {
-      const available = joints.map((j) => `${j.id}${j.name ? ` (${j.name})` : ""}`).join(", ");
-      return { error: `No joint with id or name "${wanted}". Available: ${available || "none"}` };
-    }
-    if (!Number.isFinite(axis.from) || !Number.isFinite(axis.to)) {
-      return { error: `Sweep axis "${wanted}" needs finite \`from\` and \`to\`.` };
-    }
-    const steps = Math.trunc(axis.steps);
-    if (!Number.isFinite(steps) || steps < 1) {
-      return { error: `Sweep axis "${wanted}" needs \`steps\` >= 1.` };
-    }
-    resolved.push({ joint: found.id, from: axis.from, to: axis.to, steps });
-  }
-  if (resolved.length === 0) return { error: "`sweep` needs at least one joint axis." };
-  const total = resolved.reduce((n, a) => n * (a.steps + 1), 1);
-  if (total > MAX_SWEEP_POSES) {
-    return {
-      error: `Sweep grid is ${total} poses (limit ${MAX_SWEEP_POSES}). Lower \`steps\` or sweep fewer joints at once.`
-    };
-  }
-  return { axes: resolved };
-}
-function poseGrid(axes) {
-  let poses = [[]];
-  for (const axis of axes) {
-    const n = Math.trunc(axis.steps);
-    const next = [];
-    for (const pose of poses) {
-      for (let i = 0; i <= n; i++) {
-        const state = axis.from + (axis.to - axis.from) * i / n;
-        next.push([...pose, { joint: axis.joint, state }]);
-      }
-    }
-    poses = next;
-  }
-  return poses;
-}
-function poseTransforms(doc, poses) {
-  const joints = doc.joints ?? [];
-  const byId = new Map(joints.map((j) => [j.id, j]));
-  const saved = joints.map((j) => j.state);
-  try {
-    return poses.map((pose) => {
-      for (const { joint, state } of pose) {
-        const j = byId.get(joint);
-        if (j) j.state = state;
-      }
-      return solveForwardKinematics2(doc);
-    });
-  } finally {
-    joints.forEach((j, i) => {
-      j.state = saved[i];
-    });
-  }
-}
 function computeGroupClearance(doc, engine, groupA, groupB, sweep) {
   if (groupA.length === 0 || groupB.length === 0) {
     return { error: "Both `group_a` and `group_b` need at least one part id." };
@@ -58077,7 +58365,7 @@ function computeGroupClearance(doc, engine, groupA, groupB, sweep) {
   if (!sweep || sweep.length === 0) {
     return measureGroups(engine, placeParts(base), groupA, groupB);
   }
-  const { axes, error: sweepError } = resolveSweepAxes(doc, sweep);
+  const { axes, warnings, error: sweepError } = resolveSweepAxes(doc, sweep);
   if (sweepError || !axes) return { error: sweepError ?? "sweep could not be resolved" };
   const poses = poseGrid(axes);
   let transforms;
@@ -58087,6 +58375,8 @@ function computeGroupClearance(doc, engine, groupA, groupB, sweep) {
     return { error: e instanceof Error ? e.message : String(e) };
   }
   let worst2;
+  const samples = [];
+  const keepSamples = poses.length <= MAX_SWEEP_SAMPLES;
   for (let i = 0; i < poses.length; i++) {
     const { result, error: error2 } = measureGroups(
       engine,
@@ -58095,6 +58385,13 @@ function computeGroupClearance(doc, engine, groupA, groupB, sweep) {
       groupB
     );
     if (error2 || !result) return { error: error2 };
+    if (keepSamples) {
+      samples.push({
+        pose: roundPose(poses[i]),
+        distance_mm: result.distance_mm,
+        intersecting: result.intersecting
+      });
+    }
     if (!worst2 || worseThan(
       { distance: result.distance_mm, intersecting: result.intersecting },
       { distance: worst2.result.distance_mm, intersecting: worst2.result.intersecting }
@@ -58106,8 +58403,10 @@ function computeGroupClearance(doc, engine, groupA, groupB, sweep) {
   return {
     result: {
       ...worst2.result,
-      worst_pose: worst2.pose.map((p) => ({ joint: p.joint, state: round6(p.state) })),
-      poses_checked: poses.length
+      worst_pose: roundPose(worst2.pose),
+      poses_checked: poses.length,
+      ...keepSamples ? { samples } : {},
+      ...warnings && warnings.length > 0 ? { sweep_warnings: warnings } : {}
     }
   };
 }
@@ -58191,10 +58490,12 @@ function computeInterferenceAudit(doc, engine, opts) {
     return { error: e instanceof Error ? e.message : String(e) };
   }
   let poses = [];
+  let sweepWarnings;
   let transforms = [void 0];
   if (opts.sweep && opts.sweep.length > 0) {
-    const { axes, error: error2 } = resolveSweepAxes(doc, opts.sweep);
+    const { axes, warnings, error: error2 } = resolveSweepAxes(doc, opts.sweep);
     if (error2 || !axes) return { error: error2 ?? "sweep could not be resolved" };
+    sweepWarnings = warnings;
     poses = poseGrid(axes);
     try {
       transforms = poseTransforms(doc, poses);
@@ -58285,7 +58586,8 @@ function computeInterferenceAudit(doc, engine, opts) {
       queries,
       ...poses.length > 0 ? { poses_checked: poses.length } : {},
       findings,
-      unresolved_ignores: [...new Set(unresolved)]
+      unresolved_ignores: [...new Set(unresolved)],
+      ...sweepWarnings && sweepWarnings.length > 0 ? { sweep_warnings: sweepWarnings } : {}
     }
   };
 }
@@ -58303,6 +58605,7 @@ async function checkClearance(args, engine) {
   const groupB = stringArray(args.group_b);
   const label = typeof args.label === "string" && args.label.trim() ? args.label.trim() : void 0;
   const allowContact = asBool(args.allow_contact);
+  const includeSamples = asBool(args.include_samples);
   const { sweep, error: sweepParseError } = parseSweep(args.sweep);
   if (sweepParseError) return err3(sweepParseError);
   if (label && args.joint_state !== void 0 && args.joint_state !== null) {
@@ -58358,6 +58661,11 @@ async function checkClearance(args, engine) {
     worst_pair: result.worst_pair,
     ...result.worst_pose ? { worst_pose: result.worst_pose } : {},
     ...result.poses_checked !== void 0 ? { poses_checked: result.poses_checked } : {},
+    ...result.sweep_warnings ? { sweep_warnings: result.sweep_warnings } : {},
+    ...includeSamples && result.poses_checked !== void 0 ? result.samples ? { samples: result.samples } : {
+      samples_omitted: true,
+      samples_note: `Sweep grid is ${result.poses_checked} poses (over the ${MAX_SWEEP_SAMPLES}-pose sample cap) \u2014 per-pose samples were omitted. Lower \`steps\` to get the margin curve.`
+    } : {},
     pairs_checked: result.pairs_checked,
     group_a: result.group_a,
     group_b: result.group_b,
@@ -58374,30 +58682,6 @@ async function checkClearance(args, engine) {
     }
   };
 }
-function parseSweep(raw) {
-  if (raw === void 0 || raw === null) return {};
-  if (!Array.isArray(raw)) {
-    return { error: "`sweep` must be an array of {joint, from, to, steps} axes." };
-  }
-  const sweep = [];
-  for (const entry of raw) {
-    if (!entry || typeof entry !== "object") {
-      return { error: "Each `sweep` axis must be an object {joint, from, to, steps}." };
-    }
-    const e = entry;
-    const joint = typeof e.joint === "string" ? e.joint.trim() : "";
-    const from = Number(e.from);
-    const to = Number(e.to);
-    const steps = Number(e.steps);
-    if (!joint || !Number.isFinite(from) || !Number.isFinite(to) || !Number.isFinite(steps)) {
-      return {
-        error: "Each `sweep` axis needs a `joint` id/name plus numeric `from`, `to`, and `steps`."
-      };
-    }
-    sweep.push({ joint, from, to, steps });
-  }
-  return sweep.length > 0 ? { sweep } : {};
-}
 function parseIgnorePairs(raw) {
   if (raw === void 0 || raw === null) return { pairs: [] };
   if (!Array.isArray(raw)) {
@@ -58441,6 +58725,7 @@ function auditClearance(documentId, doc, engine, args, sweep, label, pose) {
     pairs_broadphase: result.pairs_broadphase,
     queries: result.queries,
     ...result.poses_checked !== void 0 ? { poses_checked: result.poses_checked } : {},
+    ...result.sweep_warnings ? { sweep_warnings: result.sweep_warnings } : {},
     ...result.unresolved_ignores.length > 0 ? {
       unresolved_ignores: result.unresolved_ignores,
       note: `ignore_pairs named parts that do not exist: ${result.unresolved_ignores.join(", ")} \u2014 those pairs were NOT whitelisted.`
@@ -58605,16 +58890,17 @@ function err3(text) {
     isError: true
   };
 }
-var CLEARANCE_CLAIM_PREFIX, MECH_DOMAIN2, CLEARANCE_ORACLE, STALE_EPS_MM, CONTACT_EPS_MM, round6, checkClearanceSchema, MAX_SWEEP_POSES, pairKey, toolDefs11;
+var CLEARANCE_CLAIM_PREFIX, MECH_DOMAIN2, CLEARANCE_ORACLE, STALE_EPS_MM, CONTACT_EPS_MM, checkClearanceSchema, pairKey, toolDefs11;
 var init_clearance = __esm({
   "src/tools/clearance.ts"() {
     "use strict";
     init_tool_def();
-    init_dist();
     init_receipt_unified();
     init_pose();
     init_session_core();
     init_arg_coerce();
+    init_sweep();
+    init_sweep();
     CLEARANCE_CLAIM_PREFIX = "mech.clearance.";
     MECH_DOMAIN2 = "mechanical";
     CLEARANCE_ORACLE = {
@@ -58623,7 +58909,6 @@ var init_clearance = __esm({
     };
     STALE_EPS_MM = 1e-6;
     CONTACT_EPS_MM = 1e-3;
-    round6 = (v) => Math.round(v * 1e6) / 1e6;
     checkClearanceSchema = {
       type: "object",
       properties: {
@@ -58654,19 +58939,10 @@ var init_clearance = __esm({
           description: "Treat exact surface contact (measured distance within 0.001 mm of zero) as passing even though it is below `min_mm` \u2014 for parts designed to touch, e.g. a stage bolted flush to the chamber floor. Penetration beyond the tolerance still fails. Persisted with the spec when `label` is given."
         },
         joint_state: jointStateSchemaProp,
-        sweep: {
-          type: "array",
-          description: "Range-of-motion sweep: drive these joints across their travel and report the WORST pose, not the authored one. Each axis is {joint, from, to, steps}; multiple axes form a Cartesian grid (capped at 4096 poses). Joint states are restored afterwards \u2014 the sweep never edits the document.",
-          items: {
-            type: "object",
-            properties: {
-              joint: { type: "string", description: "Joint id or name to drive." },
-              from: { type: "number", description: "Start of travel (degrees for revolute, mm for prismatic)." },
-              to: { type: "number", description: "End of travel." },
-              steps: { type: "number", description: "Number of intervals; steps + 1 poses are sampled." }
-            },
-            required: ["joint", "from", "to", "steps"]
-          }
+        sweep: sweepSchemaProp,
+        include_samples: {
+          type: "boolean",
+          description: "Swept queries only: return the per-pose margin curve as `samples` \u2014 one {pose, distance_mm, intersecting} entry per pose, in grid order. Omitted (with a note) when the grid exceeds 256 poses. Never persisted with a labelled spec."
         },
         ignore_pairs: {
           type: "array",
@@ -58687,13 +58963,12 @@ var init_clearance = __esm({
       },
       required: ["document_id"]
     };
-    MAX_SWEEP_POSES = 4096;
     pairKey = (a, b) => a < b ? `${a}\0${b}` : `${b}\0${a}`;
     toolDefs11 = [
       {
         name: "check_clearance",
         pack: null,
-        description: "Measure the minimum distance between two groups of parts in a CAD session and assert it stays above `min_mm` \u2014 air gaps, press fits, screw-head clearances. Reports the measured minimum (negative = penetration depth), a clear/touching/intersecting verdict, the worst part pair, and pass/fail. Pass `allow_contact: true` for parts designed to touch (e.g. bolted flush) so exact contact passes instead of reading as an intersection. Pass `joint_state` to measure at one real pose (joint id or name \u2192 degrees, or mm for sliders) instead of the stored one. Give it a `label` to persist the assertion on the document: build_receipt then emits it as a mech.clearance claim and verify_receipt re-verifies it as Holds / Stale / Violated when geometry changes. Two modes beyond the single-pair snapshot: (1) `sweep` \u2014 pass [{joint, from, to, steps}] to drive the mechanism through its range of motion and report the WORST pose, not the one it was authored in (a linkage modelled at mid-travel routinely clears there and collides at both ends); persisted with the label, so the assertion re-verifies over the same range. (2) audit \u2014 omit `group_a`/`group_b` entirely to broadphase EVERY part pair in the document and list everything that interpenetrates, with penetration depth; whitelist intended contact with `ignore_pairs` (Fixed-joint pairs are skipped by default). Combine both for 'does this machine ever hit itself anywhere in its workspace'.",
+        description: "Measure the minimum distance between two groups of parts in a CAD session and assert it stays above `min_mm` \u2014 air gaps, press fits, screw-head clearances. Reports the measured minimum (negative = penetration depth), a clear/touching/intersecting verdict, the worst part pair, and pass/fail. Pass `allow_contact: true` for parts designed to touch (e.g. bolted flush) so exact contact passes instead of reading as an intersection. Pass `joint_state` to measure at one real pose (joint id or name \u2192 degrees, or mm for sliders) instead of the stored one. Give it a `label` to persist the assertion on the document: build_receipt then emits it as a mech.clearance claim and verify_receipt re-verifies it as Holds / Stale / Violated when geometry changes. Two modes beyond the single-pair snapshot: (1) `sweep` \u2014 pass [{joint, from, to, steps}] to drive the mechanism through its range of motion and report the WORST pose, not the one it was authored in (a linkage modelled at mid-travel routinely clears there and collides at both ends); persisted with the label, so the assertion re-verifies over the same range. Sweep endpoints beyond a joint's declared limits are reported in `sweep_warnings` rather than clamped, and `include_samples: true` returns the per-pose margin curve as `samples` (one {pose, distance_mm, intersecting} per pose, omitted above 256 poses and never persisted). Swept distances come from the same tessellated meshes, re-placed per pose, so accuracy stays tessellation-bound. (2) audit \u2014 omit `group_a`/`group_b` entirely to broadphase EVERY part pair in the document and list everything that interpenetrates, with penetration depth; whitelist intended contact with `ignore_pairs` (Fixed-joint pairs are skipped by default). Combine both for 'does this machine ever hit itself anywhere in its workspace'.",
         inputSchema: checkClearanceSchema,
         handler: (a, c) => checkClearance(a, c.engine),
         behavior: behavior({ writesDoc: true })
@@ -78728,7 +79003,7 @@ async function importAltium(input) {
   const binary = isCompoundFile(bytes);
   let pcb;
   try {
-    pcb = binary ? await parseAltiumPcbDoc(new Uint8Array(bytes)) : await parseAltiumAsciiPcb(bytes.toString("utf8"));
+    pcb = binary ? await parseAltiumPcbDoc2(new Uint8Array(bytes)) : await parseAltiumAsciiPcb2(bytes.toString("utf8"));
   } catch (e) {
     return importError(
       `Could not parse the Altium ${binary ? "binary" : "ASCII"} .PcbDoc: ` + (e instanceof Error ? e.message : String(e))
@@ -78769,7 +79044,7 @@ async function importAltiumLibrary(input) {
   }
   let lib;
   try {
-    lib = await parseAltiumPcbLib(new Uint8Array(bytes));
+    lib = await parseAltiumPcbLib2(new Uint8Array(bytes));
   } catch (e) {
     return importError(
       `Could not parse the Altium .PcbLib: ${e instanceof Error ? e.message : String(e)}`
@@ -78818,7 +79093,7 @@ async function importEagle(input) {
   }
   let pcb;
   try {
-    pcb = await parseEagleBrd(content);
+    pcb = await parseEagleBrd2(content);
   } catch (e) {
     return importError(
       `Could not parse the Eagle .brd: ${e instanceof Error ? e.message : String(e)}`
@@ -83983,8 +84258,8 @@ var init_server3 = __esm({
     init_order_feed();
     init_animate();
     PKG_VERSION = (() => {
-      if ("0.9.4-main.73") {
-        return "0.9.4-main.73";
+      if ("0.9.4-main.75") {
+        return "0.9.4-main.75";
       }
       try {
         const req = createRequire2(import.meta.url);
@@ -83993,8 +84268,8 @@ var init_server3 = __esm({
         return "0.0.0";
       }
     })();
-    BUILD_SHA = "c94448044a725e430c38faf507027d5a10b2c68d";
-    BUILD_TIME = "2026-08-17T23:42:23.328Z";
+    BUILD_SHA = "89230349e9d445891fbcb1efd7f0cc9425ba972e";
+    BUILD_TIME = "2026-08-25T23:30:10.326Z";
     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.9.4-main.73",
+  "version": "0.9.4-main.75",
   "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": "c94448044a725e430c38faf507027d5a10b2c68d",
-    "builtAt": "2026-08-17T23:42:23.328Z"
+    "sha": "89230349e9d445891fbcb1efd7f0cc9425ba972e",
+    "builtAt": "2026-08-25T23:30:10.326Z"
   }
 }