@vcad/mcp 0.9.4-main.35 → 0.9.4-main.36

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 05b902db41f28989ab2bae377db68a55dd2a7121 at 2026-07-26T13:07:16.613Z. Source: https://github.com/ecto/vcad
+Built from 3b9087f300b569c70aa24cebc52af06d15e59187 at 2026-07-26T13:20:01.737Z. Source: https://github.com/ecto/vcad

package/index.mjs

@@ -40914,6 +40914,25 @@ var init_CHANGELOG = __esm({
     CHANGELOG_default = {
       $schema: "./changelog.schema.json",
       entries: [
+        {
+          id: "2026-07-26-swept-and-all-pairs-clearance",
+          version: "0.9.4",
+          date: "2026-07-26",
+          category: "feat",
+          title: "check_clearance sweeps the range of motion",
+          summary: "Pass `sweep` to drive joints through their travel and get the worst pose, or omit both groups to audit every part pair in the document for interference.",
+          features: [
+            "clearance",
+            "assembly",
+            "kinematics",
+            "mcp"
+          ],
+          mcpTools: [
+            "check_clearance",
+            "build_receipt",
+            "verify_receipt"
+          ]
+        },
         {
           id: "2026-07-26-render-loon-directly",
           version: "0.9.4",
@@ -55576,10 +55595,23 @@ function clearanceVerdict(distanceMm) {
   if (distanceMm <= CONTACT_EPS_MM) return "touching";
   return "clear";
 }
-function clearanceHolds(distanceMm, minMm, allowContact) {
+function clearanceHolds(distanceMm, minMm, allowContact, intersecting = false) {
+  if (intersecting) return false;
   return distanceMm >= minMm || allowContact && clearanceVerdict(distanceMm) === "touching";
 }
-function partCandidates(doc, engine) {
+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 = [];
@@ -55588,23 +55620,30 @@ function partCandidates(doc, engine) {
     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, mesh });
+    out.push({ id: String(rootId), name: node?.name ?? void 0, 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,
-      mesh
+      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 = [];
@@ -55616,16 +55655,115 @@ function resolveGroup(candidates, ids) {
   }
   return { parts: [...parts.values()], missing };
 }
-function computeGroupClearance(doc, engine, groupA, groupB) {
+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." };
   }
-  let candidates;
+  let base;
+  try {
+    base = poseableParts(doc, engine);
+  } catch (e) {
+    return { error: e instanceof Error ? e.message : String(e) };
+  }
+  if (!sweep || sweep.length === 0) {
+    return measureGroups(engine, placeParts(base), groupA, groupB);
+  }
+  const { axes, error: sweepError } = resolveSweepAxes(doc, sweep);
+  if (sweepError || !axes) return { error: sweepError ?? "sweep could not be resolved" };
+  const poses = poseGrid(axes);
+  let transforms;
   try {
-    candidates = partCandidates(doc, engine);
+    transforms = poseTransforms(doc, poses);
   } catch (e) {
     return { error: e instanceof Error ? e.message : String(e) };
   }
+  let worst2;
+  for (let i = 0; i < poses.length; i++) {
+    const { result, error: error2 } = measureGroups(
+      engine,
+      placeParts(base, transforms[i]),
+      groupA,
+      groupB
+    );
+    if (error2 || !result) return { error: error2 };
+    if (!worst2 || worseThan(
+      { distance: result.distance_mm, intersecting: result.intersecting },
+      { distance: worst2.result.distance_mm, intersecting: worst2.result.intersecting }
+    )) {
+      worst2 = { result, pose: poses[i] };
+    }
+  }
+  if (!worst2) return { error: "Sweep produced no poses to measure." };
+  return {
+    result: {
+      ...worst2.result,
+      worst_pose: worst2.pose.map((p) => ({ joint: p.joint, state: round6(p.state) })),
+      poses_checked: poses.length
+    }
+  };
+}
+function measureGroups(engine, candidates, groupA, groupB) {
   const a = resolveGroup(candidates, groupA);
   const b = resolveGroup(candidates, groupB);
   const missing = [...a.missing, ...b.missing];
@@ -55652,7 +55790,7 @@ function computeGroupClearance(doc, engine, groupA, groupB) {
         return { error: e instanceof Error ? e.message : String(e) };
       }
       pairs += 1;
-      if (!worst2 || r.distance < worst2.r.distance) {
+      if (!worst2 || worseThan(r, worst2.r)) {
         worst2 = { a: pa, b: pb, r };
       }
     }
@@ -55677,6 +55815,132 @@ function computeGroupClearance(doc, engine, groupA, groupB) {
     }
   };
 }
+function meshAabb(mesh) {
+  const p = mesh.positions;
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0; i + 2 < p.length; i += 3) {
+    for (let k = 0; k < 3; k++) {
+      const v = p[i + k];
+      if (v < min[k]) min[k] = v;
+      if (v > max[k]) max[k] = v;
+    }
+  }
+  return { min, max };
+}
+function aabbNear(a, b, margin) {
+  for (let k = 0; k < 3; k++) {
+    if (a.min[k] - margin > b.max[k]) return false;
+    if (b.min[k] - margin > a.max[k]) return false;
+  }
+  return true;
+}
+function computeInterferenceAudit(doc, engine, opts) {
+  let base;
+  try {
+    base = poseableParts(doc, engine);
+  } catch (e) {
+    return { error: e instanceof Error ? e.message : String(e) };
+  }
+  let poses = [];
+  let transforms = [void 0];
+  if (opts.sweep && opts.sweep.length > 0) {
+    const { axes, error: error2 } = resolveSweepAxes(doc, opts.sweep);
+    if (error2 || !axes) return { error: error2 ?? "sweep could not be resolved" };
+    poses = poseGrid(axes);
+    try {
+      transforms = poseTransforms(doc, poses);
+    } catch (e) {
+      return { error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  const first = placeParts(base, transforms[0]);
+  if (first.length < 2) {
+    return { error: "Fewer than two measurable parts \u2014 nothing to audit." };
+  }
+  const ignore = /* @__PURE__ */ new Set();
+  const unresolved = [];
+  const resolveId = (raw) => {
+    const wanted = String(raw);
+    return (first.find((c) => c.id === wanted) ?? first.find((c) => c.name === wanted))?.id;
+  };
+  for (const [rawA, rawB] of opts.ignorePairs) {
+    const a = resolveId(rawA);
+    const b = resolveId(rawB);
+    if (!a) unresolved.push(String(rawA));
+    if (!b) unresolved.push(String(rawB));
+    if (a && b) ignore.add(pairKey(a, b));
+  }
+  for (const joint of doc.joints ?? []) {
+    const parent = joint.parentInstanceId;
+    if (!parent) continue;
+    const fixed = joint.kind?.type === "Fixed";
+    if (opts.ignoreAdjacent || fixed && opts.ignoreFixedJoints) {
+      ignore.add(pairKey(parent, joint.childInstanceId));
+    }
+  }
+  const margin = Math.max(opts.minMm, 0);
+  const worstByPair = /* @__PURE__ */ new Map();
+  const broadphase = /* @__PURE__ */ new Set();
+  let queries = 0;
+  let ignored = 0;
+  for (let p = 0; p < transforms.length; p++) {
+    const parts = p === 0 ? first : placeParts(base, transforms[p]);
+    const boxes = parts.map((c) => meshAabb(c.mesh));
+    for (let i = 0; i < parts.length; i++) {
+      for (let j = i + 1; j < parts.length; j++) {
+        const key = pairKey(parts[i].id, parts[j].id);
+        if (ignore.has(key)) {
+          if (p === 0) ignored += 1;
+          continue;
+        }
+        if (!aabbNear(boxes[i], boxes[j], margin + CONTACT_EPS_MM)) continue;
+        broadphase.add(key);
+        let r;
+        try {
+          r = engine.meshClearance(parts[i].mesh, parts[j].mesh);
+        } catch (e) {
+          return { error: e instanceof Error ? e.message : String(e) };
+        }
+        queries += 1;
+        const prev = worstByPair.get(key);
+        if (!prev || worseThan(r, prev.r)) {
+          worstByPair.set(key, {
+            a: parts[i],
+            b: parts[j],
+            r,
+            ...poses.length > 0 ? { pose: poses[p] } : {}
+          });
+        }
+      }
+    }
+  }
+  const named = (p) => ({ id: p.id, ...p.name ? { name: p.name } : {} });
+  const findings = [...worstByPair.values()].filter((w) => !clearanceHolds(round6(w.r.distance), opts.minMm, false, w.r.intersecting)).map((w) => ({
+    a: named(w.a),
+    b: named(w.b),
+    distance_mm: round6(w.r.distance),
+    verdict: w.r.intersecting ? "intersecting" : clearanceVerdict(round6(w.r.distance)),
+    point_a: w.r.pointA.map(round6),
+    point_b: w.r.pointB.map(round6),
+    ...w.pose ? { worst_pose: w.pose.map((s) => ({ joint: s.joint, state: round6(s.state) })) } : {}
+  })).sort(
+    (x, y) => Number(y.verdict === "intersecting") - Number(x.verdict === "intersecting") || x.distance_mm - y.distance_mm
+  );
+  const n = first.length;
+  return {
+    result: {
+      parts_checked: n,
+      pairs_total: n * (n - 1) / 2,
+      pairs_ignored: ignored,
+      pairs_broadphase: broadphase.size,
+      queries,
+      ...poses.length > 0 ? { poses_checked: poses.length } : {},
+      findings,
+      unresolved_ignores: [...new Set(unresolved)]
+    }
+  };
+}
 function upsertClearanceSpec(doc, spec) {
   const specs = doc.clearance_specs ?? [];
   const idx = specs.findIndex((s) => s.label === spec.label);
@@ -55689,16 +55953,13 @@ async function checkClearance(args, engine) {
   if (!documentId) return err3("Pass `document_id` (the CAD session).");
   const groupA = stringArray(args.group_a);
   const groupB = stringArray(args.group_b);
-  if (!groupA || !groupB) {
-    return err3("Pass `group_a` and `group_b` as arrays of part ids (or part names).");
-  }
-  const minMm = typeof args.min_mm === "number" ? args.min_mm : NaN;
-  if (!Number.isFinite(minMm)) return err3("Pass `min_mm`, the required minimum separation in mm.");
   const label = typeof args.label === "string" && args.label.trim() ? args.label.trim() : void 0;
   const allowContact = asBool(args.allow_contact);
+  const { sweep, error: sweepParseError } = parseSweep(args.sweep);
+  if (sweepParseError) return err3(sweepParseError);
   if (label && args.joint_state !== void 0 && args.joint_state !== null) {
     return err3(
-      "`label` and `joint_state` cannot be combined: a persisted clearance spec is re-measured at the document's stored joint states, so an assertion captured at an ad-hoc pose could not be re-verified. Either drop `label` (one-off pose measurement), or set the joint states on the document and assert there."
+      "`label` and `joint_state` cannot be combined: a persisted clearance spec is re-measured at the document's stored joint states, so an assertion captured at an ad-hoc pose could not be re-verified. Either drop `label` (one-off pose measurement), use `sweep` (persisted with the spec and re-verified over the same range), or set the joint states on the document and assert there."
     );
   }
   const stored = getSession(documentId);
@@ -55709,10 +55970,20 @@ async function checkClearance(args, engine) {
   } catch (e) {
     return err3(e instanceof Error ? e.message : String(e));
   }
-  const { result, error: error2 } = computeGroupClearance(doc, engine, groupA, groupB);
+  if (!groupA && !groupB) {
+    return auditClearance(documentId, doc, engine, args, sweep, label, pose);
+  }
+  if (!groupA || !groupB) {
+    return err3(
+      "Pass both `group_a` and `group_b` as arrays of part ids (or part names) \u2014 or neither, to audit every pair in the document."
+    );
+  }
+  const minMm = typeof args.min_mm === "number" ? args.min_mm : NaN;
+  if (!Number.isFinite(minMm)) return err3("Pass `min_mm`, the required minimum separation in mm.");
+  const { result, error: error2 } = computeGroupClearance(doc, engine, groupA, groupB, sweep);
   if (error2 || !result) return err3(error2 ?? "Clearance could not be computed.");
   const verdict = clearanceVerdict(result.distance_mm);
-  const pass2 = clearanceHolds(result.distance_mm, minMm, allowContact);
+  const pass2 = clearanceHolds(result.distance_mm, minMm, allowContact, result.intersecting);
   let specSaved = false;
   if (label) {
     upsertClearanceSpec(stored, {
@@ -55720,7 +55991,8 @@ async function checkClearance(args, engine) {
       group_a: result.group_a.map((p) => p.id),
       group_b: result.group_b.map((p) => p.id),
       min_mm: minMm,
-      ...allowContact ? { allow_contact: true } : {}
+      ...allowContact ? { allow_contact: true } : {},
+      ...sweep && sweep.length > 0 ? { sweep } : {}
     });
     specSaved = true;
   }
@@ -55736,6 +56008,8 @@ async function checkClearance(args, engine) {
     ...pose ? { pose } : {},
     intersecting: result.intersecting,
     worst_pair: result.worst_pair,
+    ...result.worst_pose ? { worst_pose: result.worst_pose } : {},
+    ...result.poses_checked !== void 0 ? { poses_checked: result.poses_checked } : {},
     pairs_checked: result.pairs_checked,
     group_a: result.group_a,
     group_b: result.group_b,
@@ -55752,11 +56026,92 @@ 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)) {
+    return { pairs: [], error: "`ignore_pairs` must be an array of [part_a, part_b] pairs." };
+  }
+  const pairs = [];
+  for (const entry of raw) {
+    if (!Array.isArray(entry) || entry.length !== 2) {
+      return { pairs: [], error: "Each `ignore_pairs` entry must be a two-element array." };
+    }
+    pairs.push([String(entry[0]), String(entry[1])]);
+  }
+  return { pairs };
+}
+function auditClearance(documentId, doc, engine, args, sweep, label, pose) {
+  const minMm = typeof args.min_mm === "number" && Number.isFinite(args.min_mm) ? args.min_mm : 0;
+  const { pairs: ignorePairs, error: ignoreError } = parseIgnorePairs(args.ignore_pairs);
+  if (ignoreError) return err3(ignoreError);
+  const ignoreFixedJoints = args.ignore_fixed_joints === void 0 ? true : asBool(args.ignore_fixed_joints);
+  const ignoreAdjacent = asBool(args.ignore_adjacent);
+  const { result, error: error2 } = computeInterferenceAudit(doc, engine, {
+    minMm,
+    ignorePairs,
+    ignoreFixedJoints,
+    ignoreAdjacent,
+    sweep
+  });
+  if (error2 || !result) return err3(error2 ?? "Interference audit could not be computed.");
+  const payload = {
+    success: true,
+    document_id: documentId,
+    mode: "audit",
+    required_mm: minMm,
+    ...pose ? { pose } : {},
+    pass: result.findings.length === 0,
+    findings: result.findings,
+    interference_count: result.findings.length,
+    parts_checked: result.parts_checked,
+    pairs_total: result.pairs_total,
+    pairs_ignored: result.pairs_ignored,
+    pairs_broadphase: result.pairs_broadphase,
+    queries: result.queries,
+    ...result.poses_checked !== void 0 ? { poses_checked: result.poses_checked } : {},
+    ...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.`
+    } : {},
+    ...label ? {
+      spec_saved: false,
+      label_note: "`label` persists only pairwise assertions; an audit is a whole-document scan, so nothing was saved. Name the offending pair and re-run with group_a/group_b to persist it."
+    } : {}
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload) }],
+    structuredContent: { clearance: payload, document_id: documentId }
+  };
+}
 function clearanceReceiptClaims(doc, engine) {
   const specs = doc.clearance_specs ?? [];
   return specs.map((spec) => {
     const id = `${CLEARANCE_CLAIM_PREFIX}${spec.label}`;
-    const description = `clearance "${spec.label}" at least ${spec.min_mm} mm`;
+    const description = spec.sweep?.length ? `clearance "${spec.label}" at least ${spec.min_mm} mm across the swept range of motion` : `clearance "${spec.label}" at least ${spec.min_mm} mm`;
     const subject = `${spec.group_a.join("+")} vs ${spec.group_b.join("+")}`;
     if (!engine) {
       return {
@@ -55770,7 +56125,13 @@ function clearanceReceiptClaims(doc, engine) {
         subject
       };
     }
-    const { result, error: error2 } = computeGroupClearance(doc, engine, spec.group_a, spec.group_b);
+    const { result, error: error2 } = computeGroupClearance(
+      doc,
+      engine,
+      spec.group_a,
+      spec.group_b,
+      spec.sweep
+    );
     if (error2 || !result) {
       return {
         ...unverifiableClaim(
@@ -55790,8 +56151,15 @@ function clearanceReceiptClaims(doc, engine) {
       group_b: spec.group_b,
       required_mm: spec.min_mm,
       measured_mm: result.distance_mm,
-      holds: clearanceHolds(result.distance_mm, spec.min_mm, allowContact),
-      ...allowContact ? { allow_contact: true } : {}
+      holds: clearanceHolds(result.distance_mm, spec.min_mm, allowContact, result.intersecting),
+      ...allowContact ? { allow_contact: true } : {},
+      // A swept claim carries its grid so verify_receipt re-checks the same
+      // range of motion — re-verifying at one pose would silently weaken it.
+      ...spec.sweep?.length ? {
+        sweep: spec.sweep,
+        worst_pose: result.worst_pose ?? [],
+        poses_checked: result.poses_checked ?? 0
+      } : {}
     };
     return {
       id,
@@ -55820,7 +56188,13 @@ function verifyClearanceClaims(doc, engine, receipt) {
       });
       continue;
     }
-    const { result, error: error2 } = computeGroupClearance(doc, engine, stored.group_a, stored.group_b);
+    const { result, error: error2 } = computeGroupClearance(
+      doc,
+      engine,
+      stored.group_a,
+      stored.group_b,
+      stored.sweep
+    );
     if (error2 || !result) {
       checks.push({
         label,
@@ -55832,32 +56206,28 @@ function verifyClearanceClaims(doc, engine, receipt) {
       continue;
     }
     const measured = result.distance_mm;
-    if (!clearanceHolds(measured, stored.required_mm, stored.allow_contact === true)) {
+    const sweptFields = result.poses_checked ? { worst_pose: result.worst_pose, poses_checked: result.poses_checked } : {};
+    const common = {
+      label,
+      required_mm: stored.required_mm,
+      stored_mm: stored.measured_mm,
+      measured_mm: measured,
+      ...sweptFields
+    };
+    if (!clearanceHolds(measured, stored.required_mm, stored.allow_contact === true, result.intersecting)) {
       checks.push({
-        label,
+        ...common,
         status: "Violated",
-        required_mm: stored.required_mm,
-        stored_mm: stored.measured_mm,
-        measured_mm: measured,
-        reason: `measured ${measured} mm is below the required ${stored.required_mm} mm`
+        reason: result.poses_checked ? `measured ${measured} mm is below the required ${stored.required_mm} mm somewhere in the swept range of motion` : `measured ${measured} mm is below the required ${stored.required_mm} mm`
       });
     } else if (Math.abs(measured - stored.measured_mm) > STALE_EPS_MM) {
       checks.push({
-        label,
+        ...common,
         status: "Stale",
-        required_mm: stored.required_mm,
-        stored_mm: stored.measured_mm,
-        measured_mm: measured,
         reason: "geometry changed since the receipt was built, but the clearance still holds"
       });
     } else {
-      checks.push({
-        label,
-        status: "Holds",
-        required_mm: stored.required_mm,
-        stored_mm: stored.measured_mm,
-        measured_mm: measured
-      });
+      checks.push({ ...common, status: "Holds" });
     }
   }
   const status = checks.some((c) => c.status === "Violated") ? "Violated" : checks.some((c) => c.status === "Stale") ? "Stale" : "Holds";
@@ -55887,7 +56257,7 @@ function err3(text) {
     isError: true
   };
 }
-var CLEARANCE_CLAIM_PREFIX, MECH_DOMAIN2, CLEARANCE_ORACLE, STALE_EPS_MM, CONTACT_EPS_MM, round6, checkClearanceSchema, toolDefs11;
+var CLEARANCE_CLAIM_PREFIX, MECH_DOMAIN2, CLEARANCE_ORACLE, STALE_EPS_MM, CONTACT_EPS_MM, round6, checkClearanceSchema, MAX_SWEEP_POSES, pairKey, toolDefs11;
 var init_clearance = __esm({
   "src/tools/clearance.ts"() {
     "use strict";
@@ -55935,15 +56305,47 @@ var init_clearance = __esm({
           type: "boolean",
           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
+        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"]
+          }
+        },
+        ignore_pairs: {
+          type: "array",
+          description: "Audit mode: part id/name pairs whose contact is intended (a bolt in its own hole, a bearing pressed into its bore). Each entry is a two-element array.",
+          items: {
+            type: "array",
+            items: { type: "string" }
+          }
+        },
+        ignore_fixed_joints: {
+          type: "boolean",
+          description: "Audit mode: skip pairs joined by a Fixed joint \u2014 they are bolted together and always 'interfere'. Default true."
+        },
+        ignore_adjacent: {
+          type: "boolean",
+          description: "Audit mode: skip every directly-jointed parent/child pair, not just Fixed ones. Default false \u2014 adjacent links can and do clash away from the joint axis."
+        }
       },
-      required: ["document_id", "group_a", "group_b", "min_mm"]
+      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 a real pose (joint id or name \u2192 degrees, or mm for sliders) instead of the stored zero pose \u2014 that is how you check a mechanism clears through its travel. 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.",
+        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'.",
         inputSchema: checkClearanceSchema,
         handler: (a, c) => checkClearance(a, c.engine),
         behavior: behavior({ writesDoc: true })
@@ -79647,8 +80049,8 @@ var init_server3 = __esm({
     init_order_feed();
     init_animate();
     PKG_VERSION = (() => {
-      if ("0.9.4-main.35") {
-        return "0.9.4-main.35";
+      if ("0.9.4-main.36") {
+        return "0.9.4-main.36";
       }
       try {
         const req = createRequire2(import.meta.url);
@@ -79657,8 +80059,8 @@ var init_server3 = __esm({
         return "0.0.0";
       }
     })();
-    BUILD_SHA = "05b902db41f28989ab2bae377db68a55dd2a7121";
-    BUILD_TIME = "2026-07-26T13:07:16.613Z";
+    BUILD_SHA = "3b9087f300b569c70aa24cebc52af06d15e59187";
+    BUILD_TIME = "2026-07-26T13:20:01.737Z";
     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.35",
+  "version": "0.9.4-main.36",
   "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": "05b902db41f28989ab2bae377db68a55dd2a7121",
-    "builtAt": "2026-07-26T13:07:16.613Z"
+    "sha": "3b9087f300b569c70aa24cebc52af06d15e59187",
+    "builtAt": "2026-07-26T13:20:01.737Z"
   }
 }