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

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 254d4e9d13825ac74a895590703959d77898e1f3 at 2026-07-26T13:42:07.736Z. Source: https://github.com/ecto/vcad

package/index.mjs

@@ -11559,6 +11559,7 @@ var init_dist = __esm({
           circuitTransient: wasmModule7.circuitTransient,
           circuitTune: wasmModule7.circuitTune,
           feaAnalyzeMesh: wasmModule7.feaAnalyzeMesh,
+          feaCheckBeam: wasmModule7.feaCheckBeam,
           emSimulate: wasmModule7.emSimulate,
           antennaAnalyze: wasmModule7.antennaAnalyze,
           photonicsSimulate: wasmModule7.photonicsSimulate,
@@ -11887,6 +11888,22 @@ var init_dist = __esm({
         }
         return fn(specJson, optionsJson, positions, indices);
       }
+      /**
+       * Closed-form check of a prismatic member: exact section properties,
+       * beam bending with the Timoshenko shear term, Bredt thin-wall (or
+       * Saint-Venant series) torsion, and Euler buckling — the route for
+       * thin-walled sheet-metal and tube-frame members, which no affordable
+       * lattice pitch can resolve. Same fail-closed contract and
+       * `vcad.fea-claims/1` predicted claims as `feaAnalyzeMesh`; see
+       * `vcad-kernel-fea::section`.
+       */
+      feaCheckBeam(caseJson) {
+        const fn = this.kernel.feaCheckBeam;
+        if (typeof fn !== "function") {
+          throw new Error("feaCheckBeam is not exported by this kernel WASM build \u2014 rebuild packages/kernel-wasm");
+        }
+        return fn(caseJson);
+      }
       /**
        * EM field simulation (2D/axisymmetric finite-volume magnetostatics or
        * electrostatics): inductance, force, torque, capacitance extraction and
@@ -40914,6 +40931,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",
@@ -40965,6 +41001,25 @@ var init_CHANGELOG = __esm({
             "export_cad"
           ]
         },
+        {
+          id: "2026-07-26-fastener-forms",
+          version: "0.9.4",
+          date: "2026-07-26",
+          category: "feat",
+          title: "Fasteners are a first-class form",
+          summary: "bolt, bolt-circle, clearance-hole and tapped-hole: catalog-backed hardware oriented by its own axis, with real countersunk heads, length checks, and BOM lines counted off the geometry.",
+          features: [
+            "loon",
+            "fasteners",
+            "bom",
+            "assembly"
+          ],
+          mcpTools: [
+            "create_cad_loon",
+            "bom_create",
+            "search_mechanical_parts"
+          ]
+        },
         {
           id: "2026-07-26-document-source-provenance",
           version: "0.9.4",
@@ -40984,6 +41039,23 @@ var init_CHANGELOG = __esm({
             "load_document"
           ]
         },
+        {
+          id: "2026-07-26-beam-check-thin-walled-fea",
+          version: "0.9.4",
+          date: "2026-07-26",
+          category: "feat",
+          title: "beam_check: audited structural answer for thin walls",
+          summary: "Sheet-metal and tube-frame members had no audited FEA answer at any resolution; beam_check prices them in closed form (Bredt torsion, beam bending, Euler buckling), and analyze_structure now measures the wall and refuses with the cell arithmetic instead of a bare Unverifiable.",
+          features: [
+            "fea",
+            "sheet-metal",
+            "receipts"
+          ],
+          mcpTools: [
+            "beam_check",
+            "analyze_structure"
+          ]
+        },
         {
           id: "2026-07-26-backwards-extrude-inverted-winding",
           version: "0.9.4",
@@ -53305,6 +53377,7 @@ var init_tool_metadata = __esm({
       solve_thermal: { title: "Solve Thermal", annotations: RO },
       simulate_flow: { title: "Simulate Flow", annotations: RO },
       analyze_structure: { title: "Analyze Structure", annotations: RO },
+      beam_check: { title: "Check Beam / Section", annotations: RO },
       simulate_neutron_shield: {
         title: "Simulate Neutron Shield",
         annotations: RO
@@ -55576,10 +55649,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 +55674,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 +55709,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 +55844,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 +55869,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 +56007,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 +56024,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 +56045,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 +56062,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 +56080,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 +56179,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 +56205,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 +56242,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 +56260,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 +56311,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 +56359,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 })
@@ -56746,6 +57202,14 @@ function totalsSummary(totals) {
     currency: totals.currency
   };
 }
+function documentHardware(documentId) {
+  try {
+    const doc = documents.get(documentId);
+    return Array.isArray(doc?.hardware) ? doc.hardware : [];
+  } catch {
+    return [];
+  }
+}
 async function bomCreate(input, store, user) {
   const args = input ?? {};
   const owner = ownerId(user);
@@ -56760,7 +57224,23 @@ async function bomCreate(input, store, user) {
     created_at: now,
     updated_at: now
   };
-  const lineInputs = Array.isArray(args.lines) ? args.lines : [];
+  const fromGeometry = args.from_geometry !== false;
+  const geometryLines = [];
+  if (fromGeometry && bom.document_id) {
+    for (const hw of documentHardware(bom.document_id)) {
+      geometryLines.push({
+        kind: "cots",
+        name: hw.spec,
+        catalog_id: hw.catalog_id ?? void 0,
+        qty: hw.qty,
+        notes: "counted from the model geometry"
+      });
+    }
+  }
+  const lineInputs = [
+    ...geometryLines,
+    ...Array.isArray(args.lines) ? args.lines : []
+  ];
   for (let i = 0; i < lineInputs.length; i++) {
     const built = await buildLine(lineInputs[i] ?? {}, store, owner);
     if ("error" in built) return err4(`lines[${i}]: ${built.error}`);
@@ -56936,6 +57416,7 @@ var init_bom = __esm({
     init_pricing();
     init_types4();
     init_mech_parts();
+    init_session_core();
     init_tool_def();
     PRICING_NOTE = "All prices are ESTIMATES (Phase-0 quote estimates, catalog price bands, or caller-supplied numbers) \u2014 not binding quotes.";
     memBoms = /* @__PURE__ */ new Map();
@@ -57001,6 +57482,10 @@ var init_bom = __esm({
           type: "array",
           items: { type: "object", properties: lineProperties, required: ["kind"] },
           description: "Optional full line list to build the BOM in ONE call (recommended on serverless \u2014 BOMs are in-memory per instance, so one-shot creation is the robust path)."
+        },
+        from_geometry: {
+          type: "boolean",
+          description: "Seed COTS lines from the hardware the document's geometry declares \u2014 every loon `bolt`/`bolt-circle` (plus its washers and nuts), with quantities already multiplied through patterns. Default true when document_id is given."
         }
       },
       required: []
@@ -57035,7 +57520,7 @@ var init_bom = __esm({
       {
         name: "bom_create",
         pack: "bom",
-        description: "Create a project bill of materials \u2014 the deliverable that collects every manufactured part (PCBs, sheet metal, 3D prints; link quote_manufacturing quotes by quote_id) and COTS part (bearings, shafts, screws, magnets; link search_mechanical_parts entries by catalog_id) in one place. Optionally attach a document_id and assembly notes. Pass the full `lines` array to build the whole BOM in ONE call \u2014 recommended, since BOMs are in-memory per server instance. All prices are estimates and flagged as such.",
+        description: "Create a project bill of materials \u2014 the deliverable that collects every manufactured part (PCBs, sheet metal, 3D prints; link quote_manufacturing quotes by quote_id) and COTS part (bearings, shafts, screws, magnets; link search_mechanical_parts entries by catalog_id) in one place. Optionally attach a document_id and assembly notes. Pass the full `lines` array to build the whole BOM in ONE call \u2014 recommended, since BOMs are in-memory per server instance. When document_id names a resident session, fastener lines are seeded from the geometry itself (every loon `bolt`/`bolt-circle`, quantities multiplied through patterns) \u2014 pass from_geometry:false to opt out. All prices are estimates and flagged as such.",
         inputSchema: bomCreateSchema,
         handler: (a, c) => bomCreate(a, c.fabricateStore, c.user),
         behavior: behavior({})
@@ -71828,7 +72313,7 @@ var init_structure = __esm({
       {
         name: "analyze_structure",
         pack: null,
-        description: 'Static structural FEA on a part\'s real geometry with fail-closed mesh-convergence gating: linear-tet fill of the tessellated interior at 2+ refinement levels, linear-elastic solve (PCG), returning max von Mises stress, max displacement, discretization-error estimates, and (with yield_strength_mpa) a safety factor \u2014 plus `vcad.fea-claims/1` and unified-receipt claims. If QoIs disagree across levels the verdict is Unverifiable and NO stress/displacement claim is emitted (raise resolution, or fillet the singular corner it points at). Claims carry basis "predicted" and roll up Provisional until hardware is load-tested. Scope: small-displacement linear elasticity, one isotropic material; no plasticity, buckling, contact, or dynamic loads; boundary is staircase-approximated at the lattice pitch. Use predict_physics for the fast coarse steering loop; use this for the audited answer.',
+        description: 'Static structural FEA on a part\'s real geometry with fail-closed mesh-convergence gating: linear-tet fill of the tessellated interior at 2+ refinement levels, linear-elastic solve (PCG), returning max von Mises stress, max displacement, discretization-error estimates, and (with yield_strength_mpa) a safety factor \u2014 plus `vcad.fea-claims/1` and unified-receipt claims. If QoIs disagree across levels the verdict is Unverifiable and NO stress/displacement claim is emitted (raise resolution, or fillet the singular corner it points at). Claims carry basis "predicted" and roll up Provisional until hardware is load-tested. Scope: small-displacement linear elasticity, one isotropic material; no plasticity, buckling, contact, or dynamic loads; boundary is staircase-approximated at the lattice pitch. THIN-WALLED PARTS (sheet metal, tube frame, plate) are outside this tool: it measures the thinnest load-bearing section and fails closed with the cell arithmetic and a pointer to beam_check, which is the more accurate answer for a prismatic member anyway. Use predict_physics for the fast coarse steering loop; use this for the audited answer on chunky geometry.',
         inputSchema: {
           type: "object",
           required: ["document_id", "part", "loads", "supports"],
@@ -71893,7 +72378,7 @@ var init_structure = __esm({
             },
             resolution: {
               type: "number",
-              description: "Coarse-level lattice cells along the longest bbox axis (default 24). The finest level is resolution * 2^(levels-1), capped at 160 for this tier. Keep >= ~6 cells through the thinnest load-bearing section."
+              description: "Coarse-level lattice cells along the longest bbox axis (default 24). The finest level is resolution * 2^(levels-1), capped at 160 for this tier. Keep >= ~6 cells through the thinnest load-bearing section \u2014 the tool measures the part and refuses below ~4, with the cell arithmetic attached. Raising this is NOT the lever for a thin wall (a 2 mm wall on a 300 mm member needs ~950 cells): use beam_check."
             },
             levels: {
               type: "number",
@@ -71944,6 +72429,89 @@ var init_structure = __esm({
           });
         },
         behavior: behavior({})
+      },
+      {
+        name: "beam_check",
+        pack: null,
+        description: 'Closed-form structural check of a PRISMATIC member \u2014 the audited answer for thin-walled geometry, where the lattice in analyze_structure cannot put enough cells through the wall at any affordable resolution. Give it a profile (rect, rect_tube, round, round_tube, i_beam), a span, an end condition, and a load case; get section properties (A, I_y, I_z, J, section moduli, torsional stiffness), stresses (bending, axial, torsional and transverse shear, von Mises), deflection with the Timoshenko shear term, twist, the Euler buckling load under compression, and a safety factor \u2014 plus `vcad.fea-claims/1` and unified-receipt claims under `structure.beam.*`. Exact integrals where they exist (round, round tube, rectangle bending), the convergent Saint-Venant series for solid-rectangle torsion, Bredt closed thin-wall theory for tube torsion \u2014 every approximation is stated in the returned notes. For a constant cross-section this is not a fallback: it beats a staircased lattice on accuracy and costs microseconds. Fail-closed: too stubby for beam theory (L/depth < 5), too thick-walled for Bredt, deflecting past a tenth of the span, torque on an open section, or buckling before it yields \u2014 any of those makes the verdict Unverifiable and NO QoI is claimed, with the reason naming the route forward. Claims carry basis "predicted" and roll up Provisional until hardware is load-tested. Scope: one uniform section over the whole span, idealized ends, no stress concentrations (holes, welds, corner radii), no local wall buckling, no fatigue. Needs no document \u2014 it is geometry-by-description, so it works before the part exists.',
+        inputSchema: {
+          type: "object",
+          required: ["profile", "length_mm", "end_condition"],
+          properties: {
+            profile: {
+              type: "object",
+              required: ["type"],
+              description: 'Cross-section. The member runs along X and the section lives in (Y, Z): width_mm is the Y extent, height_mm the Z extent. One of: {"type":"rect",width_mm,height_mm}, {"type":"rect_tube",width_mm,height_mm,wall_mm}, {"type":"round",diameter_mm}, {"type":"round_tube",diameter_mm,wall_mm}, {"type":"i_beam",width_mm,height_mm,flange_mm,web_mm}. Tube dimensions are OUTSIDE dimensions.',
+              properties: {
+                type: {
+                  type: "string",
+                  enum: ["rect", "rect_tube", "round", "round_tube", "i_beam"]
+                },
+                width_mm: { type: "number", description: "Y extent, mm." },
+                height_mm: { type: "number", description: "Z extent, mm." },
+                wall_mm: { type: "number", description: "Wall thickness, mm." },
+                diameter_mm: { type: "number", description: "Outside diameter, mm." },
+                flange_mm: { type: "number", description: "Flange thickness, mm." },
+                web_mm: { type: "number", description: "Web thickness, mm." }
+              }
+            },
+            length_mm: {
+              type: "number",
+              description: "Free span between supports, mm."
+            },
+            end_condition: {
+              type: "string",
+              enum: [
+                "cantilever_tip",
+                "cantilever_uniform",
+                "simple_center",
+                "simple_uniform",
+                "fixed_fixed_center",
+                "fixed_fixed_uniform"
+              ],
+              description: "Support and load arrangement. `*_uniform` spreads the transverse force over the span; `*_center`/`*_tip` concentrates it. Also sets the Euler effective-length factor (cantilever K=2, simple K=1, fixed-fixed K=0.5)."
+            },
+            transverse_force_n: {
+              type: "number",
+              description: "Total transverse force, N (magnitude). Default 0."
+            },
+            bend_axis: {
+              type: "string",
+              enum: ["y", "z"],
+              description: "Which principal axis to bend about: `y` uses I_y and deflects along Z (default), `z` uses I_z and deflects along Y. Matters for any non-square section."
+            },
+            torque_nmm: {
+              type: "number",
+              description: "Torque about the member axis, N\xB7mm (1 N\xB7m = 1000 N\xB7mm). Default 0. This is the case closed-form theory answers best and the lattice answers worst."
+            },
+            axial_force_n: {
+              type: "number",
+              description: "Axial force, N \u2014 positive tension, negative compression. Compression is also checked against Euler buckling, and a member that buckles is reported Unverifiable rather than 'safe'. Default 0."
+            },
+            youngs_modulus_mpa: {
+              type: "number",
+              description: "Young's modulus, MPa. Default 69000 (6061 aluminum); steel ~200000, PLA ~2300."
+            },
+            poisson: {
+              type: "number",
+              description: "Poisson's ratio in [0, 0.5). Default 0.33; sets G = E/(2(1+nu))."
+            },
+            yield_strength_mpa: {
+              type: "number",
+              description: "Yield strength, MPa. When given, safety_factor = yield / von Mises is computed and claimed (applicable checks only)."
+            }
+          }
+        },
+        handler: (args, ctx) => {
+          const a = args;
+          const started = performance.now();
+          const out = ctx.engine.feaCheckBeam(JSON.stringify(a));
+          return textResult7({
+            solve_ms: Math.round(performance.now() - started),
+            ...out
+          });
+        },
+        behavior: behavior({})
       }
     ];
   }
@@ -79647,8 +80215,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.38") {
+        return "0.9.4-main.38";
       }
       try {
         const req = createRequire2(import.meta.url);
@@ -79657,8 +80225,8 @@ var init_server3 = __esm({
         return "0.0.0";
       }
     })();
-    BUILD_SHA = "05b902db41f28989ab2bae377db68a55dd2a7121";
-    BUILD_TIME = "2026-07-26T13:07:16.613Z";
+    BUILD_SHA = "254d4e9d13825ac74a895590703959d77898e1f3";
+    BUILD_TIME = "2026-07-26T13:42:07.736Z";
     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);
@@ -79806,6 +80374,7 @@ var init_server3 = __esm({
       "solve_thermal",
       "simulate_flow",
       "analyze_structure",
+      "beam_check",
       "simulate_neutron_shield",
       "simulate_lattice_gauge",
       "analyze_tolerance_stackup",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vcad/mcp",
-  "version": "0.9.4-main.35",
+  "version": "0.9.4-main.38",
   "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": "254d4e9d13825ac74a895590703959d77898e1f3",
+    "builtAt": "2026-07-26T13:42:07.736Z"
   }
 }