forgecad 0.10.2 → 0.10.3

package/dist-cli/forgecad.js

@@ -58,7 +58,6 @@ import {
   getCollectedIntentionalOverlaps,
   getCollectedJointsView,
   getCollectedPhysicalComponentExpectations,
-  getCollectedRobotExport,
   getCompilerRegressionCorpusPart,
   getDesignTraceInputs,
   getDesignTraceUsedBy,
@@ -135,11 +134,11 @@ import {
   updateConstraintValue,
   validateSimulationModel,
   wrapOCCTShapeBackend
-} from "./chunk-RQQ42YCP.js";
+} from "./chunk-WLUKAW3H.js";
 
 // cli/forgecad.ts
 import { Command, Flags, Help, flush as flushOclif, handle as handleOclif, run as runOclif } from "@oclif/core";
-import { readFileSync as readFileSync26 } from "fs";
+import { readFileSync as readFileSync28 } from "fs";
 
 // cli/check-api-contracts.ts
 import assert from "assert/strict";
@@ -5065,12 +5064,6 @@ function applyNonPartExpectations(entryPath, result, expectations) {
   assertMinimum(entryPath, result.cutPlanes.length, expectations.minCutPlanes, "cut plane(s)");
   assertMinimum(entryPath, jointCount, expectations.minJoints, "joint control(s)");
   assertMinimum(entryPath, animationCount, expectations.minAnimations, "joint animation(s)");
-  if (expectations.requireRobotExport || expectations.minRobotParts != null || expectations.minRobotJoints != null) {
-    assert4(result.robotExport, `${entryPath}: expected robotExport(...) data to stay available to the example gate`);
-    if (!result.robotExport) return;
-    assertMinimum(entryPath, result.robotExport.assembly.parts.length, expectations.minRobotParts, "robot part(s)");
-    assertMinimum(entryPath, result.robotExport.assembly.joints.length, expectations.minRobotJoints, "robot joint(s)");
-  }
 }
 function validateAssemblyEntry(entry) {
   const result = executeExample(entry);
@@ -5536,8 +5529,8 @@ function requireSingleInputForOutputPath(inputPaths, outputPath, flag = "--outpu
     throw new Error(`Cannot use ${flag} <${valueKind}> with multiple inputs. Omit ${flag} to use per-input defaults.`);
   }
 }
-function batchOutputPath(inputPath, explicitOutputPath, defaultOutputPath12) {
-  return explicitOutputPath ?? defaultOutputPath12(inputPath);
+function batchOutputPath(inputPath, explicitOutputPath, defaultOutputPath13) {
+  return explicitOutputPath ?? defaultOutputPath13(inputPath);
 }
 function printBatchHeader(inputPath, index, total) {
   if (total <= 1) return;
@@ -14743,10 +14736,10 @@ function polygonCentroid(points) {
   for (let i = 0; i < points.length; i += 1) {
     const [x1, y1] = points[i];
     const [x2, y2] = points[(i + 1) % points.length];
-    const cross7 = x1 * y2 - x2 * y1;
-    a2 += cross7;
-    cx += (x1 + x2) * cross7;
-    cy += (y1 + y2) * cross7;
+    const cross8 = x1 * y2 - x2 * y1;
+    a2 += cross8;
+    cx += (x1 + x2) * cross8;
+    cy += (y1 + y2) * cross8;
   }
   if (Math.abs(a2) < EPS5) {
     return points.length > 0 ? [points.reduce((sum2, p) => sum2 + p[0], 0) / points.length, points.reduce((sum2, p) => sum2 + p[1], 0) / points.length] : [0, 0];
@@ -17080,7 +17073,6 @@ var ESTABLISHED_LOWERCASE_RUNTIME_GLOBALS = /* @__PURE__ */ new Set([
   "sketchToDxf",
   "bom",
   "sheetStock",
-  "robotExport",
   "group",
   "console",
   "cutPlane",
@@ -17293,7 +17285,7 @@ function checkRuntimeNamesDoc(runtimeNames) {
   const compatibilityList = renderRuntimeNameList(collisionReservedNames.filter((name) => SKILL_SUPPRESSED_RUNTIME_NAMES.has(name)));
   let doc;
   try {
-    doc = readText("docs/permanent/generated/runtime-names.md");
+    doc = readText("docs/skill/generated/runtime-names.md");
   } catch {
     return "Generated runtime names doc is missing. Run npm run gen:docs.";
   }
@@ -17372,6 +17364,7 @@ import { readFileSync as readFileSync10 } from "fs";
 import { resolve as resolve12 } from "path";
 function parseArgs4(argv) {
   const inputPaths = [];
+  const paramOverrides = {};
   const jointOverrides = {};
   let json = false;
   let compact = false;
@@ -17397,14 +17390,24 @@ function parseArgs4(argv) {
       i += 1;
       continue;
     }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
     if (arg.startsWith("--")) {
       throw new Error(`Unknown flag: ${arg}`);
     }
     inputPaths.push(arg);
   }
-  requireInputPaths(inputPaths, "Usage: forgecad check simready <script.forge.js> [input ...] [--json] [--joint JointName=Value]");
+  requireInputPaths(
+    inputPaths,
+    "Usage: forgecad check simready <script.forge.js> [input ...] [--json] [--param Key=Value] [--joint JointName=Value]"
+  );
   requireScriptInputPaths(inputPaths);
-  return { inputPaths, json, compact, noFailExit, jointOverrides };
+  return { inputPaths, json, compact, noFailExit, paramOverrides, jointOverrides };
 }
 function finding2(code, message, path5) {
   return { level: "error", code, message, path: path5 };
@@ -17422,10 +17425,6 @@ function failedReport(source, modelName, errorMessage2, code = "SIM.CHECK.ERROR"
   };
 }
 function resolveSimulationModel(result, jointOverrides) {
-  const legacy = getCollectedRobotExport();
-  if (legacy) {
-    return { ...legacy, state: { ...legacy.state, ...jointOverrides } };
-  }
   const assembly2 = getRunResultAssemblySource(result);
   if (!assembly2) return null;
   return collectSimulationModel(assembly2.describe(), { state: jointOverrides });
@@ -17477,6 +17476,7 @@ function runCheckSimReadyInput(options, scriptPath) {
   const scriptAbs = resolve12(scriptPath);
   const code = readFileSync10(scriptAbs, "utf-8");
   const { allFiles, fileName } = collectProjectFiles(scriptAbs);
+  setParamOverrides(options.paramOverrides);
   const runResult = applyCliJointOverrides(
     runScript(code, fileName, allFiles, { assemblyState: options.jointOverrides }),
     options.jointOverrides
@@ -17488,12 +17488,7 @@ function runCheckSimReadyInput(options, scriptPath) {
     try {
       const model = resolveSimulationModel(runResult, options.jointOverrides);
       if (!model) {
-        report = failedReport(
-          scriptPath,
-          scriptPath,
-          "Model must return assembly(...).withSimulation(...), or call legacy robotExport({...}).",
-          "SIM.SIMULATION.MISSING"
-        );
+        report = failedReport(scriptPath, scriptPath, "Model must return assembly(...).withSimulation(...).", "SIM.SIMULATION.MISSING");
       } else {
         report = { source: scriptPath, ...validateSimulationModel(model) };
       }
@@ -17504,6 +17499,647 @@ function runCheckSimReadyInput(options, scriptPath) {
   return report;
 }
 
+// src/forge/analysis/massProperties.ts
+function meshSurfaceAreaMm2(mesh) {
+  const { numProp, numTri, triVerts, vertProperties } = mesh;
+  let area = 0;
+  for (let t = 0; t < numTri; t += 1) {
+    const i0 = triVerts[t * 3] * numProp;
+    const i1 = triVerts[t * 3 + 1] * numProp;
+    const i2 = triVerts[t * 3 + 2] * numProp;
+    const e1x = vertProperties[i1] - vertProperties[i0];
+    const e1y = vertProperties[i1 + 1] - vertProperties[i0 + 1];
+    const e1z = vertProperties[i1 + 2] - vertProperties[i0 + 2];
+    const e2x = vertProperties[i2] - vertProperties[i0];
+    const e2y = vertProperties[i2 + 1] - vertProperties[i0 + 1];
+    const e2z = vertProperties[i2 + 2] - vertProperties[i0 + 2];
+    const cx = e1y * e2z - e1z * e2y;
+    const cy = e1z * e2x - e1x * e2z;
+    const cz = e1x * e2y - e1y * e2x;
+    area += 0.5 * Math.sqrt(cx * cx + cy * cy + cz * cz);
+  }
+  return area;
+}
+function accumulateBounds(mesh, min, max) {
+  const { numProp, vertProperties } = mesh;
+  const numVerts = vertProperties.length / numProp;
+  for (let v = 0; v < numVerts; v += 1) {
+    for (let axis = 0; axis < 3; axis += 1) {
+      const value = vertProperties[v * numProp + axis];
+      if (value < min[axis]) min[axis] = value;
+      if (value > max[axis]) max[axis] = value;
+    }
+  }
+}
+function symmetricEigen3(m) {
+  const a = [
+    [m[0][0], m[0][1], m[0][2]],
+    [m[1][0], m[1][1], m[1][2]],
+    [m[2][0], m[2][1], m[2][2]]
+  ];
+  const v = [
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]
+  ];
+  for (let sweep = 0; sweep < 100; sweep += 1) {
+    const off = Math.abs(a[0][1]) + Math.abs(a[0][2]) + Math.abs(a[1][2]);
+    if (off < 1e-20) break;
+    for (let p = 0; p < 2; p += 1) {
+      for (let q = p + 1; q < 3; q += 1) {
+        if (Math.abs(a[p][q]) < 1e-300) continue;
+        const theta = (a[q][q] - a[p][p]) / (2 * a[p][q]);
+        const t = Math.sign(theta || 1) / (Math.abs(theta) + Math.sqrt(theta * theta + 1));
+        const c = 1 / Math.sqrt(t * t + 1);
+        const s = t * c;
+        for (let i = 0; i < 3; i += 1) {
+          const aip = a[i][p];
+          const aiq = a[i][q];
+          a[i][p] = c * aip - s * aiq;
+          a[i][q] = s * aip + c * aiq;
+        }
+        for (let i = 0; i < 3; i += 1) {
+          const api = a[p][i];
+          const aqi = a[q][i];
+          a[p][i] = c * api - s * aqi;
+          a[q][i] = s * api + c * aqi;
+        }
+        for (let i = 0; i < 3; i += 1) {
+          const vip = v[i][p];
+          const viq = v[i][q];
+          v[i][p] = c * vip - s * viq;
+          v[i][q] = s * vip + c * viq;
+        }
+      }
+    }
+  }
+  const eigen = [
+    { value: a[0][0], vector: [v[0][0], v[1][0], v[2][0]] },
+    { value: a[1][1], vector: [v[0][1], v[1][1], v[2][1]] },
+    { value: a[2][2], vector: [v[0][2], v[1][2], v[2][2]] }
+  ];
+  eigen.sort((x, y) => y.value - x.value);
+  return {
+    values: [eigen[0].value, eigen[1].value, eigen[2].value],
+    vectors: [eigen[0].vector, eigen[1].vector, eigen[2].vector]
+  };
+}
+function analyzeMassProperties(objects) {
+  if (objects.length === 0) {
+    throw new Error("analyzeMassProperties requires at least one object");
+  }
+  const perObject = [];
+  let surfaceAreaMm2 = 0;
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  const inertiaAboutOwnCom = [];
+  for (const obj of objects) {
+    const massPlaceholder = 1;
+    const probe = computeMeshInertia(obj.mesh, massPlaceholder);
+    const volumeMm3 = probe.volumeMm3;
+    const volumeM3 = volumeMm3 * 1e-9;
+    const massKg = obj.densityKgM3 * volumeM3;
+    inertiaAboutOwnCom.push({
+      ixx: probe.ixx * massKg,
+      iyy: probe.iyy * massKg,
+      izz: probe.izz * massKg,
+      ixy: probe.ixy * massKg,
+      ixz: probe.ixz * massKg,
+      iyz: probe.iyz * massKg
+    });
+    perObject.push({
+      name: obj.name,
+      volumeMm3,
+      massKg,
+      densityKgM3: obj.densityKgM3,
+      centerOfMassMm: probe.centerOfMass
+    });
+    surfaceAreaMm2 += meshSurfaceAreaMm2(obj.mesh);
+    accumulateBounds(obj.mesh, min, max);
+  }
+  const totalVolumeMm3 = perObject.reduce((sum2, o) => sum2 + o.volumeMm3, 0);
+  const totalMassKg = perObject.reduce((sum2, o) => sum2 + o.massKg, 0);
+  const weights = totalMassKg > 0 ? perObject.map((o) => o.massKg) : perObject.map((o) => o.volumeMm3);
+  const weightTotal = weights.reduce((a, b) => a + b, 0) || 1;
+  const com = [0, 0, 0];
+  perObject.forEach((o, i) => {
+    com[0] += weights[i] * o.centerOfMassMm[0] / weightTotal;
+    com[1] += weights[i] * o.centerOfMassMm[1] / weightTotal;
+    com[2] += weights[i] * o.centerOfMassMm[2] / weightTotal;
+  });
+  const tensor = { ixx: 0, iyy: 0, izz: 0, ixy: 0, ixz: 0, iyz: 0 };
+  perObject.forEach((o, i) => {
+    const own = inertiaAboutOwnCom[i];
+    const dx = (o.centerOfMassMm[0] - com[0]) * 1e-3;
+    const dy = (o.centerOfMassMm[1] - com[1]) * 1e-3;
+    const dz = (o.centerOfMassMm[2] - com[2]) * 1e-3;
+    const m = o.massKg;
+    tensor.ixx += own.ixx + m * (dy * dy + dz * dz);
+    tensor.iyy += own.iyy + m * (dx * dx + dz * dz);
+    tensor.izz += own.izz + m * (dx * dx + dy * dy);
+    tensor.ixy += own.ixy - m * dx * dy;
+    tensor.ixz += own.ixz - m * dx * dz;
+    tensor.iyz += own.iyz - m * dy * dz;
+  });
+  const eig = symmetricEigen3([
+    [tensor.ixx, tensor.ixy, tensor.ixz],
+    [tensor.ixy, tensor.iyy, tensor.iyz],
+    [tensor.ixz, tensor.iyz, tensor.izz]
+  ]);
+  const principalMomentsKgM2 = eig.values;
+  const radiusOfGyrationM = totalMassKg > 0 ? [
+    Math.sqrt(Math.max(0, principalMomentsKgM2[0]) / totalMassKg),
+    Math.sqrt(Math.max(0, principalMomentsKgM2[1]) / totalMassKg),
+    Math.sqrt(Math.max(0, principalMomentsKgM2[2]) / totalMassKg)
+  ] : [0, 0, 0];
+  const size = [max[0] - min[0], max[1] - min[1], max[2] - min[2]];
+  return {
+    totalVolumeMm3,
+    totalMassKg,
+    centerOfMassMm: com,
+    inertiaTensorKgM2: tensor,
+    principalMomentsKgM2,
+    principalAxes: eig.vectors,
+    radiusOfGyrationM,
+    surfaceAreaMm2,
+    boundingBoxMm: { minMm: min, maxMm: max, sizeMm: size },
+    perObject
+  };
+}
+
+// src/forge/analysis/stability.ts
+function axisIndex(up) {
+  switch (up) {
+    case "x":
+      return { upIdx: 0, planeA: 1, planeB: 2 };
+    case "y":
+      return { upIdx: 1, planeA: 2, planeB: 0 };
+    default:
+      return { upIdx: 2, planeA: 0, planeB: 1 };
+  }
+}
+function convexHull2D(points) {
+  const pts = points.slice().sort((p, q) => p[0] === q[0] ? p[1] - q[1] : p[0] - q[0]);
+  const unique = [];
+  for (const p of pts) {
+    const last = unique[unique.length - 1];
+    if (!last || last[0] !== p[0] || last[1] !== p[1]) unique.push(p);
+  }
+  if (unique.length < 3) return unique;
+  const cross8 = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+  const lower2 = [];
+  for (const p of unique) {
+    while (lower2.length >= 2 && cross8(lower2[lower2.length - 2], lower2[lower2.length - 1], p) <= 0) lower2.pop();
+    lower2.push(p);
+  }
+  const upper = [];
+  for (let i = unique.length - 1; i >= 0; i -= 1) {
+    const p = unique[i];
+    while (upper.length >= 2 && cross8(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) upper.pop();
+    upper.push(p);
+  }
+  lower2.pop();
+  upper.pop();
+  return lower2.concat(upper);
+}
+function distancePointToSegment(p, a, b) {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const lenSq = dx * dx + dy * dy;
+  if (lenSq < 1e-18) return Math.hypot(p[0] - a[0], p[1] - a[1]);
+  let t = ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / lenSq;
+  t = Math.max(0, Math.min(1, t));
+  return Math.hypot(p[0] - (a[0] + t * dx), p[1] - (a[1] + t * dy));
+}
+function signedDistanceToPolygon(p, poly) {
+  let minDist = Infinity;
+  let nearestEdge = 0;
+  let inside = true;
+  for (let i = 0; i < poly.length; i += 1) {
+    const a = poly[i];
+    const b = poly[(i + 1) % poly.length];
+    const cross8 = (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]);
+    if (cross8 < 0) inside = false;
+    const d = distancePointToSegment(p, a, b);
+    if (d < minDist) {
+      minDist = d;
+      nearestEdge = i;
+    }
+  }
+  return { distance: inside ? minDist : -minDist, nearestEdge };
+}
+function analyzeStability(meshes, centerOfMassMm, options = {}) {
+  const up = options.up ?? "z";
+  const { upIdx, planeA, planeB } = axisIndex(up);
+  const minMarginMm = options.minMarginMm ?? 0;
+  let groundLevelMm = Infinity;
+  for (const mesh of meshes) {
+    const numVerts = mesh.vertProperties.length / mesh.numProp;
+    for (let v = 0; v < numVerts; v += 1) {
+      const value = mesh.vertProperties[v * mesh.numProp + upIdx];
+      if (value < groundLevelMm) groundLevelMm = value;
+    }
+  }
+  if (!Number.isFinite(groundLevelMm)) {
+    throw new Error("analyzeStability: geometry has no vertices");
+  }
+  let contactToleranceMm = options.contactToleranceMm ?? 0;
+  if (!options.contactToleranceMm) {
+    let span = 0;
+    for (const mesh of meshes) {
+      const numVerts = mesh.vertProperties.length / mesh.numProp;
+      for (let v = 0; v < numVerts; v += 1) {
+        const value = mesh.vertProperties[v * mesh.numProp + upIdx];
+        span = Math.max(span, value - groundLevelMm);
+      }
+    }
+    contactToleranceMm = Math.max(0.05, span * 2e-3);
+  }
+  const contactPoints = [];
+  for (const mesh of meshes) {
+    const numVerts = mesh.vertProperties.length / mesh.numProp;
+    for (let v = 0; v < numVerts; v += 1) {
+      const base = v * mesh.numProp;
+      if (mesh.vertProperties[base + upIdx] <= groundLevelMm + contactToleranceMm) {
+        contactPoints.push([mesh.vertProperties[base + planeA], mesh.vertProperties[base + planeB]]);
+      }
+    }
+  }
+  const supportPolygonMm = convexHull2D(contactPoints);
+  const comProjectionMm = [centerOfMassMm[planeA], centerOfMassMm[planeB]];
+  const comHeightMm = centerOfMassMm[upIdx] - groundLevelMm;
+  const degenerate = supportPolygonMm.length < 3;
+  if (degenerate) {
+    return {
+      up,
+      groundLevelMm,
+      centerOfMassMm,
+      comProjectionMm,
+      comHeightMm,
+      supportPolygonMm,
+      contactVertexCount: contactPoints.length,
+      comInsideSupport: false,
+      tipOverMarginMm: 0,
+      tipOverAngleDeg: 0,
+      criticalEdge: null,
+      tipDirection: null,
+      comShiftToTargetMm: null,
+      degenerate: true
+    };
+  }
+  const { distance: distance2, nearestEdge } = signedDistanceToPolygon(comProjectionMm, supportPolygonMm);
+  const a = supportPolygonMm[nearestEdge];
+  const b = supportPolygonMm[(nearestEdge + 1) % supportPolygonMm.length];
+  const ex = b[0] - a[0];
+  const ey = b[1] - a[1];
+  const edgeLen = Math.hypot(ex, ey) || 1;
+  const nx = ey / edgeLen;
+  const ny = -ex / edgeLen;
+  const tipDirection = [nx, ny];
+  const tipOverAngleDeg = comHeightMm > 1e-9 ? Math.atan2(distance2, comHeightMm) * 180 / Math.PI : distance2 >= 0 ? 90 : -90;
+  let comShiftToTargetMm = null;
+  if (distance2 < minMarginMm) {
+    const deficit = minMarginMm - distance2;
+    comShiftToTargetMm = [-nx * deficit, -ny * deficit];
+  }
+  return {
+    up,
+    groundLevelMm,
+    centerOfMassMm,
+    comProjectionMm,
+    comHeightMm,
+    supportPolygonMm,
+    contactVertexCount: contactPoints.length,
+    comInsideSupport: distance2 >= 0,
+    tipOverMarginMm: distance2,
+    tipOverAngleDeg,
+    criticalEdge: { a, b },
+    tipDirection,
+    comShiftToTargetMm,
+    degenerate: false
+  };
+}
+
+// src/forge/analysis/feedback.ts
+var FEEDBACK_SCHEMA = "forgecad.feedback/v1";
+function evaluateTarget(value, target) {
+  switch (target.op) {
+    case ">=":
+      return value >= target.value;
+    case "<=":
+      return value <= target.value;
+    case ">":
+      return value > target.value;
+    case "<":
+      return value < target.value;
+    case "==":
+      return value === target.value;
+    default:
+      return false;
+  }
+}
+function makeMetric(key, label, value, options) {
+  const { unit, target, status: forced, warnFraction = 0.1 } = options;
+  let status = forced ?? "info";
+  if (!forced && target && value !== null && Number.isFinite(value)) {
+    const passed = evaluateTarget(value, target);
+    if (!passed) {
+      status = "fail";
+    } else {
+      const span = Math.abs(target.value) || 1;
+      const slack = Math.abs(value - target.value) / span;
+      status = slack < warnFraction ? "warn" : "pass";
+    }
+  } else if (!forced && value === null) {
+    status = "info";
+  }
+  return target ? { key, label, value, unit, status, target } : { key, label, value, unit, status };
+}
+function reportOk(metrics, findings) {
+  if (metrics.some((m) => m.status === "fail")) return false;
+  if (findings.some((f2) => f2.level === "error")) return false;
+  return true;
+}
+function statusGlyph(status) {
+  switch (status) {
+    case "pass":
+      return "\u2713";
+    case "warn":
+      return "\u26A0";
+    case "fail":
+      return "\u2717";
+    default:
+      return "\xB7";
+  }
+}
+function formatValue(value) {
+  if (value === null || !Number.isFinite(value)) return "n/a";
+  const abs = Math.abs(value);
+  if (abs !== 0 && (abs < 1e-3 || abs >= 1e6)) return value.toExponential(3);
+  return Number.parseFloat(value.toPrecision(6)).toString();
+}
+function renderFeedbackText(report) {
+  const lines = [];
+  const head = report.ok ? "\u2713" : "\u2717";
+  lines.push(`${head} ${report.category}: ${report.source}`);
+  lines.push(`  ${report.summary}`);
+  for (const metric of report.metrics) {
+    const target = metric.target ? `  (target ${metric.target.op} ${formatValue(metric.target.value)} ${metric.unit})` : "";
+    lines.push(`  ${statusGlyph(metric.status)} ${metric.label}: ${formatValue(metric.value)} ${metric.unit}${target}`);
+  }
+  for (const finding3 of report.findings) {
+    const glyph = finding3.level === "error" ? "\u2717" : finding3.level === "warning" ? "\u26A0" : "\xB7";
+    const suggest = finding3.suggest ? ` \u2192 ${finding3.suggest}` : "";
+    const path5 = finding3.path ? ` (${finding3.path})` : "";
+    lines.push(`  ${glyph} [${finding3.code}] ${finding3.message}${path5}${suggest}`);
+  }
+  if (report.trust.assumptions.length > 0) {
+    lines.push(`  assumptions: ${report.trust.assumptions.join("; ")}`);
+  }
+  return lines.join("\n");
+}
+
+// cli/analysis-shared.ts
+async function loadAnalysisObjectsWithAssembly(scriptPath, options) {
+  const input = loadCliScriptInput(scriptPath);
+  await initCliBackend(resolveCliBackend(options.backend, input) ?? CLI_DEFAULT_BACKEND);
+  const qualityPreset = options.quality && options.quality !== "default" ? options.quality : void 0;
+  setParamOverrides(options.paramOverrides);
+  const runResult = applyCliJointOverrides(
+    runScript(input.code, input.fileName, input.allFiles, {
+      ...qualityPreset ? { quality: qualityPreset } : {},
+      readBinaryFile: input.readBinaryFile,
+      assemblyState: options.jointOverrides
+    }),
+    options.jointOverrides
+  );
+  if (runResult.error) {
+    return { objects: [], assembly: null, runResult, error: runResult.error };
+  }
+  const objects = runResult.objects.filter((obj) => obj.shape && !obj.mock).map((obj) => ({ name: obj.name, mesh: obj.shape.getMesh() }));
+  if (objects.length === 0) {
+    return { objects: [], assembly: null, runResult, error: "No solid geometry found in the model." };
+  }
+  return { objects, assembly: getRunResultAssemblySource(runResult), runResult, error: null };
+}
+async function loadAnalysisObjects(scriptPath, options) {
+  const { objects, error } = await loadAnalysisObjectsWithAssembly(scriptPath, options);
+  return { objects, error };
+}
+function printFeedback(report, json, compact) {
+  if (json) {
+    console.log(JSON.stringify(report, null, compact ? 0 : 2));
+    return;
+  }
+  const reports = "runs" in report ? report.runs : [report];
+  for (const entry of reports) {
+    const text = renderFeedbackText(entry);
+    if (entry.ok) console.log(text);
+    else console.error(text);
+  }
+}
+
+// cli/check-stability.ts
+function parseArgs5(argv) {
+  const inputPaths = [];
+  const paramOverrides = {};
+  const jointOverrides = {};
+  let json = false;
+  let compact = false;
+  let minMarginMm = 0;
+  let up = "z";
+  let contactToleranceMm = null;
+  let noFailExit = false;
+  let backend;
+  let quality;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--compact") {
+      compact = true;
+      continue;
+    }
+    if (arg === "--no-fail-exit") {
+      noFailExit = true;
+      continue;
+    }
+    if (arg === "--min-margin-mm") {
+      const value = Number(argv[i + 1]);
+      if (!Number.isFinite(value)) throw new Error("--min-margin-mm requires a number");
+      minMarginMm = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--up") {
+      const val = argv[i + 1];
+      if (val !== "x" && val !== "y" && val !== "z") throw new Error("--up must be x, y, or z");
+      up = val;
+      i += 1;
+      continue;
+    }
+    if (arg === "--contact-tol") {
+      const value = Number(argv[i + 1]);
+      if (!Number.isFinite(value) || value < 0) throw new Error("--contact-tol requires a non-negative number (mm)");
+      contactToleranceMm = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--quality" || arg === "-q") {
+      const val = argv[i + 1];
+      if (val !== "default" && val !== "live" && val !== "high") throw new Error("--quality must be default, live, or high");
+      quality = val;
+      i += 1;
+      continue;
+    }
+    if (arg === "--backend") {
+      const val = argv[i + 1];
+      if (val !== "manifold" && val !== "occt" && val !== "truck" && val !== "sdf") {
+        throw new Error("--backend must be manifold, occt, truck, or sdf");
+      }
+      backend = val;
+      i += 1;
+      continue;
+    }
+    if (arg === "--joint") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error("--joint requires JointName=Value");
+      addCliJointOverride(value, jointOverrides);
+      i += 1;
+      continue;
+    }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--")) throw new Error(`Unknown flag: ${arg}`);
+    inputPaths.push(arg);
+  }
+  requireInputPaths(
+    inputPaths,
+    "Usage: forgecad check stability <model.forge.js> [input ...] [--min-margin-mm N] [--up x|y|z] [--json] [--param Key=Value]"
+  );
+  requireScriptInputPaths(inputPaths);
+  return { inputPaths, json, compact, minMarginMm, up, contactToleranceMm, noFailExit, backend, quality, paramOverrides, jointOverrides };
+}
+function failedReport2(source, message, code = "STABILITY.ERROR") {
+  return {
+    schema: FEEDBACK_SCHEMA,
+    category: "stability",
+    source,
+    ok: false,
+    summary: "stability analysis failed",
+    metrics: [],
+    findings: [{ level: "error", code, message }],
+    trust: { assumptions: [] },
+    data: {},
+    timeMs: 0
+  };
+}
+function round3(value, digits = 4) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+function analyze(source, options, objects) {
+  const start = Date.now();
+  const props = analyzeMassProperties(objects.map((o) => ({ name: o.name, mesh: o.mesh, densityKgM3: 1e3 })));
+  const stab = analyzeStability(objects.map((o) => o.mesh), props.centerOfMassMm, {
+    up: options.up,
+    minMarginMm: options.minMarginMm,
+    contactToleranceMm: options.contactToleranceMm ?? void 0
+  });
+  const findings = [];
+  const assumptions = [
+    "Rigid body at rest under gravity; center of mass is the uniform-density volume centroid.",
+    `Up axis is +${options.up}; the support footprint is the convex hull of the lowest geometry.`
+  ];
+  if (stab.degenerate) {
+    findings.push({
+      level: "error",
+      code: "STABILITY.SUPPORT.DEGENERATE",
+      message: `Support footprint collapses to ${stab.contactVertexCount === 0 ? "no" : "a line/point of"} contact \u2014 no stable base.`,
+      suggest: "Add a flat resting face, widen the base, or check that the model rests on the ground plane."
+    });
+  } else if (stab.tipOverMarginMm < options.minMarginMm) {
+    const dir = stab.comShiftToTargetMm;
+    findings.push({
+      level: "error",
+      code: stab.comInsideSupport ? "STABILITY.MARGIN.LOW" : "STABILITY.TIPS_OVER",
+      message: stab.comInsideSupport ? `Tip-over margin ${round3(stab.tipOverMarginMm, 2)} mm is below the required ${options.minMarginMm} mm.` : `Center of mass falls outside the support polygon by ${round3(-stab.tipOverMarginMm, 2)} mm \u2014 the part tips over.`,
+      suggest: dir ? `Shift the center of mass by (${round3(dir[0], 1)}, ${round3(dir[1], 1)}) mm in the ground plane \u2014 widen the base, move mass inboard, or add ballast on the opposite side.` : "Widen the base or move mass toward the support center."
+    });
+  }
+  const metrics = [
+    makeMetric("tipOverMarginMm", "Tip-over margin", round3(stab.tipOverMarginMm, 3), {
+      unit: "mm",
+      target: { op: ">=", value: options.minMarginMm },
+      status: stab.degenerate ? "fail" : void 0
+    }),
+    makeMetric("tipOverAngleDeg", "Tip-over angle", round3(stab.tipOverAngleDeg, 3), { unit: "deg" }),
+    makeMetric("comHeightMm", "CoM height", round3(stab.comHeightMm, 3), { unit: "mm" }),
+    makeMetric("comInsideSupport", "CoM inside support", stab.comInsideSupport ? 1 : 0, {
+      unit: "bool",
+      target: { op: ">=", value: 1 },
+      status: stab.comInsideSupport ? "pass" : "fail"
+    })
+  ];
+  return {
+    schema: FEEDBACK_SCHEMA,
+    category: "stability",
+    source,
+    ok: reportOk(metrics, findings),
+    summary: stab.degenerate ? "no stable support footprint" : stab.comInsideSupport ? `stable \xB7 margin ${round3(stab.tipOverMarginMm, 2)} mm \xB7 tips at ${round3(stab.tipOverAngleDeg, 1)}\xB0 tilt` : `TIPS OVER \xB7 CoM ${round3(-stab.tipOverMarginMm, 2)} mm past the support edge`,
+    metrics,
+    findings,
+    trust: { assumptions, watertight: true },
+    data: {
+      up: stab.up,
+      groundLevelMm: round3(stab.groundLevelMm, 4),
+      centerOfMassMm: stab.centerOfMassMm.map((v) => round3(v, 4)),
+      comProjectionMm: stab.comProjectionMm.map((v) => round3(v, 4)),
+      comHeightMm: round3(stab.comHeightMm, 4),
+      tipOverMarginMm: round3(stab.tipOverMarginMm, 4),
+      tipOverAngleDeg: round3(stab.tipOverAngleDeg, 4),
+      comInsideSupport: stab.comInsideSupport,
+      contactVertexCount: stab.contactVertexCount,
+      supportPolygonMm: stab.supportPolygonMm.map((p) => [round3(p[0], 3), round3(p[1], 3)]),
+      criticalEdge: stab.criticalEdge ? { a: stab.criticalEdge.a.map((v) => round3(v, 3)), b: stab.criticalEdge.b.map((v) => round3(v, 3)) } : null,
+      tipDirection: stab.tipDirection ? stab.tipDirection.map((v) => round3(v, 5)) : null,
+      comShiftToTargetMm: stab.comShiftToTargetMm ? stab.comShiftToTargetMm.map((v) => round3(v, 3)) : null
+    },
+    timeMs: Date.now() - start
+  };
+}
+async function runCheckStabilityCli(argv = process.argv.slice(2)) {
+  const options = parseArgs5(argv);
+  requireExistingInputPaths(options.inputPaths);
+  await init();
+  const reports = [];
+  for (const [index, scriptPath] of options.inputPaths.entries()) {
+    if (!options.json) printBatchHeader(scriptPath, index, options.inputPaths.length);
+    let report;
+    try {
+      const { objects, error } = await loadAnalysisObjects(scriptPath, {
+        backend: options.backend,
+        quality: options.quality,
+        paramOverrides: options.paramOverrides,
+        jointOverrides: options.jointOverrides
+      });
+      report = error ? failedReport2(scriptPath, error, "STABILITY.MODEL.EMPTY") : analyze(scriptPath, options, objects);
+    } catch (error) {
+      report = failedReport2(scriptPath, error instanceof Error ? error.message : String(error));
+    }
+    reports.push(report);
+  }
+  printFeedback(reports.length === 1 ? reports[0] : { runs: reports }, options.json, options.compact);
+  if (reports.some((report) => !report.ok) && !options.noFailExit) process.exitCode = 1;
+}
+
 // cli/check-text.ts
 import assert6 from "assert/strict";
 var EPS6 = 1e-3;
@@ -18546,11 +19182,12 @@ async function buildStepBlob(objects) {
 }
 
 // cli/forge-brep.ts
-function parseArgs5(argv) {
+function parseArgs6(argv) {
   let format = "step";
   let backend = "occt";
   let outputPath;
   const inputPaths = [];
+  const paramOverrides = {};
   const jointOverrides = {};
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
@@ -18585,6 +19222,13 @@ function parseArgs5(argv) {
       i += 1;
       continue;
     }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
     if (arg === "--python") {
       throw new Error("--python is no longer supported. STEP/BREP export now uses the native OCCT runtime exporter.");
     }
@@ -18603,14 +19247,14 @@ function parseArgs5(argv) {
   }
   requireInputPaths(
     inputPaths,
-    "Usage: forgecad export <step|brep> <model.forge.js|asset.step|asset.stp> [input ...] [--output path] [--backend occt|truck] [--joint JointName=Value]"
+    "Usage: forgecad export <step|brep> <model.forge.js|asset.step|asset.stp> [input ...] [--output path] [--backend occt|truck] [--param Key=Value] [--joint JointName=Value]"
   );
   requireExactExportInputPaths(inputPaths);
   requireSingleInputForOutputPath(inputPaths, outputPath);
   if (backend === "truck" && format !== "step") {
     throw new Error("The native Truck BREP exporter currently supports STEP only (use --format step).");
   }
-  return { format, backend, outputPath, inputPaths, jointOverrides };
+  return { format, backend, outputPath, inputPaths, paramOverrides, jointOverrides };
 }
 function defaultOutputPath(scriptPath, sourcePath, format) {
   const abs = resolve16(scriptPath);
@@ -18618,8 +19262,9 @@ function defaultOutputPath(scriptPath, sourcePath, format) {
   const target = `${stem}.${format}`;
   return resolve16(target) === resolve16(sourcePath) ? `${stem}.forgecad.${format}` : target;
 }
-async function buildRuntimeExactExportBlob(format, code, fileName, allFiles, readBinaryFile, jointOverrides) {
+async function buildRuntimeExactExportBlob(format, code, fileName, allFiles, readBinaryFile, paramOverrides, jointOverrides) {
   await activateBackend("occt");
+  setParamOverrides(paramOverrides);
   const result = applyCliJointOverrides(
     runScript(code, fileName, allFiles, { readBinaryFile, assemblyState: jointOverrides }),
     jointOverrides
@@ -18652,8 +19297,9 @@ async function buildRuntimeExactExportBlob(format, code, fileName, allFiles, rea
     objectCount: exactObjects.length
   };
 }
-async function buildTruckStepBlob(code, fileName, allFiles, readBinaryFile, jointOverrides) {
+async function buildTruckStepBlob(code, fileName, allFiles, readBinaryFile, paramOverrides, jointOverrides) {
   await activateBackend("truck");
+  setParamOverrides(paramOverrides);
   const result = applyCliJointOverrides(
     runScript(code, fileName, allFiles, { readBinaryFile, assemblyState: jointOverrides }),
     jointOverrides
@@ -18669,13 +19315,13 @@ async function buildTruckStepBlob(code, fileName, allFiles, readBinaryFile, join
   return { blob: new Blob([step], { type: "application/step" }), objectCount: handles.length };
 }
 async function runBrepCli(argv = process.argv.slice(2)) {
-  const { format, backend, outputPath, inputPaths, jointOverrides } = parseArgs5(argv);
+  const { format, backend, outputPath, inputPaths, paramOverrides, jointOverrides } = parseArgs6(argv);
   requireExistingInputPaths(inputPaths);
   let failures = 0;
   for (const [index, scriptPath] of inputPaths.entries()) {
     printBatchHeader(scriptPath, index, inputPaths.length);
     try {
-      await exportBrepInput(format, backend, outputPath, scriptPath, jointOverrides);
+      await exportBrepInput(format, backend, outputPath, scriptPath, paramOverrides, jointOverrides);
     } catch (error) {
       failures += 1;
       console.error(error instanceof Error ? error.message : String(error));
@@ -18685,11 +19331,19 @@ async function runBrepCli(argv = process.argv.slice(2)) {
     process.exit(1);
   }
 }
-async function exportBrepInput(format, backend, outputPath, scriptPath, jointOverrides) {
+async function exportBrepInput(format, backend, outputPath, scriptPath, paramOverrides, jointOverrides) {
   const input = loadCliScriptInput(scriptPath);
   await init();
   try {
-    const exactExport = backend === "truck" ? await buildTruckStepBlob(input.code, input.fileName, input.allFiles, input.readBinaryFile, jointOverrides) : await buildRuntimeExactExportBlob(format, input.code, input.fileName, input.allFiles, input.readBinaryFile, jointOverrides);
+    const exactExport = backend === "truck" ? await buildTruckStepBlob(input.code, input.fileName, input.allFiles, input.readBinaryFile, paramOverrides, jointOverrides) : await buildRuntimeExactExportBlob(
+      format,
+      input.code,
+      input.fileName,
+      input.allFiles,
+      input.readBinaryFile,
+      paramOverrides,
+      jointOverrides
+    );
     if (outputPath && resolve16(outputPath) === input.sourcePath) {
       console.error("Output path would overwrite the input file. Pass a different --output path.");
       process.exit(1);
@@ -18699,6 +19353,7 @@ async function exportBrepInput(format, backend, outputPath, scriptPath, jointOve
     console.log(`\u2713 Exported ${exactExport.objectCount} object(s) to ${finalOutput}`);
     return;
   } catch (runtimeError) {
+    setParamOverrides(paramOverrides);
     const result = applyCliJointOverrides(
       runScript(input.code, input.fileName, input.allFiles, {
         readBinaryFile: input.readBinaryFile,
@@ -19656,7 +20311,7 @@ async function waitForRenderHtml2(port, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (await fetchRenderHtml2(port)) return true;
-    await new Promise((resolve44) => setTimeout(resolve44, 250));
+    await new Promise((resolve46) => setTimeout(resolve46, 250));
   }
   return false;
 }
@@ -19710,7 +20365,7 @@ ${detail}` : `Timed out waiting for Vite on port ${port}.`);
 async function stopDevServer2(proc) {
   if (!proc || proc.killed) return;
   proc.kill("SIGTERM");
-  await new Promise((resolve44) => setTimeout(resolve44, 150));
+  await new Promise((resolve46) => setTimeout(resolve46, 150));
   if (!proc.killed) {
     proc.kill("SIGKILL");
   }
@@ -20925,9 +21580,9 @@ function toViteArgs(options) {
   return args;
 }
 function waitForExit(child) {
-  return new Promise((resolve44, reject) => {
+  return new Promise((resolve46, reject) => {
     child.once("error", reject);
-    child.once("exit", (code) => resolve44(code ?? 0));
+    child.once("exit", (code) => resolve46(code ?? 0));
   });
 }
 async function runDevCli(argv = process.argv.slice(2)) {
@@ -20953,9 +21608,10 @@ async function runDevCli(argv = process.argv.slice(2)) {
 // cli/forge-gcode.ts
 import { writeFileSync as writeFileSync6 } from "fs";
 import { extname as extname5, resolve as resolve20 } from "path";
-function parseArgs6(argv) {
+function parseArgs7(argv) {
   const inputPaths = [];
   let outputPath;
+  const paramOverrides = {};
   const jointOverrides = {};
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
@@ -20972,15 +21628,25 @@ function parseArgs6(argv) {
       i += 1;
       continue;
     }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
     if (arg.startsWith("--")) {
       throw new Error(`Unknown flag: ${arg}`);
     }
     inputPaths.push(arg);
   }
-  requireInputPaths(inputPaths, "Usage: forgecad export gcode <script.forge.js> [input ...] [--output path] [--joint JointName=Value]");
+  requireInputPaths(
+    inputPaths,
+    "Usage: forgecad export gcode <script.forge.js> [input ...] [--output path] [--param Key=Value] [--joint JointName=Value]"
+  );
   requireScriptInputPaths(inputPaths);
   requireSingleInputForOutputPath(inputPaths, outputPath);
-  return { inputPaths, outputPath, jointOverrides };
+  return { inputPaths, outputPath, paramOverrides, jointOverrides };
 }
 function defaultOutputPath3(scriptPath) {
   const abs = resolve20(scriptPath);
@@ -20989,13 +21655,13 @@ function defaultOutputPath3(scriptPath) {
   return `${stem}.gcode`;
 }
 async function runGcodeExportCli(argv) {
-  const { inputPaths, outputPath, jointOverrides } = parseArgs6(argv);
+  const { inputPaths, outputPath, paramOverrides, jointOverrides } = parseArgs7(argv);
   requireExistingInputPaths(inputPaths);
   let failures = 0;
   for (const [index, scriptPath] of inputPaths.entries()) {
     printBatchHeader(scriptPath, index, inputPaths.length);
     try {
-      await exportGcodeInput(scriptPath, outputPath, jointOverrides);
+      await exportGcodeInput(scriptPath, outputPath, paramOverrides, jointOverrides);
     } catch (error) {
       failures += 1;
       console.error(error instanceof Error ? error.message : String(error));
@@ -21005,10 +21671,11 @@ async function runGcodeExportCli(argv) {
     process.exit(1);
   }
 }
-async function exportGcodeInput(scriptPath, explicitOutputPath, jointOverrides) {
+async function exportGcodeInput(scriptPath, explicitOutputPath, paramOverrides, jointOverrides) {
   const code = (await import("fs")).readFileSync(resolve20(scriptPath), "utf-8");
   const { allFiles, fileName, readBinaryFile } = collectProjectFiles(scriptPath);
   await initKernel();
+  setParamOverrides(paramOverrides);
   const result = applyCliJointOverrides(
     runScript(code, fileName, allFiles, { readBinaryFile, allowEmptyResult: true, assemblyState: jointOverrides }),
     jointOverrides
@@ -21156,7 +21823,7 @@ function parseImplicitExportArgs(argv) {
   }
   if (!scriptPath) {
     throw new Error(
-      "Usage: forgecad export implicit <model.forge.js|asset.step|asset.stp> [--output path] [--format json|webgpu-brick] [--quality live|default|high] [--backend manifold|occt|truck|sdf]"
+      "Usage: forgecad export implicit <model.forge.js|asset.step|asset.stp> [--output path] [--format json|webgpu-brick] [--quality live|default|high] [--backend manifold|occt|truck|sdf] [--param Key=Value] [--joint JointName=Value]"
     );
   }
   return { scriptPath, outputPath, format, backend, quality, workgroupSize, paramOverrides, jointOverrides };
@@ -21248,7 +21915,7 @@ async function runImplicitExportCli(argv = process.argv.slice(2)) {
   const args = parseImplicitExportArgs(argv);
   const input = loadCliScriptInput(args.scriptPath);
   await initCliBackend(args.backend);
-  if (Object.keys(args.paramOverrides).length > 0) setParamOverrides(args.paramOverrides);
+  setParamOverrides(args.paramOverrides);
   const runResult = runScript(input.code, input.fileName, input.allFiles, {
     ...args.quality ? { quality: args.quality } : {},
     readBinaryFile: input.readBinaryFile,
@@ -21483,11 +22150,12 @@ async function runLsInput(options, scriptPath, overrides, jointOverrides) {
 // cli/forge-mesh.ts
 import { writeFileSync as writeFileSync8 } from "fs";
 import { extname as extname6, resolve as resolve22 } from "path";
-function parseArgs7(argv) {
+function parseArgs8(argv) {
   const inputPaths = [];
   let outputPath;
   let quality;
   let backend;
+  const paramOverrides = {};
   const jointOverrides = {};
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
@@ -21522,6 +22190,13 @@ function parseArgs7(argv) {
       i += 1;
       continue;
     }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
     if (arg.startsWith("--")) {
       throw new Error(`Unknown flag: ${arg}`);
     }
@@ -21529,11 +22204,11 @@ function parseArgs7(argv) {
   }
   requireInputPaths(
     inputPaths,
-    "Usage: forgecad export <3mf|stl> <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--quality default|live|high] [--backend manifold|occt|truck|sdf] [--joint JointName=Value]"
+    "Usage: forgecad export <3mf|stl> <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--quality default|live|high] [--backend manifold|occt|truck|sdf] [--param Key=Value] [--joint JointName=Value]"
   );
   requireRenderableInputPaths(inputPaths);
   requireSingleInputForOutputPath(inputPaths, outputPath);
-  return { inputPaths, outputPath, quality, backend, jointOverrides };
+  return { inputPaths, outputPath, quality, backend, paramOverrides, jointOverrides };
 }
 function defaultOutputPath5(scriptPath, sourcePath, format) {
   const abs = resolve22(scriptPath);
@@ -21550,13 +22225,13 @@ function extractMeshObjects(result) {
   }));
 }
 async function runMeshExportCli(format, argv) {
-  const { inputPaths, outputPath, quality, backend, jointOverrides } = parseArgs7(argv);
+  const { inputPaths, outputPath, quality, backend, paramOverrides, jointOverrides } = parseArgs8(argv);
   requireExistingInputPaths(inputPaths);
   let failures = 0;
   for (const [index, scriptPath] of inputPaths.entries()) {
     printBatchHeader(scriptPath, index, inputPaths.length);
     try {
-      await exportMeshInput(format, scriptPath, outputPath, quality, backend, jointOverrides);
+      await exportMeshInput(format, scriptPath, outputPath, quality, backend, paramOverrides, jointOverrides);
     } catch (error) {
       failures += 1;
       console.error(error instanceof Error ? error.message : String(error));
@@ -21566,10 +22241,11 @@ async function runMeshExportCli(format, argv) {
     process.exit(1);
   }
 }
-async function exportMeshInput(format, scriptPath, outputPath, quality, backend, jointOverrides) {
+async function exportMeshInput(format, scriptPath, outputPath, quality, backend, paramOverrides, jointOverrides) {
   const input = loadCliScriptInput(scriptPath);
   await initCliBackend(resolveCliBackend(backend, input) ?? CLI_DEFAULT_BACKEND);
   const qualityPreset = quality && quality !== "default" ? quality : void 0;
+  setParamOverrides(paramOverrides);
   const runResult = runScript(input.code, input.fileName, input.allFiles, {
     ...qualityPreset ? { quality: qualityPreset } : {},
     readBinaryFile: input.readBinaryFile,
@@ -23604,9 +24280,10 @@ function buildMjcfRobotPackage(spec) {
 }
 
 // cli/forge-mjcf.ts
-function parseArgs8(argv) {
+function parseArgs9(argv) {
   const inputPaths = [];
   let outputPath;
+  const paramOverrides = {};
   const jointOverrides = {};
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
@@ -23623,25 +24300,31 @@ function parseArgs8(argv) {
       i += 1;
       continue;
     }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
     if (arg.startsWith("--")) {
       throw new Error(`Unknown flag: ${arg}`);
     }
     inputPaths.push(arg);
   }
-  requireInputPaths(inputPaths, "Usage: forgecad export mjcf <script.forge.js> [input ...] [--output dir] [--joint JointName=Value]");
+  requireInputPaths(
+    inputPaths,
+    "Usage: forgecad export mjcf <script.forge.js> [input ...] [--output dir] [--param Key=Value] [--joint JointName=Value]"
+  );
   requireScriptInputPaths(inputPaths);
   requireSingleInputForOutputPath(inputPaths, outputPath, "--output", "dir");
-  return { inputPaths, outputPath, jointOverrides };
+  return { inputPaths, outputPath, paramOverrides, jointOverrides };
 }
 function defaultOutputPath6(scriptPath) {
   const abs = resolve23(scriptPath);
   return abs.slice(0, abs.length - extname7(abs).length) + ".mjcfpkg";
 }
 function resolveSimulationModel2(result, jointOverrides) {
-  const legacy = getCollectedRobotExport();
-  if (legacy) {
-    return { ...legacy, state: { ...legacy.state, ...jointOverrides } };
-  }
   const assembly2 = getRunResultAssemblySource(result);
   if (!assembly2) return null;
   const def = assembly2.describe();
@@ -23649,13 +24332,13 @@ function resolveSimulationModel2(result, jointOverrides) {
   return collectSimulationModel(def, { state: jointOverrides });
 }
 async function runMjcfCli(argv = process.argv.slice(2)) {
-  const { inputPaths, outputPath, jointOverrides } = parseArgs8(argv);
+  const { inputPaths, outputPath, paramOverrides, jointOverrides } = parseArgs9(argv);
   requireExistingInputPaths(inputPaths);
   let failures = 0;
   for (const [index, scriptPath] of inputPaths.entries()) {
     printBatchHeader(scriptPath, index, inputPaths.length);
     try {
-      await exportMjcfInput(scriptPath, outputPath, jointOverrides);
+      await exportMjcfInput(scriptPath, outputPath, paramOverrides, jointOverrides);
     } catch (error) {
       failures += 1;
       console.error(error instanceof Error ? error.message : String(error));
@@ -23665,17 +24348,18 @@ async function runMjcfCli(argv = process.argv.slice(2)) {
     process.exit(1);
   }
 }
-async function exportMjcfInput(scriptPath, explicitOutputPath, jointOverrides) {
+async function exportMjcfInput(scriptPath, explicitOutputPath, paramOverrides, jointOverrides) {
   const code = readFileSync15(resolve23(scriptPath), "utf-8");
   const { allFiles, fileName } = collectProjectFiles(scriptPath);
   await init();
+  setParamOverrides(paramOverrides);
   const result = applyCliJointOverrides(runScript(code, fileName, allFiles, { assemblyState: jointOverrides }), jointOverrides);
   if (result.error) {
     throw new Error(`ERROR: ${result.error}`);
   }
   const robot = resolveSimulationModel2(result, jointOverrides);
   if (!robot) {
-    throw new Error("MJCF export requires the script to return assembly(...).withSimulation(...) or call legacy robotExport({...}).");
+    throw new Error("MJCF export requires the script to return assembly(...).withSimulation(...).");
   }
   const packageOut = buildMjcfRobotPackage(robot);
   const targetDir = resolve23(batchOutputPath(scriptPath, explicitOutputPath, defaultOutputPath6));
@@ -24072,7 +24756,7 @@ function readArgValue(argv, idx, flag) {
   }
   return next;
 }
-function parseArgs9(argv) {
+function parseArgs10(argv) {
   const inputPaths = [];
   let outputPath;
   let width = 1920;
@@ -24346,7 +25030,7 @@ function viewportCameraToBlenderConfig(camera) {
   };
 }
 async function runRenderHqCli(argv) {
-  const args = parseArgs9(argv);
+  const args = parseArgs10(argv);
   requireExistingInputPaths(args.inputPaths);
   let failures = 0;
   for (const [index, scriptPath] of args.inputPaths.entries()) {
@@ -24492,7 +25176,9 @@ function defaultPngOutput(scriptPath) {
   return scriptPath.replace(/\.(forge|sketch)\.js$/, ".png").replace(/\.js$/, ".png");
 }
 function usage14() {
-  console.error("Usage: forgecad render sketch <script.forge.js> [input ...] [--output path] [--size <px>] [--chrome-path <path>]");
+  console.error(
+    "Usage: forgecad render sketch <script.forge.js> [input ...] [--output path] [--size <px>] [--chrome-path <path>] [--param Key=Value]"
+  );
   process.exit(1);
 }
 function parseCli2(argv) {
@@ -24502,6 +25188,7 @@ function parseCli2(argv) {
   let size = 1024;
   let chromePath = process.env.CHROME_PATH;
   let background = "#2a2a2a";
+  const paramOverrides = {};
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === "--size") {
@@ -24516,6 +25203,13 @@ function parseCli2(argv) {
       background = argv[++i];
       continue;
     }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value.`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
     if (arg === "--output" || arg === "-o") {
       outputPath = argv[++i];
       if (!outputPath || outputPath.startsWith("--")) throw new Error(`${arg} requires a file path.`);
@@ -24533,7 +25227,8 @@ function parseCli2(argv) {
     outputPath,
     size,
     chromePath,
-    background
+    background,
+    paramOverrides
   };
 }
 async function runRender2dCli(argv = process.argv.slice(2)) {
@@ -24570,6 +25265,7 @@ async function renderSketchInput(options, scriptPath, chromePath) {
   const code = await readFile(resolve26(scriptPath), "utf-8");
   const { allFiles, fileName } = collectProjectFiles(scriptPath);
   await init();
+  setParamOverrides(options.paramOverrides);
   const result = runScript(code, fileName, allFiles);
   if (result.error) {
     throw new Error(`Script error: ${result.error}`);
@@ -24677,14 +25373,22 @@ function formatSheetCutList(input) {
 
 // cli/forge-cut-list.ts
 function usage15() {
-  console.error("Usage: forgecad cut-list <script.forge.js> [input ...] [--joint JointName=Value]");
+  console.error("Usage: forgecad cut-list <script.forge.js> [input ...] [--param Key=Value] [--joint JointName=Value]");
   process.exit(1);
 }
-function parseArgs10(argv) {
+function parseArgs11(argv) {
   const positionals = [];
+  const paramOverrides = {};
   const jointOverrides = {};
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[index + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      index += 1;
+      continue;
+    }
     if (arg === "--joint") {
       const value = argv[index + 1];
       if (!value || value.startsWith("--")) throw new Error("--joint requires JointName=Value");
@@ -24698,16 +25402,16 @@ function parseArgs10(argv) {
   if (positionals.length === 0) usage15();
   const inputPaths = requireInputPaths(positionals, "Missing input path.");
   requireScriptInputPaths(inputPaths);
-  return { inputPaths, jointOverrides };
+  return { inputPaths, paramOverrides, jointOverrides };
 }
 async function runCutListCli(argv = process.argv.slice(2)) {
-  const { inputPaths, jointOverrides } = parseArgs10(argv);
+  const { inputPaths, paramOverrides, jointOverrides } = parseArgs11(argv);
   requireExistingInputPaths(inputPaths);
   let failures = 0;
   for (const [index, scriptPath] of inputPaths.entries()) {
     printBatchHeader(scriptPath, index, inputPaths.length);
     try {
-      await printCutListInput(scriptPath, jointOverrides);
+      await printCutListInput(scriptPath, paramOverrides, jointOverrides);
     } catch (error) {
       failures += 1;
       console.error(error instanceof Error ? error.message : String(error));
@@ -24717,10 +25421,11 @@ async function runCutListCli(argv = process.argv.slice(2)) {
     process.exit(1);
   }
 }
-async function printCutListInput(scriptPath, jointOverrides) {
+async function printCutListInput(scriptPath, paramOverrides, jointOverrides) {
   const source = await readFile2(resolve27(scriptPath), "utf-8");
   const { allFiles, fileName } = collectProjectFiles(scriptPath);
   await init();
+  setParamOverrides(paramOverrides);
   const result = applyCliJointOverrides(runScript(source, fileName, allFiles, { assemblyState: jointOverrides }), jointOverrides);
   if (result.error) {
     throw new Error(`Script error: ${result.error}`);
@@ -24735,7 +25440,7 @@ async function printCutListInput(scriptPath, jointOverrides) {
 import { readFile as readFile3, writeFile as writeFile5 } from "fs/promises";
 import { basename as basename11, resolve as resolve28 } from "path";
 var FORMAT_VALUES = ["pdf", "dxf"];
-var VALUE_FLAGS = /* @__PURE__ */ new Set(["--format", "--sheet-width", "--sheet-height", "--kerf", "--joint", "--output", "--out"]);
+var VALUE_FLAGS = /* @__PURE__ */ new Set(["--format", "--sheet-width", "--sheet-height", "--kerf", "--param", "-p", "--joint", "--output", "--out"]);
 function argValue(argv, name) {
   const prefix = `${name}=`;
   const equalsArg = argv.find((arg) => arg.startsWith(prefix));
@@ -24749,7 +25454,7 @@ function hasFlag(argv, name) {
   return argv.some((arg) => arg === name || arg.startsWith(prefix));
 }
 function usageText() {
-  return "Usage: forgecad export cutting-layout <script.forge.js> [input ...] [--output output.pdf|output.dxf]\n         [--format pdf|dxf] [--sheet-width <mm>] [--sheet-height <mm>] [--kerf <mm>] [--joint JointName=Value]";
+  return "Usage: forgecad export cutting-layout <script.forge.js> [input ...] [--output output.pdf|output.dxf]\n         [--format pdf|dxf] [--sheet-width <mm>] [--sheet-height <mm>] [--kerf <mm>] [--param Key=Value] [--joint JointName=Value]";
 }
 function usage16() {
   console.error(usageText());
@@ -24779,6 +25484,18 @@ function parseJointOverrides(argv) {
   }
   return jointOverrides;
 }
+function parseParamOverrides(argv) {
+  const paramOverrides = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg !== "--param" && arg !== "-p") continue;
+    const value = argv[i + 1];
+    if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+    addCliParamOverride(value, paramOverrides);
+    i += 1;
+  }
+  return paramOverrides;
+}
 function normalizeFormat(value) {
   if (value == null) return void 0;
   const normalized = value.toLowerCase();
@@ -24850,6 +25567,7 @@ async function runCuttingLayoutCli(argv = process.argv.slice(2)) {
   if (failures > 0) process.exit(1);
 }
 async function exportCuttingLayoutInput(argv, scriptPath, explicitOutputPath) {
+  const paramOverrides = parseParamOverrides(argv);
   const jointOverrides = parseJointOverrides(argv);
   const formatArg = argValue(argv, "--format");
   if (hasFlag(argv, "--format") && formatArg == null) {
@@ -24870,6 +25588,7 @@ async function exportCuttingLayoutInput(argv, scriptPath, explicitOutputPath) {
   const source = await readFile3(resolve28(scriptPath), "utf-8");
   const { allFiles, fileName } = collectProjectFiles(scriptPath);
   await init();
+  setParamOverrides(paramOverrides);
   const result = applyCliJointOverrides(runScript(source, fileName, allFiles, { assemblyState: jointOverrides }), jointOverrides);
   if (result.error) {
     throw new Error(`Script error: ${result.error}`);
@@ -24907,7 +25626,7 @@ import { writeFile as writeFile6 } from "fs/promises";
 import { basename as basename12, resolve as resolve29 } from "path";
 function usage17() {
   console.error(
-    "Usage: forgecad export report <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--dim-angle-tol <deg>] [--joint JointName=Value]"
+    "Usage: forgecad export report <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--dim-angle-tol <deg>] [--param Key=Value] [--joint JointName=Value]"
   );
   process.exit(1);
 }
@@ -24916,8 +25635,9 @@ function readValue7(argv, index, flag) {
   if (!value || value.startsWith("--")) throw new Error(`${flag} requires a value.`);
   return value;
 }
-function parseArgs11(argv) {
+function parseArgs12(argv) {
   const positionals = [];
+  const paramOverrides = {};
   const jointOverrides = {};
   let dimAngleToleranceDeg;
   let outputPath;
@@ -24939,6 +25659,11 @@ function parseArgs11(argv) {
       index += 1;
       continue;
     }
+    if (arg === "--param" || arg === "-p") {
+      addCliParamOverride(readValue7(argv, index, arg), paramOverrides);
+      index += 1;
+      continue;
+    }
     if (arg.startsWith("--")) throw new Error(`Unknown option: ${arg}`);
     positionals.push(arg);
   }
@@ -24946,16 +25671,16 @@ function parseArgs11(argv) {
   const inputPaths = requireInputPaths(positionals, "Missing input path.");
   requireRenderableInputPaths(inputPaths);
   requireSingleInputForOutputPath(inputPaths, outputPath);
-  return { inputPaths, outputPath, dimAngleToleranceDeg, jointOverrides };
+  return { inputPaths, outputPath, dimAngleToleranceDeg, paramOverrides, jointOverrides };
 }
 async function runReportCli(argv = process.argv.slice(2)) {
-  const { inputPaths, outputPath: parsedOutputPath, jointOverrides, dimAngleToleranceDeg } = parseArgs11(argv);
+  const { inputPaths, outputPath: parsedOutputPath, paramOverrides, jointOverrides, dimAngleToleranceDeg } = parseArgs12(argv);
   requireExistingInputPaths(inputPaths);
   let failures = 0;
   for (const [index, scriptPath] of inputPaths.entries()) {
     printBatchHeader(scriptPath, index, inputPaths.length);
     try {
-      await exportReportInput(scriptPath, parsedOutputPath, jointOverrides, dimAngleToleranceDeg);
+      await exportReportInput(scriptPath, parsedOutputPath, paramOverrides, jointOverrides, dimAngleToleranceDeg);
     } catch (error) {
       failures += 1;
       console.error(error instanceof Error ? error.message : String(error));
@@ -24965,10 +25690,11 @@ async function runReportCli(argv = process.argv.slice(2)) {
     process.exit(1);
   }
 }
-async function exportReportInput(scriptPath, explicitOutputPath, jointOverrides, dimAngleToleranceDeg) {
+async function exportReportInput(scriptPath, explicitOutputPath, paramOverrides, jointOverrides, dimAngleToleranceDeg) {
   const outputPath = batchOutputPath(scriptPath, explicitOutputPath, (inputPath) => replaceCliInputExtension(inputPath, ".report.pdf"));
   const input = loadCliScriptInput(scriptPath);
   await initCliBackend(resolveCliBackend(void 0, input) ?? CLI_DEFAULT_BACKEND);
+  setParamOverrides(paramOverrides);
   const result = applyCliJointOverrides(
     runScript(input.code, input.fileName, input.allFiles, {
       readBinaryFile: input.readBinaryFile,
@@ -25828,9 +26554,10 @@ function buildSdfRobotPackage(spec) {
 }
 
 // cli/forge-sdf.ts
-function parseArgs12(argv) {
+function parseArgs13(argv) {
   const inputPaths = [];
   let outputPath;
+  const paramOverrides = {};
   const jointOverrides = {};
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
@@ -25847,25 +26574,31 @@ function parseArgs12(argv) {
       i += 1;
       continue;
     }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
     if (arg.startsWith("--")) {
       throw new Error(`Unknown flag: ${arg}`);
     }
     inputPaths.push(arg);
   }
-  requireInputPaths(inputPaths, "Usage: forgecad export sdf <script.forge.js> [input ...] [--output dir] [--joint JointName=Value]");
+  requireInputPaths(
+    inputPaths,
+    "Usage: forgecad export sdf <script.forge.js> [input ...] [--output dir] [--param Key=Value] [--joint JointName=Value]"
+  );
   requireScriptInputPaths(inputPaths);
   requireSingleInputForOutputPath(inputPaths, outputPath, "--output", "dir");
-  return { inputPaths, outputPath, jointOverrides };
+  return { inputPaths, outputPath, paramOverrides, jointOverrides };
 }
 function defaultOutputPath9(scriptPath) {
   const abs = resolve30(scriptPath);
   return abs.slice(0, abs.length - extname9(abs).length) + ".sdfpkg";
 }
 function resolveSimulationModel3(result, jointOverrides) {
-  const legacy = getCollectedRobotExport();
-  if (legacy) {
-    return { ...legacy, state: { ...legacy.state, ...jointOverrides } };
-  }
   const assembly2 = getRunResultAssemblySource(result);
   if (!assembly2) return null;
   const def = assembly2.describe();
@@ -25873,13 +26606,13 @@ function resolveSimulationModel3(result, jointOverrides) {
   return collectSimulationModel(def, { state: jointOverrides });
 }
 async function runSdfCli(argv = process.argv.slice(2)) {
-  const { inputPaths, outputPath, jointOverrides } = parseArgs12(argv);
+  const { inputPaths, outputPath, paramOverrides, jointOverrides } = parseArgs13(argv);
   requireExistingInputPaths(inputPaths);
   let failures = 0;
   for (const [index, scriptPath] of inputPaths.entries()) {
     printBatchHeader(scriptPath, index, inputPaths.length);
     try {
-      await exportSdfInput(scriptPath, outputPath, jointOverrides);
+      await exportSdfInput(scriptPath, outputPath, paramOverrides, jointOverrides);
     } catch (error) {
       failures += 1;
       console.error(error instanceof Error ? error.message : String(error));
@@ -25889,17 +26622,18 @@ async function runSdfCli(argv = process.argv.slice(2)) {
     process.exit(1);
   }
 }
-async function exportSdfInput(scriptPath, explicitOutputPath, jointOverrides) {
+async function exportSdfInput(scriptPath, explicitOutputPath, paramOverrides, jointOverrides) {
   const code = readFileSync16(resolve30(scriptPath), "utf-8");
   const { allFiles, fileName } = collectProjectFiles(scriptPath);
   await init();
+  setParamOverrides(paramOverrides);
   const result = applyCliJointOverrides(runScript(code, fileName, allFiles, { assemblyState: jointOverrides }), jointOverrides);
   if (result.error) {
     throw new Error(`ERROR: ${result.error}`);
   }
   const robot = resolveSimulationModel3(result, jointOverrides);
   if (!robot) {
-    throw new Error("SDF export requires the script to return assembly(...).withSimulation(...) or call legacy robotExport({...}).");
+    throw new Error("SDF export requires the script to return assembly(...).withSimulation(...).");
   }
   const packageOut = buildSdfRobotPackage(robot);
   const targetDir = resolve30(batchOutputPath(scriptPath, explicitOutputPath, defaultOutputPath9));
@@ -26625,15 +27359,16 @@ function generateSketchPdf(meta, options) {
 
 // cli/forge-sketch-pdf.ts
 function usage19() {
-  console.error("Usage: forgecad export sketch-pdf <script.forge.js> [input ...] [--output path]");
+  console.error("Usage: forgecad export sketch-pdf <script.forge.js> [input ...] [--output path] [--param Key=Value]");
   process.exit(1);
 }
 function defaultPdfOutput(scriptPath) {
   return scriptPath.replace(/\.(forge|sketch)\.js$/, ".sketch.pdf").replace(/\.js$/, ".sketch.pdf");
 }
-function parseArgs13(argv) {
+function parseArgs14(argv) {
   const inputPaths = [];
   let outputPath;
+  const paramOverrides = {};
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
     if (arg === "--output" || arg === "-o") {
@@ -26642,18 +27377,25 @@ function parseArgs13(argv) {
       index += 1;
       continue;
     }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[index + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value.`);
+      addCliParamOverride(value, paramOverrides);
+      index += 1;
+      continue;
+    }
     if (arg.startsWith("--")) throw new Error(`Unknown option: ${arg}`);
     inputPaths.push(arg);
   }
   requireInputPaths(inputPaths, "Missing input path.");
   requireScriptInputPaths(inputPaths);
   requireSingleInputForOutputPath(inputPaths, outputPath);
-  return { inputPaths, outputPath };
+  return { inputPaths, outputPath, paramOverrides };
 }
 async function runSketchPdfCli(argv = process.argv.slice(2)) {
   let parsed;
   try {
-    parsed = parseArgs13(argv);
+    parsed = parseArgs14(argv);
     requireExistingInputPaths(parsed.inputPaths);
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
@@ -26663,7 +27405,7 @@ async function runSketchPdfCli(argv = process.argv.slice(2)) {
   for (const [index, scriptPath] of parsed.inputPaths.entries()) {
     printBatchHeader(scriptPath, index, parsed.inputPaths.length);
     try {
-      await exportSketchPdfInput(scriptPath, parsed.outputPath);
+      await exportSketchPdfInput(scriptPath, parsed.outputPath, parsed.paramOverrides);
     } catch (error) {
       failures += 1;
       console.error(error instanceof Error ? error.message : String(error));
@@ -26673,7 +27415,7 @@ async function runSketchPdfCli(argv = process.argv.slice(2)) {
     process.exit(1);
   }
 }
-async function exportSketchPdfInput(scriptPath, explicitOutputPath) {
+async function exportSketchPdfInput(scriptPath, explicitOutputPath, paramOverrides) {
   const outputPath = batchOutputPath(scriptPath, explicitOutputPath, defaultPdfOutput);
   if (resolve31(outputPath) === resolve31(scriptPath)) {
     throw new Error(`ERROR: output path would overwrite the input script. Specify an explicit output path.`);
@@ -26681,6 +27423,7 @@ async function exportSketchPdfInput(scriptPath, explicitOutputPath) {
   const code = await readFile4(resolve31(scriptPath), "utf-8");
   const { allFiles, fileName } = collectProjectFiles(scriptPath);
   await init();
+  setParamOverrides(paramOverrides);
   const result = runScript(code, fileName, allFiles);
   if (result.error) {
     throw new Error(`Script error: ${result.error}`);
@@ -27221,15 +27964,15 @@ function getEnvToken() {
 }
 function prompt(question) {
   const rl = createInterface({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve44) => {
+  return new Promise((resolve46) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve44(answer.trim());
+      resolve46(answer.trim());
     });
   });
 }
 function promptPassword(question) {
-  return new Promise((resolve44) => {
+  return new Promise((resolve46) => {
     process.stderr.write(question);
     const stdin = process.stdin;
     const wasRaw = stdin.isRaw;
@@ -27244,7 +27987,7 @@ function promptPassword(question) {
       stdin.removeListener("end", finish);
       stdin.pause();
       process.stderr.write("\n");
-      resolve44(password);
+      resolve46(password);
     };
     const onData = (ch) => {
       for (const c of ch.toString("utf-8")) {
@@ -27801,7 +28544,7 @@ import { existsSync as existsSync14, readdirSync as readdirSync8, statSync as st
 import { createServer as createServer2 } from "net";
 import { join as join12 } from "path";
 var startedComputeServer = null;
-var REQUIRED_ENGINE_VERSION = "native-occt-node-api-0.3.0";
+var REQUIRED_ENGINE_VERSION = "native-occt-node-api-0.3.1";
 var REQUIRED_PLAN_KINDS = [
   "box",
   "cylinder",
@@ -27809,6 +28552,7 @@ var REQUIRED_PLAN_KINDS = [
   "torus",
   "extrude",
   "boolean",
+  "trimByPlane",
   "transform",
   "queryOwner",
   "revolve",
@@ -27847,17 +28591,17 @@ async function waitForHealthy(computeUrl, child) {
   for (let attempt = 0; attempt < 120; attempt += 1) {
     if (await isHealthy(computeUrl)) return;
     if (child.exitCode != null) break;
-    await new Promise((resolve44) => setTimeout(resolve44, 50));
+    await new Promise((resolve46) => setTimeout(resolve46, 50));
   }
   throw new Error(`Native OCCT compute backend did not become healthy at ${computeUrl}.`);
 }
 function closeChild(child) {
-  return new Promise((resolve44) => {
+  return new Promise((resolve46) => {
     if (child.exitCode != null || child.killed) {
-      resolve44();
+      resolve46();
       return;
     }
-    child.once("exit", () => resolve44());
+    child.once("exit", () => resolve46());
     child.kill();
   });
 }
@@ -27896,12 +28640,12 @@ async function pickComputeUrl(preferred) {
     const candidate = computeUrlWithPort(preferred, port);
     if (await isHealthy(candidate)) return candidate;
     try {
-      const server = await new Promise((resolve44, reject) => {
+      const server = await new Promise((resolve46, reject) => {
         const probe = createServer2();
         probe.once("error", reject);
-        probe.listen(port, listenHost, () => resolve44(probe));
+        probe.listen(port, listenHost, () => resolve46(probe));
       });
-      await new Promise((resolve44) => server.close(() => resolve44()));
+      await new Promise((resolve46) => server.close(() => resolve46()));
       return candidate;
     } catch {
     }
@@ -28328,14 +29072,14 @@ function sendJson(res, status, payload) {
   res.end(JSON.stringify(payload));
 }
 function readJsonBody(req) {
-  return new Promise((resolve44, reject) => {
+  return new Promise((resolve46, reject) => {
     let body = "";
     req.on("data", (chunk) => {
       body += chunk;
     });
     req.on("end", () => {
       try {
-        resolve44(body ? JSON.parse(body) : {});
+        resolve46(body ? JSON.parse(body) : {});
       } catch (e) {
         reject(e);
       }
@@ -28344,12 +29088,12 @@ function readJsonBody(req) {
   });
 }
 function readBinaryBody(req) {
-  return new Promise((resolve44, reject) => {
+  return new Promise((resolve46, reject) => {
     const chunks = [];
     req.on("data", (chunk) => {
       chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
     });
-    req.on("end", () => resolve44(Buffer.concat(chunks)));
+    req.on("end", () => resolve46(Buffer.concat(chunks)));
     req.on("error", reject);
   });
 }
@@ -28449,10 +29193,10 @@ function serveStatic(distDir, req, res) {
   return true;
 }
 function isPortAvailable(port, host) {
-  return new Promise((resolve44) => {
+  return new Promise((resolve46) => {
     const s = http.createServer();
-    s.listen(port, host, () => s.close(() => resolve44(true)));
-    s.on("error", () => resolve44(false));
+    s.listen(port, host, () => s.close(() => resolve46(true)));
+    s.on("error", () => resolve46(false));
   });
 }
 async function pickPort(preferred, host, strict) {
@@ -28545,10 +29289,10 @@ data: ${JSON.stringify(data)}
     );
   }
   function waitForWatcherReady(watcher) {
-    return new Promise((resolve44, reject) => {
+    return new Promise((resolve46, reject) => {
       const handleReady = () => {
         watcher.off("error", handleError);
-        resolve44();
+        resolve46();
       };
       const handleError = (error) => {
         watcher.off("ready", handleReady);
@@ -29163,12 +29907,12 @@ data: ${JSON.stringify(data)}
       res.end("Not found");
     }
   });
-  await new Promise((resolve44) => server.listen(port, host, resolve44));
+  await new Promise((resolve46) => server.listen(port, host, resolve46));
   const displayHost = host === "0.0.0.0" ? "localhost" : host;
   const url = `http://${displayHost}:${port}`;
   if (open) openBrowser(url);
   const close4 = async () => {
-    await new Promise((resolve44) => {
+    await new Promise((resolve46) => {
       for (const timer of snapshotTimers.values()) clearTimeout(timer);
       snapshotTimers.clear();
       for (const w of watchers) w.close();
@@ -29181,7 +29925,7 @@ data: ${JSON.stringify(data)}
         }
       }
       sseClients.clear();
-      server.close(() => resolve44());
+      server.close(() => resolve46());
     });
     await computeServer?.close();
   };
@@ -29299,7 +30043,7 @@ function usage21(command) {
   if (command === "render") return "Usage: forgecad context render <model.forge.js> [--out <dir>] [--force] [--size <px>]";
   return `Usage: forgecad context ${command} <model.forge.js> [--format text|json]`;
 }
-function parseArgs14(command, args) {
+function parseArgs15(command, args) {
   let filePath;
   let format = "text";
   for (let i = 0; i < args.length; i++) {
@@ -29584,7 +30328,7 @@ async function writeContextBundle(projectRoot, bundleDir, context, views) {
 }
 async function runContextGetCli(args = process.argv.slice(2)) {
   try {
-    const parsed = parseArgs14("get", args);
+    const parsed = parseArgs15("get", args);
     const loaded = await loadAgentContext(parsed.filePath);
     if (!loaded.context) {
       console.error(`No submitted agent context for ${loaded.filePath}.`);
@@ -29603,7 +30347,7 @@ async function runContextGetCli(args = process.argv.slice(2)) {
 }
 async function runContextStatusCli(args = process.argv.slice(2)) {
   try {
-    const parsed = parseArgs14("status", args);
+    const parsed = parseArgs15("status", args);
     const loaded = await loadAgentContext(parsed.filePath);
     const status = statusForLoaded(loaded);
     if (parsed.format === "json") {
@@ -29663,15 +30407,16 @@ async function runContextRenderCli(args = process.argv.slice(2)) {
 import { readFile as readFile5, writeFile as writeFile9 } from "fs/promises";
 import { basename as basename14, resolve as resolve34 } from "path";
 function usage22() {
-  console.error("Usage: forgecad export svg <script.forge.js> [input ...] [--output path]");
+  console.error("Usage: forgecad export svg <script.forge.js> [input ...] [--output path] [--param Key=Value]");
   process.exit(1);
 }
 function defaultSvgOutput(scriptPath) {
   return scriptPath.replace(/\.(forge|sketch)\.js$/, ".svg").replace(/\.js$/, ".svg");
 }
-function parseArgs15(argv) {
+function parseArgs16(argv) {
   const inputPaths = [];
   let outputPath;
+  const paramOverrides = {};
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
     if (arg === "--output" || arg === "-o") {
@@ -29680,18 +30425,25 @@ function parseArgs15(argv) {
       index += 1;
       continue;
     }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[index + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value.`);
+      addCliParamOverride(value, paramOverrides);
+      index += 1;
+      continue;
+    }
     if (arg.startsWith("--")) throw new Error(`Unknown option: ${arg}`);
     inputPaths.push(arg);
   }
   requireInputPaths(inputPaths, "Missing input path.");
   requireScriptInputPaths(inputPaths);
   requireSingleInputForOutputPath(inputPaths, outputPath);
-  return { inputPaths, outputPath };
+  return { inputPaths, outputPath, paramOverrides };
 }
 async function runSvgCli(argv = process.argv.slice(2)) {
   let parsed;
   try {
-    parsed = parseArgs15(argv);
+    parsed = parseArgs16(argv);
     requireExistingInputPaths(parsed.inputPaths);
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
@@ -29701,7 +30453,7 @@ async function runSvgCli(argv = process.argv.slice(2)) {
   for (const [index, scriptPath] of parsed.inputPaths.entries()) {
     printBatchHeader(scriptPath, index, parsed.inputPaths.length);
     try {
-      await exportSvgInput(scriptPath, parsed.outputPath);
+      await exportSvgInput(scriptPath, parsed.outputPath, parsed.paramOverrides);
     } catch (error) {
       failures += 1;
       console.error(error instanceof Error ? error.message : String(error));
@@ -29711,7 +30463,7 @@ async function runSvgCli(argv = process.argv.slice(2)) {
     process.exit(1);
   }
 }
-async function exportSvgInput(scriptPath, explicitOutputPath) {
+async function exportSvgInput(scriptPath, explicitOutputPath, paramOverrides) {
   const outputPath = batchOutputPath(scriptPath, explicitOutputPath, defaultSvgOutput);
   if (resolve34(outputPath) === resolve34(scriptPath)) {
     throw new Error(`ERROR: output path would overwrite the input script. Specify an explicit output path.`);
@@ -29719,6 +30471,7 @@ async function exportSvgInput(scriptPath, explicitOutputPath) {
   const code = await readFile5(resolve34(scriptPath), "utf-8");
   const { allFiles, fileName } = collectProjectFiles(scriptPath);
   await init();
+  setParamOverrides(paramOverrides);
   const result = runScript(code, fileName, allFiles);
   if (result.error) {
     throw new Error(`Script error: ${result.error}`);
@@ -30145,9 +30898,10 @@ function buildUrdfRobotPackage(spec) {
 }
 
 // cli/forge-urdf.ts
-function parseArgs16(argv) {
+function parseArgs17(argv) {
   const inputPaths = [];
   let outputPath;
+  const paramOverrides = {};
   const jointOverrides = {};
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
@@ -30164,25 +30918,31 @@ function parseArgs16(argv) {
       i += 1;
       continue;
     }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
     if (arg.startsWith("--")) {
       throw new Error(`Unknown flag: ${arg}`);
     }
     inputPaths.push(arg);
   }
-  requireInputPaths(inputPaths, "Usage: forgecad export urdf <script.forge.js> [input ...] [--output dir] [--joint JointName=Value]");
+  requireInputPaths(
+    inputPaths,
+    "Usage: forgecad export urdf <script.forge.js> [input ...] [--output dir] [--param Key=Value] [--joint JointName=Value]"
+  );
   requireScriptInputPaths(inputPaths);
   requireSingleInputForOutputPath(inputPaths, outputPath, "--output", "dir");
-  return { inputPaths, outputPath, jointOverrides };
+  return { inputPaths, outputPath, paramOverrides, jointOverrides };
 }
 function defaultOutputPath10(scriptPath) {
   const abs = resolve35(scriptPath);
   return abs.slice(0, abs.length - extname11(abs).length) + ".urdfpkg";
 }
 function resolveSimulationModel4(result, jointOverrides) {
-  const legacy = getCollectedRobotExport();
-  if (legacy) {
-    return { ...legacy, state: { ...legacy.state, ...jointOverrides } };
-  }
   const assembly2 = getRunResultAssemblySource(result);
   if (!assembly2) return null;
   const def = assembly2.describe();
@@ -30190,13 +30950,13 @@ function resolveSimulationModel4(result, jointOverrides) {
   return collectSimulationModel(def, { state: jointOverrides });
 }
 async function runUrdfCli(argv = process.argv.slice(2)) {
-  const { inputPaths, outputPath, jointOverrides } = parseArgs16(argv);
+  const { inputPaths, outputPath, paramOverrides, jointOverrides } = parseArgs17(argv);
   requireExistingInputPaths(inputPaths);
   let failures = 0;
   for (const [index, scriptPath] of inputPaths.entries()) {
     printBatchHeader(scriptPath, index, inputPaths.length);
     try {
-      await exportUrdfInput(scriptPath, outputPath, jointOverrides);
+      await exportUrdfInput(scriptPath, outputPath, paramOverrides, jointOverrides);
     } catch (error) {
       failures += 1;
       console.error(error instanceof Error ? error.message : String(error));
@@ -30206,17 +30966,18 @@ async function runUrdfCli(argv = process.argv.slice(2)) {
     process.exit(1);
   }
 }
-async function exportUrdfInput(scriptPath, explicitOutputPath, jointOverrides) {
+async function exportUrdfInput(scriptPath, explicitOutputPath, paramOverrides, jointOverrides) {
   const code = readFileSync20(resolve35(scriptPath), "utf-8");
   const { allFiles, fileName } = collectProjectFiles(scriptPath);
   await init();
+  setParamOverrides(paramOverrides);
   const result = applyCliJointOverrides(runScript(code, fileName, allFiles, { assemblyState: jointOverrides }), jointOverrides);
   if (result.error) {
     throw new Error(`ERROR: ${result.error}`);
   }
   const robot = resolveSimulationModel4(result, jointOverrides);
   if (!robot) {
-    throw new Error("URDF export requires the script to return assembly(...).withSimulation(...) or call legacy robotExport({...}).");
+    throw new Error("URDF export requires the script to return assembly(...).withSimulation(...).");
   }
   const packageOut = buildUrdfRobotPackage(robot);
   const targetDir = resolve35(batchOutputPath(scriptPath, explicitOutputPath, defaultOutputPath10));
@@ -30777,9 +31538,10 @@ ${jointResults.map((result) => result.text).join("\n\n")}
 }
 
 // cli/forge-usd.ts
-function parseArgs17(argv) {
+function parseArgs18(argv) {
   const inputPaths = [];
   let outputPath;
+  const paramOverrides = {};
   const jointOverrides = {};
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
@@ -30796,21 +31558,29 @@ function parseArgs17(argv) {
       i += 1;
       continue;
     }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
     if (arg.startsWith("--")) throw new Error(`Unknown flag: ${arg}`);
     inputPaths.push(arg);
   }
-  requireInputPaths(inputPaths, "Usage: forgecad export usd <script.forge.js> [input ...] [--output dir] [--joint JointName=Value]");
+  requireInputPaths(
+    inputPaths,
+    "Usage: forgecad export usd <script.forge.js> [input ...] [--output dir] [--param Key=Value] [--joint JointName=Value]"
+  );
   requireScriptInputPaths(inputPaths);
   requireSingleInputForOutputPath(inputPaths, outputPath, "--output", "dir");
-  return { inputPaths, outputPath, jointOverrides };
+  return { inputPaths, outputPath, paramOverrides, jointOverrides };
 }
 function defaultOutputPath11(scriptPath) {
   const abs = resolve36(scriptPath);
   return abs.slice(0, abs.length - extname12(abs).length) + ".usdpkg";
 }
 function resolveSimulationModel5(result, jointOverrides) {
-  const legacy = getCollectedRobotExport();
-  if (legacy) return { ...legacy, state: { ...legacy.state, ...jointOverrides } };
   const assembly2 = getRunResultAssemblySource(result);
   if (!assembly2) return null;
   const def = assembly2.describe();
@@ -30818,13 +31588,13 @@ function resolveSimulationModel5(result, jointOverrides) {
   return collectSimulationModel(def, { state: jointOverrides });
 }
 async function runUsdCli(argv = process.argv.slice(2)) {
-  const { inputPaths, outputPath, jointOverrides } = parseArgs17(argv);
+  const { inputPaths, outputPath, paramOverrides, jointOverrides } = parseArgs18(argv);
   requireExistingInputPaths(inputPaths);
   let failures = 0;
   for (const [index, scriptPath] of inputPaths.entries()) {
     printBatchHeader(scriptPath, index, inputPaths.length);
     try {
-      await exportUsdInput(scriptPath, outputPath, jointOverrides);
+      await exportUsdInput(scriptPath, outputPath, paramOverrides, jointOverrides);
     } catch (error) {
       failures += 1;
       console.error(error instanceof Error ? error.message : String(error));
@@ -30834,17 +31604,18 @@ async function runUsdCli(argv = process.argv.slice(2)) {
     process.exit(1);
   }
 }
-async function exportUsdInput(scriptPath, explicitOutputPath, jointOverrides) {
+async function exportUsdInput(scriptPath, explicitOutputPath, paramOverrides, jointOverrides) {
   const code = readFileSync21(resolve36(scriptPath), "utf-8");
   const { allFiles, fileName } = collectProjectFiles(scriptPath);
   await init();
+  setParamOverrides(paramOverrides);
   const result = applyCliJointOverrides(runScript(code, fileName, allFiles, { assemblyState: jointOverrides }), jointOverrides);
   if (result.error) {
     throw new Error(`ERROR: ${result.error}`);
   }
   const model = resolveSimulationModel5(result, jointOverrides);
   if (!model) {
-    throw new Error("USD export requires the script to return assembly(...).withSimulation(...) or call legacy robotExport({...}).");
+    throw new Error("USD export requires the script to return assembly(...).withSimulation(...).");
   }
   const packageOut = buildUsdRobotPackage(model);
   const targetDir = resolve36(batchOutputPath(scriptPath, explicitOutputPath, defaultOutputPath11));
@@ -30886,9 +31657,9 @@ function parseWebArgs(argv) {
   return options;
 }
 function waitForExit2(child) {
-  return new Promise((resolve44, reject) => {
+  return new Promise((resolve46, reject) => {
     child.once("error", reject);
-    child.once("exit", (code) => resolve44(code ?? 0));
+    child.once("exit", (code) => resolve46(code ?? 0));
   });
 }
 async function runWebCli(argv = process.argv.slice(2)) {
@@ -31502,10 +32273,10 @@ function padRight(s, w) {
 }
 function confirm(question) {
   const rl = createInterface2({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve44) => {
+  return new Promise((resolve46) => {
     rl.question(`${question} [y/N] `, (answer) => {
       rl.close();
-      resolve44(answer.trim().toLowerCase() === "y");
+      resolve46(answer.trim().toLowerCase() === "y");
     });
   });
 }
@@ -31515,10 +32286,10 @@ function moveCandidateReasonLabel(candidate) {
 }
 function promptChoice(question) {
   const rl = createInterface2({ input: process.stdin, output: process.stderr });
-  return new Promise((resolve44) => {
+  return new Promise((resolve46) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve44(answer.trim());
+      resolve46(answer.trim());
     });
   });
 }
@@ -33440,7 +34211,7 @@ function takeValue(argv, index, name) {
   }
   return value;
 }
-function parseArgs18(argv) {
+function parseArgs19(argv) {
   const { consumed: focusConsumed } = parseFocusFlags(argv);
   const consumed = new Set(focusConsumed);
   const profileOverrides = {};
@@ -33619,7 +34390,7 @@ function scriptErrorReport(scriptPath, message, profile, elapsedMs) {
   };
 }
 async function runPrintCheckCli(argv = process.argv.slice(2)) {
-  const args = parseArgs18(argv);
+  const args = parseArgs19(argv);
   requireExistingInputPaths(args.inputPaths);
   const profile = resolvePrintProfile(args.profileId, args.profileOverrides);
   const reports = [];
@@ -33687,12 +34458,1481 @@ async function runPrintCheckInput(args, scriptPath, profile, argv) {
   return report;
 }
 
+// cli/forge-pinocchio.ts
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync25, writeFileSync as writeFileSync20 } from "fs";
+import { dirname as dirname13, extname as extname13, resolve as resolve41 } from "path";
+
+// src/forge/export/pinocchioExport.ts
+var DEG2RAD = Math.PI / 180;
+function defaultRange(type) {
+  return type === "prismatic" ? { min: 0, max: 0.1 } : { min: -Math.PI / 2, max: Math.PI / 2 };
+}
+function toModelUnits(type, value) {
+  return type === "prismatic" ? value * 1e-3 : value * DEG2RAD;
+}
+function buildPinocchioPackage(spec) {
+  const urdf = buildUrdfRobotPackage(spec);
+  const assemblyJoints = new Map(spec.assembly.joints.map((j) => [j.name, j]));
+  const actuated = urdf.manifest.joints.filter((j) => j.type === "revolute" || j.type === "prismatic");
+  if (actuated.length === 0) {
+    throw new Error("PINOCCHIO.MOTION.EMPTY: the assembly has no revolute or prismatic joints to drive.");
+  }
+  const joints = actuated.map((j) => {
+    const source = assemblyJoints.get(j.sourceName);
+    const range = source && source.min !== void 0 && source.max !== void 0 ? { min: toModelUnits(j.type, source.min), max: toModelUnits(j.type, source.max) } : defaultRange(j.type);
+    const effort = spec.joints[j.sourceName]?.effort;
+    return {
+      sourceName: j.sourceName,
+      urdfName: j.urdfName,
+      type: j.type,
+      min: range.min,
+      max: range.max,
+      samples: 17,
+      budget: typeof effort === "number" && effort > 0 ? effort : null
+    };
+  });
+  const manifest = {
+    format: "forgecad-pinocchio-package",
+    modelName: urdf.modelName,
+    sourceModelName: spec.modelName,
+    urdfPath: urdf.manifest.urdfPath,
+    feedbackPath: "feedback.json",
+    expectedDof: actuated.length,
+    gravity: [0, 0, -9.80665],
+    joints,
+    install: {
+      linuxMac: "uv run --python 3.11 --with pin --with numpy python scripts/run_pinocchio.py",
+      windows: "conda install pinocchio coal -c conda-forge  # then: python scripts/run_pinocchio.py"
+    },
+    runCommand: "uv run --python 3.11 --with pin --with numpy python scripts/run_pinocchio.py"
+  };
+  const files = [
+    ...urdf.files,
+    { path: "pinocchio-manifest.json", text: JSON.stringify(manifest, null, 2) },
+    { path: "scripts/run_pinocchio.py", text: runPinocchioScript() },
+    { path: "README.md", text: readme(manifest) }
+  ];
+  return { modelName: urdf.modelName, manifest, files };
+}
+function readme(manifest) {
+  return [
+    `# ${manifest.sourceModelName} \u2014 Pinocchio package`,
+    "",
+    "Generated by ForgeCAD. The model is a standard URDF with per-link inertials computed from the",
+    "solid geometry; Pinocchio (BSD-2-Clause) builds its dynamics model from it.",
+    "",
+    "## Run",
+    "",
+    "Linux / macOS:",
+    "",
+    "```bash",
+    manifest.install.linuxMac,
+    "```",
+    "",
+    "Windows (no PyPI wheel \u2014 use conda-forge):",
+    "",
+    "```bash",
+    manifest.install.windows,
+    "```",
+    "",
+    "`run_pinocchio.py` sweeps each joint across its range, computes the gravity-hold torque with",
+    "`pin.computeGeneralizedGravity`, and writes `feedback.json` (the `forgecad.feedback/v1` contract).",
+    "Re-surface it in ForgeCAD with `forgecad sim dynamics <this-dir>`.",
+    "",
+    "Coal (BSD-3-Clause) provides collision via convex hulls / BVH over `.obj`/`.stl`/`.dae` meshes;",
+    "it performs no convex decomposition. This package ships visual + collision STLs from the URDF export.",
+    "",
+    "Cross-check: the gravity torque at pose 0 should match `forgecad sim mechanism` static-hold torque."
+  ].join("\n");
+}
+function runPinocchioScript() {
+  return `#!/usr/bin/env python3
+"""Compute per-joint gravity-hold torque budgets with Pinocchio and emit feedback.json."""
+import json
+import os
+import sys
+
+import numpy as np
+
+try:
+    import pinocchio as pin
+except ImportError:
+    raise SystemExit(
+        "Pinocchio not found. Linux/macOS: pip install pin coal. "
+        "Windows: conda install pinocchio coal -c conda-forge."
+    )
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(HERE)
+manifest = json.load(open(os.path.join(ROOT, "pinocchio-manifest.json")))
+
+model = pin.buildModelFromUrdf(os.path.join(ROOT, manifest["urdfPath"]))
+data = model.createData()
+model.gravity.linear = np.array(manifest["gravity"], dtype=float)
+
+metrics = [{"key": "dofCount", "label": "DOF (model.nv)", "value": int(model.nv), "unit": "", "status": "info"}]
+findings = []
+joint_data = []
+
+for spec in manifest["joints"]:
+    if not model.existJointName(spec["urdfName"]):
+        findings.append({"level": "warning", "code": "PINOCCHIO.JOINT.MISSING",
+                         "message": "URDF joint %s not found in the built model" % spec["urdfName"],
+                         "path": spec["sourceName"]})
+        continue
+    jid = model.getJointId(spec["urdfName"])
+    iq = model.joints[jid].idx_q
+    iv = model.joints[jid].idx_v
+    peak = 0.0
+    for value in np.linspace(spec["min"], spec["max"], int(spec["samples"])):
+        q = pin.neutral(model)
+        q[iq] = value
+        g = pin.computeGeneralizedGravity(model, data, q)
+        peak = max(peak, abs(float(g[iv])))
+    is_revolute = spec["type"] == "revolute"
+    unit = "N\xB7m" if is_revolute else "N"
+    key = ("peakGravityTorqueNm." if is_revolute else "peakGravityForceN.") + spec["sourceName"]
+    metrics.append({"key": key, "label": "Peak gravity load (%s)" % spec["sourceName"],
+                    "value": round(peak, 4), "unit": unit, "status": "info"})
+    entry = {"joint": spec["sourceName"], "type": spec["type"], "peak": round(peak, 4), "budget": spec["budget"]}
+    if spec["budget"]:
+        margin = (spec["budget"] - peak) / spec["budget"] * 100.0
+        entry["marginPct"] = round(margin, 2)
+        metrics.append({"key": "torqueMarginPct." + spec["sourceName"], "label": "Budget margin (%s)" % spec["sourceName"],
+                        "value": round(margin, 2), "unit": "%", "status": "pass" if margin >= 0 else "fail",
+                        "target": {"op": ">=", "value": 0}})
+        if margin < 0:
+            findings.append({"level": "error", "code": "PINOCCHIO.HOLD.OVER_BUDGET", "path": spec["sourceName"],
+                             "message": "Joint %s peaks at %.3f %s over its %.3f %s budget" % (
+                                 spec["sourceName"], peak, unit, spec["budget"], unit),
+                             "suggest": "Increase the Sim.drive effort or reduce the distal moment."})
+    joint_data.append(entry)
+
+ok = all(m.get("status") != "fail" for m in metrics) and not any(f["level"] == "error" for f in findings)
+report = {
+    "schema": "forgecad.feedback/v1", "category": "dynamics", "source": manifest["sourceModelName"], "ok": ok,
+    "summary": "%d DOF, %d joint(s) swept" % (model.nv, len(joint_data)),
+    "metrics": metrics, "findings": findings,
+    "trust": {"assumptions": ["Pinocchio gravity-hold torque swept over joint ranges; no contact or friction."],
+              "converged": True},
+    "data": {"dof": int(model.nv), "joints": joint_data}, "timeMs": 0,
+}
+out = os.path.join(ROOT, manifest["feedbackPath"])
+json.dump(report, open(out, "w"), indent=2)
+print("Wrote %s (ok=%s)" % (out, ok))
+sys.exit(0 if ok else 1)
+`;
+}
+
+// cli/forge-pinocchio.ts
+function parseArgs20(argv) {
+  const inputPaths = [];
+  let outputPath;
+  const paramOverrides = {};
+  const jointOverrides = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--output") {
+      outputPath = argv[i + 1];
+      if (!outputPath) throw new Error("--output requires a directory path");
+      i += 1;
+      continue;
+    }
+    if (arg === "--joint") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error("--joint requires JointName=Value");
+      addCliJointOverride(value, jointOverrides);
+      i += 1;
+      continue;
+    }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--")) throw new Error(`Unknown flag: ${arg}`);
+    inputPaths.push(arg);
+  }
+  requireInputPaths(inputPaths, "Usage: forgecad export pinocchio <script.forge.js> [input ...] [--output dir] [--param Key=Value] [--joint JointName=Value]");
+  requireScriptInputPaths(inputPaths);
+  requireSingleInputForOutputPath(inputPaths, outputPath, "--output", "dir");
+  return { inputPaths, outputPath, paramOverrides, jointOverrides };
+}
+function defaultOutputPath12(scriptPath) {
+  const abs = resolve41(scriptPath);
+  return abs.slice(0, abs.length - extname13(abs).length) + ".pinocchiopkg";
+}
+function resolveSimulationModel6(result, jointOverrides) {
+  const assembly2 = getRunResultAssemblySource(result);
+  if (!assembly2) return null;
+  const def = assembly2.describe();
+  if (!def.sim) return null;
+  return collectSimulationModel(def, { state: jointOverrides });
+}
+async function runPinocchioCli(argv = process.argv.slice(2)) {
+  const { inputPaths, outputPath, paramOverrides, jointOverrides } = parseArgs20(argv);
+  requireExistingInputPaths(inputPaths);
+  let failures = 0;
+  for (const [index, scriptPath] of inputPaths.entries()) {
+    printBatchHeader(scriptPath, index, inputPaths.length);
+    try {
+      await exportPinocchioInput(scriptPath, outputPath, paramOverrides, jointOverrides);
+    } catch (error) {
+      failures += 1;
+      console.error(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (failures > 0) process.exit(1);
+}
+async function exportPinocchioInput(scriptPath, explicitOutputPath, paramOverrides, jointOverrides) {
+  const code = readFileSync25(resolve41(scriptPath), "utf-8");
+  const { allFiles, fileName } = collectProjectFiles(scriptPath);
+  await init();
+  setParamOverrides(paramOverrides);
+  const result = applyCliJointOverrides(runScript(code, fileName, allFiles, { assemblyState: jointOverrides }), jointOverrides);
+  if (result.error) throw new Error(`ERROR: ${result.error}`);
+  const robot = resolveSimulationModel6(result, jointOverrides);
+  if (!robot) throw new Error("Pinocchio export requires the script to return assembly(...).withSimulation(...).");
+  const packageOut = buildPinocchioPackage(robot);
+  const targetDir = resolve41(batchOutputPath(scriptPath, explicitOutputPath, defaultOutputPath12));
+  packageOut.files.forEach((file) => {
+    const absPath = resolve41(targetDir, file.path);
+    mkdirSync13(dirname13(absPath), { recursive: true });
+    if (file.text !== void 0) writeFileSync20(absPath, file.text, "utf-8");
+    else if (file.bytes) writeFileSync20(absPath, Buffer.from(file.bytes));
+  });
+  console.log(`\u2713 Exported Pinocchio package to ${targetDir}`);
+  console.log(`  urdf: ${packageOut.manifest.urdfPath}`);
+  console.log(`  run:  ${packageOut.manifest.runCommand}`);
+  console.log(`  then: forgecad sim dynamics ${targetDir}`);
+}
+
+// cli/sim-dynamics.ts
+import { existsSync as existsSync21, readFileSync as readFileSync26, statSync as statSync9 } from "fs";
+import { join as join15, resolve as resolve42 } from "path";
+function parseArgs21(argv) {
+  const inputPaths = [];
+  let json = false;
+  let compact = false;
+  let noFailExit = false;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--compact") {
+      compact = true;
+      continue;
+    }
+    if (arg === "--no-fail-exit") {
+      noFailExit = true;
+      continue;
+    }
+    if (arg.startsWith("--")) throw new Error(`Unknown flag: ${arg}`);
+    inputPaths.push(arg);
+  }
+  requireInputPaths(inputPaths, "Usage: forgecad sim dynamics <pinocchio-package-dir|feedback.json> [--json]");
+  return { inputPaths, json, compact, noFailExit };
+}
+function failedReport3(source, message, code, suggest) {
+  return {
+    schema: FEEDBACK_SCHEMA,
+    category: "dynamics",
+    source,
+    ok: false,
+    summary: "dynamics results unavailable",
+    metrics: [],
+    findings: [{ level: "error", code, message, ...suggest ? { suggest } : {} }],
+    trust: { assumptions: [] },
+    data: {},
+    timeMs: 0
+  };
+}
+function resolveFeedbackPath(inputPath) {
+  const abs = resolve42(inputPath);
+  if (existsSync21(abs) && statSync9(abs).isDirectory()) return join15(abs, "feedback.json");
+  return abs;
+}
+function ingest(inputPath) {
+  const feedbackPath = resolveFeedbackPath(inputPath);
+  if (!existsSync21(feedbackPath)) {
+    return failedReport3(
+      inputPath,
+      `No results at ${feedbackPath}.`,
+      "DYNAMICS.NOT_RUN",
+      "Run the exported scripts/run_pinocchio.py first (see the package README), then re-run sim dynamics."
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync26(feedbackPath, "utf-8"));
+  } catch (error) {
+    return failedReport3(inputPath, `Could not parse ${feedbackPath}: ${error instanceof Error ? error.message : String(error)}`, "DYNAMICS.PARSE_ERROR");
+  }
+  const report = parsed;
+  if (!report || report.schema !== FEEDBACK_SCHEMA || !Array.isArray(report.metrics)) {
+    return failedReport3(
+      inputPath,
+      `${feedbackPath} is not a ${FEEDBACK_SCHEMA} report.`,
+      "DYNAMICS.BAD_SCHEMA",
+      "Regenerate it with the exported run_pinocchio.py."
+    );
+  }
+  return { ...report, source: inputPath };
+}
+async function runSimDynamicsCli(argv = process.argv.slice(2)) {
+  const options = parseArgs21(argv);
+  const reports = options.inputPaths.map((inputPath) => ingest(inputPath));
+  printFeedback(reports.length === 1 ? reports[0] : { runs: reports }, options.json, options.compact);
+  if (reports.some((report) => !report.ok) && !options.noFailExit) process.exitCode = 1;
+}
+
+// cli/sim-mass.ts
+var DEFAULT_DENSITY_KG_M35 = 1e3;
+function parseArgs22(argv) {
+  const inputPaths = [];
+  const paramOverrides = {};
+  const jointOverrides = {};
+  let json = false;
+  let compact = false;
+  let densityKgM3 = null;
+  let backend;
+  let quality;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--compact") {
+      compact = true;
+      continue;
+    }
+    if (arg === "--density") {
+      const value = Number(argv[i + 1]);
+      if (!Number.isFinite(value) || value <= 0) throw new Error("--density requires a positive number (kg/m\xB3)");
+      densityKgM3 = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--quality" || arg === "-q") {
+      const val = argv[i + 1];
+      if (val !== "default" && val !== "live" && val !== "high") throw new Error("--quality must be default, live, or high");
+      quality = val;
+      i += 1;
+      continue;
+    }
+    if (arg === "--backend") {
+      const val = argv[i + 1];
+      if (val !== "manifold" && val !== "occt" && val !== "truck" && val !== "sdf") {
+        throw new Error("--backend must be manifold, occt, truck, or sdf");
+      }
+      backend = val;
+      i += 1;
+      continue;
+    }
+    if (arg === "--joint") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error("--joint requires JointName=Value");
+      addCliJointOverride(value, jointOverrides);
+      i += 1;
+      continue;
+    }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--")) throw new Error(`Unknown flag: ${arg}`);
+    inputPaths.push(arg);
+  }
+  requireInputPaths(
+    inputPaths,
+    "Usage: forgecad sim mass <model.forge.js> [input ...] [--density kg/m3] [--json] [--param Key=Value] [--joint JointName=Value]"
+  );
+  requireScriptInputPaths(inputPaths);
+  return { inputPaths, json, compact, densityKgM3, backend, quality, paramOverrides, jointOverrides };
+}
+function failedReport4(source, message, code = "MASS.ERROR") {
+  return {
+    schema: FEEDBACK_SCHEMA,
+    category: "mass-properties",
+    source,
+    ok: false,
+    summary: "mass-properties analysis failed",
+    metrics: [],
+    findings: [{ level: "error", code, message }],
+    trust: { assumptions: [] },
+    data: {},
+    timeMs: 0
+  };
+}
+function round4(value, digits = 6) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+function analyze2(source, options, objects) {
+  const start = Date.now();
+  const density = options.densityKgM3 ?? DEFAULT_DENSITY_KG_M35;
+  const props = analyzeMassProperties(objects.map((o) => ({ name: o.name, mesh: o.mesh, densityKgM3: density })));
+  const findings = [];
+  const assumptions = [
+    "Mass properties integrated from the triangulated mesh (exact for the mesh; curved features carry tessellation error).",
+    "Manifold kernel meshes are watertight by construction."
+  ];
+  if (options.densityKgM3 === null) {
+    findings.push({
+      level: "warning",
+      code: "MASS.DENSITY.DEFAULTED",
+      message: `No density given; using default ${DEFAULT_DENSITY_KG_M35} kg/m\xB3 (water). Volume, center of mass, and principal axes are exact regardless.`,
+      suggest: "Pass --density <kg/m3> (e.g. 2700 aluminium, 7850 steel, 1240 ABS) for accurate mass and inertia magnitude."
+    });
+    assumptions.push(`uniform density ${DEFAULT_DENSITY_KG_M35} kg/m\xB3 (default)`);
+  } else {
+    assumptions.push(`uniform density ${density} kg/m\xB3`);
+  }
+  const metrics = [
+    makeMetric("totalMassKg", "Total mass", round4(props.totalMassKg, 6), { unit: "kg" }),
+    makeMetric("totalVolumeCm3", "Volume", round4(props.totalVolumeMm3 / 1e3, 4), { unit: "cm\xB3" }),
+    makeMetric("surfaceAreaCm2", "Surface area", round4(props.surfaceAreaMm2 / 100, 4), { unit: "cm\xB2" }),
+    makeMetric("comXmm", "Center of mass X", round4(props.centerOfMassMm[0], 4), { unit: "mm" }),
+    makeMetric("comYmm", "Center of mass Y", round4(props.centerOfMassMm[1], 4), { unit: "mm" }),
+    makeMetric("comZmm", "Center of mass Z", round4(props.centerOfMassMm[2], 4), { unit: "mm" }),
+    makeMetric("principalI1", "Principal moment I1", round4(props.principalMomentsKgM2[0], 9), { unit: "kg\xB7m\xB2" }),
+    makeMetric("principalI2", "Principal moment I2", round4(props.principalMomentsKgM2[1], 9), { unit: "kg\xB7m\xB2" }),
+    makeMetric("principalI3", "Principal moment I3", round4(props.principalMomentsKgM2[2], 9), { unit: "kg\xB7m\xB2" })
+  ];
+  return {
+    schema: FEEDBACK_SCHEMA,
+    category: "mass-properties",
+    source,
+    ok: reportOk(metrics, findings),
+    summary: `mass ${round4(props.totalMassKg, 4)} kg \xB7 volume ${round4(props.totalVolumeMm3 / 1e3, 2)} cm\xB3 \xB7 CoM (${round4(
+      props.centerOfMassMm[0],
+      2
+    )}, ${round4(props.centerOfMassMm[1], 2)}, ${round4(props.centerOfMassMm[2], 2)}) mm`,
+    metrics,
+    findings,
+    trust: { assumptions, watertight: true },
+    data: {
+      densityKgM3: density,
+      totalVolumeMm3: round4(props.totalVolumeMm3, 4),
+      totalMassKg: round4(props.totalMassKg, 6),
+      centerOfMassMm: props.centerOfMassMm.map((v) => round4(v, 4)),
+      inertiaTensorKgM2: {
+        ixx: round4(props.inertiaTensorKgM2.ixx, 9),
+        iyy: round4(props.inertiaTensorKgM2.iyy, 9),
+        izz: round4(props.inertiaTensorKgM2.izz, 9),
+        ixy: round4(props.inertiaTensorKgM2.ixy, 9),
+        ixz: round4(props.inertiaTensorKgM2.ixz, 9),
+        iyz: round4(props.inertiaTensorKgM2.iyz, 9)
+      },
+      principalMomentsKgM2: props.principalMomentsKgM2.map((v) => round4(v, 9)),
+      principalAxes: props.principalAxes.map((axis) => axis.map((v) => round4(v, 6))),
+      radiusOfGyrationM: props.radiusOfGyrationM.map((v) => round4(v, 6)),
+      boundingBoxMm: {
+        minMm: props.boundingBoxMm.minMm.map((v) => round4(v, 4)),
+        maxMm: props.boundingBoxMm.maxMm.map((v) => round4(v, 4)),
+        sizeMm: props.boundingBoxMm.sizeMm.map((v) => round4(v, 4))
+      },
+      perObject: props.perObject.map((o) => ({
+        name: o.name,
+        volumeMm3: round4(o.volumeMm3, 4),
+        massKg: round4(o.massKg, 6),
+        centerOfMassMm: o.centerOfMassMm.map((v) => round4(v, 4))
+      }))
+    },
+    timeMs: Date.now() - start
+  };
+}
+async function runSimMassCli(argv = process.argv.slice(2)) {
+  const options = parseArgs22(argv);
+  requireExistingInputPaths(options.inputPaths);
+  await init();
+  const reports = [];
+  for (const [index, scriptPath] of options.inputPaths.entries()) {
+    if (!options.json) printBatchHeader(scriptPath, index, options.inputPaths.length);
+    let report;
+    try {
+      const { objects, error } = await loadAnalysisObjects(scriptPath, {
+        backend: options.backend,
+        quality: options.quality,
+        paramOverrides: options.paramOverrides,
+        jointOverrides: options.jointOverrides
+      });
+      report = error ? failedReport4(scriptPath, error, "MASS.MODEL.EMPTY") : analyze2(scriptPath, options, objects);
+    } catch (error) {
+      report = failedReport4(scriptPath, error instanceof Error ? error.message : String(error));
+    }
+    reports.push(report);
+  }
+  printFeedback(reports.length === 1 ? reports[0] : { runs: reports }, options.json, options.compact);
+  if (reports.some((report) => !report.ok)) process.exitCode = 1;
+}
+
+// src/forge/analysis/mechanism.ts
+var GRAVITY_MS2 = 9.80665;
+var DEFAULT_GRAVITY = [0, 0, -GRAVITY_MS2];
+function cross7(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+function dot5(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function normalize4(v) {
+  const len = Math.hypot(v[0], v[1], v[2]);
+  if (len < 1e-12) throw new Error("mechanism joint axis has zero length");
+  return [v[0] / len, v[1] / len, v[2] / len];
+}
+function freedoms(type) {
+  return type === "fixed" ? 0 : 1;
+}
+function distalLinks(jointChild, childrenOf) {
+  const names = /* @__PURE__ */ new Set();
+  let cycle = false;
+  const stack = [jointChild];
+  while (stack.length > 0) {
+    const link = stack.pop();
+    if (names.has(link)) {
+      cycle = true;
+      continue;
+    }
+    names.add(link);
+    for (const j of childrenOf.get(link) ?? []) stack.push(j.child);
+  }
+  return { names, cycle };
+}
+function analyzeMechanism(input) {
+  const { links, joints } = input;
+  if (links.length === 0) throw new Error("mechanism analysis needs at least one link");
+  const gravity = input.gravity ?? DEFAULT_GRAVITY;
+  const couplings = input.couplings ?? 0;
+  const linkByName = new Map(links.map((l) => [l.name, l]));
+  for (const j of joints) {
+    if (!linkByName.has(j.parent)) throw new Error(`joint "${j.name}" references unknown parent link "${j.parent}"`);
+    if (!linkByName.has(j.child)) throw new Error(`joint "${j.name}" references unknown child link "${j.child}"`);
+  }
+  const childrenOf = /* @__PURE__ */ new Map();
+  for (const j of joints) {
+    if (!childrenOf.has(j.parent)) childrenOf.set(j.parent, []);
+    childrenOf.get(j.parent).push(j);
+  }
+  const freedomSum = joints.reduce((sum2, j) => sum2 + freedoms(j.type), 0);
+  const actuatedJointCount = joints.filter((j) => j.type !== "fixed").length;
+  const fixedJointCount = joints.length - actuatedJointCount;
+  const hasClosedLoops = joints.length > links.length - 1;
+  const actuatedDof = freedomSum - couplings;
+  const grueblerSpatial = 6 * (links.length - 1 - joints.length) + freedomSum - couplings;
+  const totalMassKg = links.reduce((sum2, l) => sum2 + l.massKg, 0);
+  const jointLoads = [];
+  for (const joint2 of joints) {
+    if (joint2.type === "fixed") continue;
+    const { names } = distalLinks(joint2.child, childrenOf);
+    let mass = 0;
+    const weightedCom = [0, 0, 0];
+    for (const name of names) {
+      const link = linkByName.get(name);
+      mass += link.massKg;
+      weightedCom[0] += link.massKg * link.comWorldMm[0];
+      weightedCom[1] += link.massKg * link.comWorldMm[1];
+      weightedCom[2] += link.massKg * link.comWorldMm[2];
+    }
+    const com = mass > 0 ? [weightedCom[0] / mass, weightedCom[1] / mass, weightedCom[2] / mass] : [...joint2.pointWorldMm];
+    const axis = normalize4(joint2.axisWorld);
+    const force = [mass * gravity[0], mass * gravity[1], mass * gravity[2]];
+    const load = { joint: joint2.name, type: joint2.type, distalMassKg: mass, distalComWorldMm: com, marginPct: null };
+    if (joint2.type === "revolute") {
+      const r = [(com[0] - joint2.pointWorldMm[0]) / 1e3, (com[1] - joint2.pointWorldMm[1]) / 1e3, (com[2] - joint2.pointWorldMm[2]) / 1e3];
+      load.holdTorqueNm = Math.abs(dot5(axis, cross7(r, force)));
+      if (joint2.effort !== void 0 && joint2.effort > 0) {
+        load.budget = joint2.effort;
+        load.marginPct = (joint2.effort - load.holdTorqueNm) / joint2.effort * 100;
+      }
+    } else {
+      load.holdForceN = Math.abs(dot5(force, axis));
+      if (joint2.effort !== void 0 && joint2.effort > 0) {
+        load.budget = joint2.effort;
+        load.marginPct = (joint2.effort - load.holdForceN) / joint2.effort * 100;
+      }
+    }
+    jointLoads.push(load);
+  }
+  return {
+    linkCount: links.length,
+    jointCount: joints.length,
+    actuatedJointCount,
+    fixedJointCount,
+    couplings,
+    hasClosedLoops,
+    actuatedDof,
+    grueblerSpatial,
+    gravity,
+    totalMassKg,
+    jointLoads
+  };
+}
+
+// cli/sim-mechanism.ts
+var DEFAULT_DENSITY_KG_M36 = 1e3;
+function parseArgs23(argv) {
+  const inputPaths = [];
+  const paramOverrides = {};
+  const jointOverrides = {};
+  let json = false;
+  let compact = false;
+  let minTorqueMarginPct = 0;
+  let densityKgM3 = DEFAULT_DENSITY_KG_M36;
+  let noFailExit = false;
+  let backend;
+  let quality;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--compact") {
+      compact = true;
+      continue;
+    }
+    if (arg === "--no-fail-exit") {
+      noFailExit = true;
+      continue;
+    }
+    if (arg === "--min-torque-margin-pct") {
+      const n = Number(argv[++i]);
+      if (!Number.isFinite(n)) throw new Error("--min-torque-margin-pct requires a number");
+      minTorqueMarginPct = n;
+      continue;
+    }
+    if (arg === "--density") {
+      const n = Number(argv[++i]);
+      if (!Number.isFinite(n) || n <= 0) throw new Error("--density requires a positive number (kg/m\xB3)");
+      densityKgM3 = n;
+      continue;
+    }
+    if (arg === "--quality" || arg === "-q") {
+      const v = argv[i + 1];
+      if (v !== "default" && v !== "live" && v !== "high") throw new Error("--quality must be default, live, or high");
+      quality = v;
+      i += 1;
+      continue;
+    }
+    if (arg === "--backend") {
+      const v = argv[i + 1];
+      if (v !== "manifold" && v !== "occt" && v !== "truck" && v !== "sdf") throw new Error("--backend must be manifold, occt, truck, or sdf");
+      backend = v;
+      i += 1;
+      continue;
+    }
+    if (arg === "--joint") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error("--joint requires JointName=Value");
+      addCliJointOverride(value, jointOverrides);
+      i += 1;
+      continue;
+    }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--")) throw new Error(`Unknown flag: ${arg}`);
+    inputPaths.push(arg);
+  }
+  requireInputPaths(inputPaths, "Usage: forgecad sim mechanism <model.forge.js> [--min-torque-margin-pct N] [--json]");
+  requireScriptInputPaths(inputPaths);
+  return { inputPaths, json, compact, minTorqueMarginPct, densityKgM3, noFailExit, backend, quality, paramOverrides, jointOverrides };
+}
+function failedReport5(source, message, code = "MECHANISM.ERROR", suggest) {
+  return {
+    schema: FEEDBACK_SCHEMA,
+    category: "mechanism",
+    source,
+    ok: false,
+    summary: "mechanism analysis failed",
+    metrics: [],
+    findings: [{ level: "error", code, message, ...suggest ? { suggest } : {} }],
+    trust: { assumptions: [] },
+    data: {},
+    timeMs: 0
+  };
+}
+function round5(value, digits = 4) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+function flattenShapes(part, out) {
+  if (part instanceof Shape) out.push(part);
+  else if (part instanceof ShapeGroup) part.children.forEach((child) => flattenShapes(child, out));
+}
+async function runSimMechanismCli(argv = process.argv.slice(2)) {
+  const options = parseArgs23(argv);
+  requireExistingInputPaths(options.inputPaths);
+  await init();
+  const reports = [];
+  for (const [index, scriptPath] of options.inputPaths.entries()) {
+    if (!options.json) printBatchHeader(scriptPath, index, options.inputPaths.length);
+    let report;
+    try {
+      report = analyze3(scriptPath, options, await loadAnalysisObjectsWithAssembly(scriptPath, options));
+    } catch (error) {
+      report = failedReport5(scriptPath, error instanceof Error ? error.message : String(error));
+    }
+    reports.push(report);
+  }
+  printFeedback(reports.length === 1 ? reports[0] : { runs: reports }, options.json, options.compact);
+  if (reports.some((report) => !report.ok) && !options.noFailExit) process.exitCode = 1;
+}
+function analyze3(source, options, loaded) {
+  const start = Date.now();
+  if (loaded.error) return failedReport5(source, loaded.error, "MECHANISM.MODEL.EMPTY");
+  if (!loaded.assembly || !loaded.runResult) {
+    return failedReport5(
+      source,
+      "Model must return an assembly(...) with joints.",
+      "MECHANISM.NO_ASSEMBLY",
+      'Build the mechanism with assembly(...).addPart(...).connect(..., { type: "revolute" }).'
+    );
+  }
+  const assembly2 = loaded.assembly;
+  const def = assembly2.describe();
+  if (def.joints.length === 0) {
+    return failedReport5(source, "Assembly has no joints to analyze.", "MECHANISM.NO_JOINTS");
+  }
+  const simModel = collectSimulationModel(def, { state: options.jointOverrides });
+  const solved = assembly2.solve(options.jointOverrides);
+  const warnings = [];
+  const worldTransform = (partName) => {
+    try {
+      return solved.getTransform(partName);
+    } catch {
+      return null;
+    }
+  };
+  const links = [];
+  for (const part of def.parts) {
+    const shapes = [];
+    flattenShapes(part.part, shapes);
+    let volumeMm3 = 0;
+    let localCom = [0, 0, 0];
+    if (shapes.length > 0) {
+      const mp = analyzeMassProperties(shapes.map((shape, i) => ({ name: `${part.name}#${i}`, mesh: shape.getMesh(), densityKgM3: 1 })));
+      volumeMm3 = mp.totalVolumeMm3;
+      localCom = mp.centerOfMassMm;
+    }
+    const simLink = simModel.links[part.name];
+    const massKg = simLink?.massKg ?? (simLink?.densityKgM3 ?? options.densityKgM3) * volumeMm3 * 1e-9;
+    const transform = worldTransform(part.name);
+    const comWorldMm = transform ? transform.point(localCom) : localCom;
+    links.push({ name: part.name, massKg, comWorldMm });
+  }
+  const jointView = new Map((loaded.runResult.jointsView?.joints ?? []).map((j) => [j.name, j]));
+  const joints = [];
+  for (const dj of def.joints) {
+    if (dj.type === "fixed") {
+      joints.push({ name: dj.name, type: "fixed", parent: dj.parent, child: dj.child, axisWorld: [0, 0, 1], pointWorldMm: [0, 0, 0] });
+      continue;
+    }
+    const jv = jointView.get(dj.name);
+    const parentTransform = worldTransform(dj.parent);
+    if (!jv || !parentTransform) {
+      warnings.push({
+        level: "warning",
+        code: "MECHANISM.JOINT.UNRESOLVED",
+        path: dj.name,
+        message: `Could not resolve a world frame for joint "${dj.name}"; excluded from torque analysis.`
+      });
+      continue;
+    }
+    joints.push({
+      name: dj.name,
+      type: dj.type,
+      parent: dj.parent,
+      child: dj.child,
+      axisWorld: parentTransform.vector(jv.axis),
+      pointWorldMm: parentTransform.point(jv.pivot),
+      effort: simModel.joints[dj.name]?.effort ?? dj.effort
+    });
+  }
+  const result = analyzeMechanism({ links, joints, couplings: def.jointCouplings?.length ?? 0 });
+  const findings = [...warnings];
+  const metrics = [
+    makeMetric("actuatedDof", "Actuated DOF", result.actuatedDof, { unit: "" }),
+    makeMetric("totalMassKg", "Total mass", round5(result.totalMassKg, 6), { unit: "kg" })
+  ];
+  if (result.hasClosedLoops) {
+    findings.push({
+      level: "info",
+      code: "MECHANISM.CLOSED_LOOP",
+      message: `Graph has closed loops; actuatedDof counts joint freedoms and the spatial Gr\xFCbler mobility is ${result.grueblerSpatial}.`
+    });
+  }
+  for (const load of result.jointLoads) {
+    if (load.type === "revolute") {
+      metrics.push(makeMetric(`holdTorqueNm.${load.joint}`, `Hold torque (${load.joint})`, round5(load.holdTorqueNm ?? 0, 4), { unit: "N\xB7m" }));
+    } else {
+      metrics.push(makeMetric(`holdForceN.${load.joint}`, `Hold force (${load.joint})`, round5(load.holdForceN ?? 0, 4), { unit: "N" }));
+    }
+    if (load.marginPct !== null) {
+      const metric = makeMetric(`torqueMarginPct.${load.joint}`, `Budget margin (${load.joint})`, round5(load.marginPct, 2), {
+        unit: "%",
+        target: { op: ">=", value: options.minTorqueMarginPct }
+      });
+      metrics.push(metric);
+      if (load.marginPct < options.minTorqueMarginPct) {
+        const required = load.type === "revolute" ? `${round5(load.holdTorqueNm ?? 0, 3)} N\xB7m` : `${round5(load.holdForceN ?? 0, 3)} N`;
+        findings.push({
+          level: "error",
+          code: load.marginPct < 0 ? "MECHANISM.HOLD.OVER_BUDGET" : "MECHANISM.HOLD.LOW_MARGIN",
+          path: load.joint,
+          message: `Joint "${load.joint}" needs ${required} to hold its pose; budget margin ${round5(load.marginPct, 1)}% is below ${options.minTorqueMarginPct}%.`,
+          suggest: "Increase the Sim.drive effort, shorten the moment arm, or lighten the distal mass."
+        });
+      }
+    }
+  }
+  const assumptions = [
+    "Static gravity hold at the current pose; no dynamics, friction, or contact.",
+    "Per-link mass from Sim.body (massKg/density) when set, else uniform default density.",
+    "Joint world axes/pivots taken from the solved assembly pose."
+  ];
+  return {
+    schema: FEEDBACK_SCHEMA,
+    category: "mechanism",
+    source,
+    ok: reportOk(metrics, findings),
+    summary: `${result.actuatedDof} DOF \xB7 ${result.jointLoads.length} actuated joint(s) \xB7 total mass ${round5(result.totalMassKg, 3)} kg`,
+    metrics,
+    findings,
+    trust: { assumptions, watertight: true },
+    data: {
+      linkCount: result.linkCount,
+      jointCount: result.jointCount,
+      actuatedJointCount: result.actuatedJointCount,
+      fixedJointCount: result.fixedJointCount,
+      couplings: result.couplings,
+      hasClosedLoops: result.hasClosedLoops,
+      actuatedDof: result.actuatedDof,
+      grueblerSpatial: result.grueblerSpatial,
+      gravity: result.gravity,
+      totalMassKg: round5(result.totalMassKg, 6),
+      jointLoads: result.jointLoads.map((l) => ({
+        joint: l.joint,
+        type: l.type,
+        distalMassKg: round5(l.distalMassKg, 6),
+        distalComWorldMm: l.distalComWorldMm.map((v) => round5(v, 4)),
+        holdTorqueNm: l.holdTorqueNm === void 0 ? void 0 : round5(l.holdTorqueNm, 4),
+        holdForceN: l.holdForceN === void 0 ? void 0 : round5(l.holdForceN, 4),
+        budget: l.budget === void 0 ? void 0 : round5(l.budget, 4),
+        marginPct: l.marginPct === null ? null : round5(l.marginPct, 2)
+      }))
+    },
+    timeMs: Date.now() - start
+  };
+}
+
+// src/forge/analysis/statistics.ts
+function createRng2(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function sampleNormal(rng, mean2, sigma) {
+  const u1 = rng() || Number.MIN_VALUE;
+  const u2 = rng();
+  const z = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+  return mean2 + sigma * z;
+}
+function sampleUniform(rng, lo, hi) {
+  return lo + (hi - lo) * rng();
+}
+function mean(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((sum2, v) => sum2 + v, 0) / values.length;
+}
+function stdDev(values) {
+  if (values.length < 2) return 0;
+  const m = mean(values);
+  const ss = values.reduce((sum2, v) => sum2 + (v - m) * (v - m), 0);
+  return Math.sqrt(ss / (values.length - 1));
+}
+function capabilityIndices(meanValue, sigma, lsl, usl) {
+  if (!(sigma > 0)) return { cp: null, cpk: null };
+  const cp = lsl !== null && usl !== null ? (usl - lsl) / (6 * sigma) : null;
+  const upper = usl !== null ? (usl - meanValue) / (3 * sigma) : Infinity;
+  const lower2 = lsl !== null ? (meanValue - lsl) / (3 * sigma) : Infinity;
+  const cpk = Math.min(upper, lower2);
+  return { cp, cpk: Number.isFinite(cpk) ? cpk : null };
+}
+function dpmoFromYield(yieldFraction) {
+  return Math.max(0, (1 - yieldFraction) * 1e6);
+}
+
+// src/forge/analysis/tolerance.ts
+var ToleranceNonlinearError = class extends Error {
+  constructor(response, input, ratio, tolerance) {
+    super(
+      `Response "${response}" is nonlinear in input "${input}" across its tolerance band (curvature ratio ${ratio.toFixed(3)} > ${tolerance}). The linearized method would report a wrong yield. Re-run with --method full-rebuild.`
+    );
+    this.response = response;
+    this.input = input;
+    this.ratio = ratio;
+    this.tolerance = tolerance;
+    this.name = "ToleranceNonlinearError";
+  }
+};
+function readResponse(map, name) {
+  const value = map[name];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`tolerance sample did not return a finite value for response "${name}"`);
+  }
+  return value;
+}
+function analyzeTolerance(sample, inputs, responses, options) {
+  if (inputs.length === 0) throw new Error("tolerance analysis needs at least one varying input");
+  if (responses.length === 0) throw new Error("tolerance analysis needs at least one measured response");
+  const responseNames = responses.map((r) => r.name);
+  const baseline = sample({});
+  const nominalResp = {};
+  for (const name of responseNames) nominalResp[name] = readResponse(baseline, name);
+  const jac = {};
+  for (const name of responseNames) jac[name] = {};
+  for (const input of inputs) {
+    const delta = input.halfWidth > 0 ? input.halfWidth : Math.max(1e-6, Math.abs(input.nominal) * 1e-3);
+    const plus = sample({ [input.name]: input.nominal + delta });
+    const minus = sample({ [input.name]: input.nominal - delta });
+    for (const name of responseNames) {
+      const fp = readResponse(plus, name);
+      const fm = readResponse(minus, name);
+      const f0 = nominalResp[name];
+      jac[name][input.name] = (fp - fm) / (2 * delta);
+      if (options.method === "linearized") {
+        const curvature = Math.abs(fp - 2 * f0 + fm);
+        const slopeSpan = Math.abs(fp - f0) + Math.abs(fm - f0);
+        const ratio = slopeSpan > 1e-12 ? curvature / slopeSpan : curvature > 1e-9 ? Infinity : 0;
+        if (ratio > options.nonlinearityTol) {
+          throw new ToleranceNonlinearError(name, input.name, ratio, options.nonlinearityTol);
+        }
+      }
+    }
+  }
+  const rng = createRng2(options.seed);
+  const draws = {};
+  for (const name of responseNames) draws[name] = [];
+  let inSpecAll = 0;
+  for (let s = 0; s < options.samples; s += 1) {
+    const overrides = {};
+    for (const input of inputs) {
+      overrides[input.name] = input.dist === "uniform" ? sampleUniform(rng, input.nominal - input.halfWidth, input.nominal + input.halfWidth) : sampleNormal(rng, input.nominal, input.sigma);
+    }
+    let allIn = true;
+    for (const response of responses) {
+      let value;
+      if (options.method === "full-rebuild") {
+        value = readResponse(sample(overrides), response.name);
+      } else {
+        value = nominalResp[response.name];
+        for (const input of inputs) value += jac[response.name][input.name] * (overrides[input.name] - input.nominal);
+      }
+      draws[response.name].push(value);
+      if (response.lsl !== null && value < response.lsl) allIn = false;
+      if (response.usl !== null && value > response.usl) allIn = false;
+    }
+    if (allIn) inSpecAll += 1;
+  }
+  const responseStats = responses.map((response) => reduceResponse(response, draws[response.name], nominalResp[response.name], inputs, jac[response.name], options));
+  return {
+    method: options.method,
+    samples: options.samples,
+    seed: options.seed,
+    targetCpk: options.targetCpk,
+    inputs,
+    responses: responseStats,
+    overallYieldPct: inSpecAll / options.samples * 100
+  };
+}
+function reduceResponse(response, values, nominal, inputs, sensitivities, options) {
+  const m = mean(values);
+  const sigma = stdDev(values);
+  const { cp, cpk } = capabilityIndices(m, sigma, response.lsl, response.usl);
+  let inSpec = 0;
+  for (const v of values) {
+    if ((response.lsl === null || v >= response.lsl) && (response.usl === null || v <= response.usl)) inSpec += 1;
+  }
+  const yieldFraction = values.length > 0 ? inSpec / values.length : 1;
+  let worstHalf = 0;
+  let rssVariance = 0;
+  const variancePerInput = inputs.map((input) => {
+    const s = sensitivities[input.name];
+    worstHalf += Math.abs(s) * input.halfWidth;
+    rssVariance += s * input.halfWidth * (s * input.halfWidth);
+    return { input: input.name, sensitivity: s, variance: s * input.sigma * (s * input.sigma) };
+  });
+  const totalVariance = variancePerInput.reduce((sum2, v) => sum2 + v.variance, 0);
+  const contributions = variancePerInput.map((v) => ({ input: v.input, sensitivity: v.sensitivity, fraction: totalVariance > 0 ? v.variance / totalVariance : 0 })).sort((a, b) => b.fraction - a.fraction);
+  const rssHalf = Math.sqrt(rssVariance);
+  let allocation = null;
+  if (cpk !== null && cpk < options.targetCpk && cpk > 0) {
+    const scale2 = cpk / options.targetCpk;
+    allocation = inputs.map((input) => ({
+      input: input.name,
+      currentHalfWidth: input.halfWidth,
+      recommendedHalfWidth: input.halfWidth * scale2
+    }));
+  }
+  return {
+    name: response.name,
+    nominal,
+    mean: m,
+    sigma,
+    lsl: response.lsl,
+    usl: response.usl,
+    cp,
+    cpk,
+    pp: cp,
+    ppk: cpk,
+    yieldPct: yieldFraction * 100,
+    dpmo: dpmoFromYield(yieldFraction),
+    worstCaseMin: nominal - worstHalf,
+    worstCaseMax: nominal + worstHalf,
+    rssMin: nominal - rssHalf,
+    rssMax: nominal + rssHalf,
+    contributions,
+    allocation
+  };
+}
+
+// cli/tolerance-inputs.ts
+function extractNumericActual(value) {
+  if (value === void 0) return null;
+  const match = value.match(/-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/);
+  if (!match) return null;
+  const n = Number(match[0]);
+  return Number.isFinite(n) ? n : null;
+}
+function parseTolFlag(raw) {
+  const eq = raw.indexOf("=");
+  if (eq <= 0) throw new Error(`--tol expects Name=\xB1X or Name=lo..hi, got "${raw}"`);
+  const name = raw.slice(0, eq).trim();
+  const spec = raw.slice(eq + 1).trim();
+  const range = spec.match(/^(-?[\d.eE+-]+)\.\.(-?[\d.eE+-]+)$/);
+  if (range) {
+    const lo = Number(range[1]);
+    const hi = Number(range[2]);
+    if (!Number.isFinite(lo) || !Number.isFinite(hi) || hi <= lo) throw new Error(`--tol ${name}: invalid range "${spec}"`);
+    return { name, band: { lo, hi } };
+  }
+  const half = Number(spec.replace(/^[±+]/, ""));
+  if (!Number.isFinite(half) || half <= 0) throw new Error(`--tol ${name}: expected \xB1X or lo..hi, got "${spec}"`);
+  return { name, band: { halfWidth: half } };
+}
+function parseSpecFlag(raw) {
+  const eq = raw.indexOf("=");
+  if (eq <= 0) throw new Error(`--spec expects Name=lsl..usl, got "${raw}"`);
+  const name = raw.slice(0, eq).trim();
+  const m = raw.slice(eq + 1).trim().match(/^(\*|-?[\d.eE+-]+)\.\.(\*|-?[\d.eE+-]+)$/);
+  if (!m) throw new Error(`--spec ${name}: expected lsl..usl (use * for an open bound), got "${raw.slice(eq + 1)}"`);
+  const lsl = m[1] === "*" ? null : Number(m[1]);
+  const usl = m[2] === "*" ? null : Number(m[2]);
+  if (lsl !== null && !Number.isFinite(lsl) || usl !== null && !Number.isFinite(usl)) throw new Error(`--spec ${name}: non-finite bound`);
+  if (lsl === null && usl === null) throw new Error(`--spec ${name}: at least one bound must be a number`);
+  return { name, lsl, usl };
+}
+function parseDistFlag(raw) {
+  const eq = raw.indexOf("=");
+  if (eq <= 0) throw new Error(`--dist expects Name=normal|uniform, got "${raw}"`);
+  const name = raw.slice(0, eq).trim();
+  const dist3 = raw.slice(eq + 1).trim();
+  if (dist3 !== "normal" && dist3 !== "uniform") throw new Error(`--dist ${name}: expected normal or uniform`);
+  return { name, dist: dist3 };
+}
+function resolveToleranceInputs(params, options) {
+  const inputs = [];
+  for (const param of params) {
+    if (options.pinned.has(param.name)) continue;
+    if (param.integer || param.boolean || param.choices) continue;
+    const override = options.tolOverrides.get(param.name);
+    let nominal = param.defaultValue;
+    let halfWidth;
+    if (override?.lo !== void 0 && override?.hi !== void 0) {
+      nominal = (override.lo + override.hi) / 2;
+      halfWidth = (override.hi - override.lo) / 2;
+    } else if (override?.halfWidth !== void 0) {
+      halfWidth = override.halfWidth;
+    } else {
+      halfWidth = (param.max - param.min) / 2;
+    }
+    if (!(halfWidth > 0)) {
+      if (override) throw new Error(`tolerance input "${param.name}" has a non-positive band`);
+      continue;
+    }
+    const dist3 = options.distOverrides.get(param.name) ?? "normal";
+    const sigma = dist3 === "uniform" ? halfWidth / Math.sqrt(3) : halfWidth / options.sigmaLevel;
+    inputs.push({ name: param.name, nominal, halfWidth, sigma, dist: dist3, unit: param.unit });
+  }
+  return inputs;
+}
+var RANGE_RE = /^\[\s*(-?[\d.eE+-]+)\s*,\s*(-?[\d.eE+-]+)\s*\]$/;
+var GT_RE = /^>\s*(-?[\d.eE+-]+)$/;
+var LT_RE = /^<\s*(-?[\d.eE+-]+)$/;
+function limitsFromExpected(expected) {
+  if (!expected) return { lsl: null, usl: null };
+  const range = expected.match(RANGE_RE);
+  if (range) return { lsl: Number(range[1]), usl: Number(range[2]) };
+  const gt = expected.match(GT_RE);
+  if (gt) return { lsl: Number(gt[1]), usl: null };
+  const lt = expected.match(LT_RE);
+  if (lt) return { lsl: null, usl: Number(lt[1]) };
+  return { lsl: null, usl: null };
+}
+function resolveToleranceResponses(verifications, specOverrides) {
+  const byLabel = /* @__PURE__ */ new Map();
+  for (const v of verifications) {
+    if (extractNumericActual(v.actual) !== null) byLabel.set(v.label, v);
+  }
+  for (const name of specOverrides.keys()) {
+    if (!byLabel.has(name)) {
+      throw new Error(`--spec names response "${name}", but the model has no numeric verify.* result with that label`);
+    }
+  }
+  const responses = [];
+  const unbounded = [];
+  for (const [label, v] of byLabel) {
+    const override = specOverrides.get(label);
+    const limits = override ?? limitsFromExpected(v.expected);
+    if (limits.lsl === null && limits.usl === null) unbounded.push(label);
+    responses.push({ name: label, lsl: limits.lsl, usl: limits.usl });
+  }
+  return { responses, unbounded };
+}
+
+// cli/sim-tolerance.ts
+function parseArgs24(argv) {
+  const inputPaths = [];
+  const paramOverrides = {};
+  const tolOverrides = /* @__PURE__ */ new Map();
+  const distOverrides = /* @__PURE__ */ new Map();
+  const specOverrides = /* @__PURE__ */ new Map();
+  let json = false;
+  let compact = false;
+  let method = "linearized";
+  let samples = null;
+  let seed = 12345;
+  let sigmaLevel = 3;
+  let targetCpk = 1.33;
+  let nonlinearityTol = 0.05;
+  let noFailExit = false;
+  let backend;
+  let quality;
+  const numberFlag = (value, label, predicate) => {
+    const n = Number(value);
+    if (!Number.isFinite(n) || !predicate(n)) throw new Error(`${label} requires a valid number`);
+    return n;
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--compact") {
+      compact = true;
+      continue;
+    }
+    if (arg === "--no-fail-exit") {
+      noFailExit = true;
+      continue;
+    }
+    if (arg === "--method") {
+      const v = argv[i + 1];
+      if (v !== "linearized" && v !== "full-rebuild") throw new Error("--method must be linearized or full-rebuild");
+      method = v;
+      i += 1;
+      continue;
+    }
+    if (arg === "--samples") {
+      samples = numberFlag(argv[++i], "--samples", (n) => n >= 1);
+      continue;
+    }
+    if (arg === "--seed") {
+      seed = numberFlag(argv[++i], "--seed", () => true) >>> 0;
+      continue;
+    }
+    if (arg === "--sigma") {
+      sigmaLevel = numberFlag(argv[++i], "--sigma", (n) => n > 0);
+      continue;
+    }
+    if (arg === "--target-cpk") {
+      targetCpk = numberFlag(argv[++i], "--target-cpk", (n) => n > 0);
+      continue;
+    }
+    if (arg === "--nonlinearity-tol") {
+      nonlinearityTol = numberFlag(argv[++i], "--nonlinearity-tol", (n) => n > 0);
+      continue;
+    }
+    if (arg === "--tol") {
+      const { name, band } = parseTolFlag(argv[++i] ?? "");
+      tolOverrides.set(name, band);
+      continue;
+    }
+    if (arg === "--dist") {
+      const { name, dist: dist3 } = parseDistFlag(argv[++i] ?? "");
+      distOverrides.set(name, dist3);
+      continue;
+    }
+    if (arg === "--spec") {
+      const { name, lsl, usl } = parseSpecFlag(argv[++i] ?? "");
+      specOverrides.set(name, { lsl, usl });
+      continue;
+    }
+    if (arg === "--quality" || arg === "-q") {
+      const v = argv[i + 1];
+      if (v !== "default" && v !== "live" && v !== "high") throw new Error("--quality must be default, live, or high");
+      quality = v;
+      i += 1;
+      continue;
+    }
+    if (arg === "--backend") {
+      const v = argv[i + 1];
+      if (v !== "manifold" && v !== "occt" && v !== "truck" && v !== "sdf") throw new Error("--backend must be manifold, occt, truck, or sdf");
+      backend = v;
+      i += 1;
+      continue;
+    }
+    if (arg === "--param" || arg === "-p") {
+      const value = argv[i + 1];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires Key=Value`);
+      addCliParamOverride(value, paramOverrides);
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("--")) throw new Error(`Unknown flag: ${arg}`);
+    inputPaths.push(arg);
+  }
+  requireInputPaths(inputPaths, "Usage: forgecad sim tolerance <model.forge.js> [--tol Param=\xB1X] [--spec Resp=lo..hi] [--json]");
+  requireScriptInputPaths(inputPaths);
+  return {
+    inputPaths,
+    json,
+    compact,
+    method,
+    samples,
+    seed,
+    sigmaLevel,
+    targetCpk,
+    nonlinearityTol,
+    noFailExit,
+    tolOverrides,
+    distOverrides,
+    specOverrides,
+    backend,
+    quality,
+    paramOverrides
+  };
+}
+function failedReport6(source, message, code = "TOLERANCE.ERROR", suggest) {
+  return {
+    schema: FEEDBACK_SCHEMA,
+    category: "tolerance",
+    source,
+    ok: false,
+    summary: "tolerance analysis failed",
+    metrics: [],
+    findings: [{ level: "error", code, message, ...suggest ? { suggest } : {} }],
+    trust: { assumptions: [] },
+    data: {},
+    timeMs: 0
+  };
+}
+function round6(value, digits = 6) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+async function analyze4(scriptPath, options) {
+  const start = Date.now();
+  const input = loadCliScriptInput(scriptPath);
+  await initCliBackend(resolveCliBackend(options.backend, input) ?? CLI_DEFAULT_BACKEND);
+  const qualityPreset = options.quality && options.quality !== "default" ? options.quality : void 0;
+  const buildResponses = (overrides) => {
+    setParamOverrides({ ...options.paramOverrides, ...overrides });
+    const rr = runScript(input.code, input.fileName, input.allFiles, {
+      ...qualityPreset ? { quality: qualityPreset } : {},
+      readBinaryFile: input.readBinaryFile
+    });
+    if (rr.error) throw new Error(`model run failed: ${rr.error}`);
+    const map = {};
+    for (const v of rr.verifications) {
+      const n = extractNumericActual(v.actual);
+      if (n !== null) map[v.label] = n;
+    }
+    return map;
+  };
+  setParamOverrides({ ...options.paramOverrides });
+  const nominal = runScript(input.code, input.fileName, input.allFiles, {
+    ...qualityPreset ? { quality: qualityPreset } : {},
+    readBinaryFile: input.readBinaryFile
+  });
+  if (nominal.error) return failedReport6(scriptPath, nominal.error, "TOLERANCE.MODEL.ERROR");
+  const inputs = resolveToleranceInputs(nominal.params, {
+    pinned: new Set(Object.keys(options.paramOverrides)),
+    sigmaLevel: options.sigmaLevel,
+    tolOverrides: options.tolOverrides,
+    distOverrides: options.distOverrides
+  });
+  if (inputs.length === 0) {
+    return failedReport6(
+      scriptPath,
+      "No continuous parameters to vary.",
+      "TOLERANCE.NO_INPUTS",
+      "Add a number param with a min/max range, or pass --tol Param=\xB1X."
+    );
+  }
+  const { responses, unbounded } = resolveToleranceResponses(nominal.verifications, options.specOverrides);
+  if (responses.length === 0) {
+    return failedReport6(
+      scriptPath,
+      "No numeric verify.* responses to measure.",
+      "TOLERANCE.NO_RESPONSES",
+      'Add a verify.inRange("Name", measured, lo, hi) call (or similar) to the model.'
+    );
+  }
+  const a = buildResponses({});
+  const b = buildResponses({});
+  for (const r of responses) {
+    if (Math.abs((a[r.name] ?? NaN) - (b[r.name] ?? NaN)) > 1e-9) {
+      return failedReport6(
+        scriptPath,
+        `Response "${r.name}" changed between identical builds; the model is non-deterministic.`,
+        "TOLERANCE.MODEL.NONDETERMINISTIC",
+        "Remove randomness (e.g. Math.random) from the model before tolerance analysis."
+      );
+    }
+  }
+  const samples = options.samples ?? (options.method === "full-rebuild" ? 2e3 : 1e5);
+  let result;
+  try {
+    result = analyzeTolerance(buildResponses, inputs, responses, {
+      method: options.method,
+      samples,
+      seed: options.seed,
+      nonlinearityTol: options.nonlinearityTol,
+      targetCpk: options.targetCpk
+    });
+  } catch (error) {
+    if (error instanceof ToleranceNonlinearError) {
+      return failedReport6(scriptPath, error.message, "TOLERANCE.NONLINEAR", "Re-run with --method full-rebuild.");
+    }
+    throw error;
+  }
+  const findings = [];
+  for (const name of unbounded) {
+    findings.push({
+      level: "warning",
+      code: "TOLERANCE.SPEC.UNBOUNDED",
+      path: name,
+      message: `Response "${name}" has no spec limits; reporting variation only.`,
+      suggest: `Bound it with verify.inRange in the model, or pass --spec ${name}=lo..hi`
+    });
+  }
+  for (const r of result.responses) {
+    if (r.cpk !== null && r.cpk < options.targetCpk) {
+      const top = r.contributions[0];
+      const rec = r.allocation?.find((alloc) => alloc.input === top?.input);
+      findings.push({
+        level: "error",
+        code: "TOLERANCE.CPK.LOW",
+        path: r.name,
+        message: `Response "${r.name}" Cpk ${round6(r.cpk, 3)} is below target ${options.targetCpk} (yield ${round6(r.yieldPct, 2)}%).`,
+        suggest: top ? `Tighten "${top.input}" (${round6(top.fraction * 100, 0)}% of the variation)${rec ? `, e.g. \xB1${round6(rec.recommendedHalfWidth, 4)}` : ""}.` : "Tighten the dominant input tolerance."
+      });
+    }
+  }
+  const metrics = [makeMetric("overallYieldPct", "Overall yield", round6(result.overallYieldPct, 4), { unit: "%" })];
+  for (const r of result.responses) {
+    if (r.cpk !== null) {
+      metrics.push(makeMetric(`cpk.${r.name}`, `Cpk (${r.name})`, round6(r.cpk, 4), { unit: "", target: { op: ">=", value: options.targetCpk } }));
+    }
+    metrics.push(makeMetric(`yieldPct.${r.name}`, `Yield (${r.name})`, round6(r.yieldPct, 4), { unit: "%" }));
+  }
+  const assumptions = [
+    `${result.method === "linearized" ? "Linearized surrogate" : "Full model rebuild"} Monte Carlo, ${samples} samples, seed ${result.seed}.`,
+    "Normal input distributions unless --dist sets uniform; default band = (max-min)/2 of each param, read as \xB1" + options.sigmaLevel + "\u03C3.",
+    "Single population: Cp/Cpk equal Pp/Ppk (no subgroup short-vs-long-term split)."
+  ];
+  return {
+    schema: FEEDBACK_SCHEMA,
+    category: "tolerance",
+    source: scriptPath,
+    ok: reportOk(metrics, findings),
+    summary: `${result.responses.length} response(s) \xB7 overall yield ${round6(result.overallYieldPct, 2)}% \xB7 ${result.responses.filter((r) => r.cpk !== null && r.cpk >= options.targetCpk).length}/${result.responses.filter((r) => r.cpk !== null).length} meet Cpk ${options.targetCpk}`,
+    metrics,
+    findings,
+    trust: { assumptions, watertight: true },
+    data: {
+      method: result.method,
+      samples: result.samples,
+      seed: result.seed,
+      targetCpk: result.targetCpk,
+      overallYieldPct: round6(result.overallYieldPct, 4),
+      inputs: result.inputs.map((i) => ({ name: i.name, nominal: round6(i.nominal, 6), halfWidth: round6(i.halfWidth, 6), sigma: round6(i.sigma, 6), dist: i.dist, unit: i.unit })),
+      responses: result.responses.map((r) => ({
+        name: r.name,
+        nominal: round6(r.nominal, 6),
+        mean: round6(r.mean, 6),
+        sigma: round6(r.sigma, 6),
+        lsl: r.lsl,
+        usl: r.usl,
+        cp: r.cp === null ? null : round6(r.cp, 4),
+        cpk: r.cpk === null ? null : round6(r.cpk, 4),
+        yieldPct: round6(r.yieldPct, 4),
+        dpmo: round6(r.dpmo, 1),
+        worstCase: [round6(r.worstCaseMin, 6), round6(r.worstCaseMax, 6)],
+        rss: [round6(r.rssMin, 6), round6(r.rssMax, 6)],
+        contributions: r.contributions.map((c) => ({ input: c.input, percent: round6(c.fraction * 100, 2), sensitivity: round6(c.sensitivity, 6) })),
+        allocation: r.allocation?.map((alloc) => ({ input: alloc.input, currentHalfWidth: round6(alloc.currentHalfWidth, 6), recommendedHalfWidth: round6(alloc.recommendedHalfWidth, 6) })) ?? null
+      }))
+    },
+    timeMs: Date.now() - start
+  };
+}
+async function runSimToleranceCli(argv = process.argv.slice(2)) {
+  const options = parseArgs24(argv);
+  requireExistingInputPaths(options.inputPaths);
+  await init();
+  const reports = [];
+  for (const [index, scriptPath] of options.inputPaths.entries()) {
+    if (!options.json) printBatchHeader(scriptPath, index, options.inputPaths.length);
+    let report;
+    try {
+      report = await analyze4(scriptPath, options);
+    } catch (error) {
+      report = failedReport6(scriptPath, error instanceof Error ? error.message : String(error));
+    }
+    reports.push(report);
+  }
+  printFeedback(reports.length === 1 ? reports[0] : { runs: reports }, options.json, options.compact);
+  if (reports.some((report) => !report.ok) && !options.noFailExit) process.exitCode = 1;
+}
+
 // cli/test-run.ts
-import { resolve as resolve42 } from "path";
+import { resolve as resolve44 } from "path";
 
 // cli/solver-debug-artifacts.ts
 import { mkdir as mkdir5, writeFile as writeFile10 } from "fs/promises";
-import { basename as basename16, join as join15, resolve as resolve41 } from "path";
+import { basename as basename16, join as join16, resolve as resolve43 } from "path";
 
 // cli/solver-debug-html.ts
 function escapeHtml(s) {
@@ -34393,7 +36633,7 @@ function appendResiduals(lines, step) {
   }
 }
 async function writeSolverDebugArtifacts(outputRoot, scriptPath, objects) {
-  const root = resolve41(outputRoot);
+  const root = resolve43(outputRoot);
   await mkdir5(root, { recursive: true });
   const bundles = [];
   const usedNames = /* @__PURE__ */ new Map();
@@ -34407,14 +36647,14 @@ async function writeSolverDebugArtifacts(outputRoot, scriptPath, objects) {
     const seen = usedNames.get(baseName) ?? 0;
     usedNames.set(baseName, seen + 1);
     const dirName = seen === 0 ? baseName : `${baseName}-${seen + 1}`;
-    const dir = join15(root, dirName);
-    const svgDir = join15(dir, "svg");
+    const dir = join16(root, dirName);
+    const svgDir = join16(dir, "svg");
     await mkdir5(svgDir, { recursive: true });
-    const transcriptPath = join15(dir, "constructive-transcript.md");
+    const transcriptPath = join16(dir, "constructive-transcript.md");
     await writeFile10(transcriptPath, buildConstructiveTranscriptMarkdown(object.name || dirName, meta), "utf8");
     const snapshotPaths = [];
     for (const snapshot of debug.svgSnapshots) {
-      const snapshotPath = join15(svgDir, `${snapshot.label}.svg`);
+      const snapshotPath = join16(svgDir, `${snapshot.label}.svg`);
       await writeFile10(snapshotPath, snapshot.svg, "utf8");
       snapshotPaths.push(snapshotPath);
     }
@@ -34439,7 +36679,7 @@ async function writeSolverDebugArtifacts(outputRoot, scriptPath, objects) {
   for (const [index, html] of htmlMap) {
     const bundle = bundles[index] ?? bundles[bundles.length - 1];
     if (bundle) {
-      const htmlPath = join15(bundle.dir, "dashboard.html");
+      const htmlPath = join16(bundle.dir, "dashboard.html");
       await writeFile10(htmlPath, html, "utf8");
     }
   }
@@ -34447,7 +36687,7 @@ async function writeSolverDebugArtifacts(outputRoot, scriptPath, objects) {
   return bundles;
 }
 async function writeSolverDebugIndex(root, scriptPath, bundles) {
-  const lines = ["# Solver debug artifacts", "", `script: ${resolve41(scriptPath)}`, `artifacts: ${bundles.length}`, ""];
+  const lines = ["# Solver debug artifacts", "", `script: ${resolve43(scriptPath)}`, `artifacts: ${bundles.length}`, ""];
   if (bundles.length === 0) {
     lines.push("No solver debug artifacts were captured.");
   } else {
@@ -34458,7 +36698,7 @@ async function writeSolverDebugIndex(root, scriptPath, bundles) {
       lines.push(`  svg_snapshots: ${bundle.snapshotPaths.length}`);
     }
   }
-  await writeFile10(join15(root, "README.md"), lines.join("\n") + "\n", "utf8");
+  await writeFile10(join16(root, "README.md"), lines.join("\n") + "\n", "utf8");
 }
 
 // cli/test-run.ts
@@ -35062,7 +37302,7 @@ async function runScriptCli(argv = process.argv.slice(2)) {
       if (!printSolverProfile && solverDebugOut) {
         const bundles = await writeSolverDebugArtifacts(solverDebugOut, scriptPath, result.objects);
         console.log(`
-\u2713 Solver debug artifacts: ${bundles.length} sketch(es) \u2192 ${resolve42(solverDebugOut)}`);
+\u2713 Solver debug artifacts: ${bundles.length} sketch(es) \u2192 ${resolve44(solverDebugOut)}`);
         for (const bundle of bundles) {
           console.log(`  ${bundle.name}: transcript=${bundle.transcriptPath} svg=${bundle.snapshotPaths.length}`);
         }
@@ -35191,7 +37431,7 @@ async function runScriptCli(argv = process.argv.slice(2)) {
         if (solverDebugOut) {
           const bundles = await writeSolverDebugArtifacts(solverDebugOut, scriptPath, result.objects);
           console.log(`
-\u2713 Solver debug artifacts: ${bundles.length} sketch(es) \u2192 ${resolve42(solverDebugOut)}`);
+\u2713 Solver debug artifacts: ${bundles.length} sketch(es) \u2192 ${resolve44(solverDebugOut)}`);
           for (const bundle of bundles) {
             console.log(`  ${bundle.name}: transcript=${bundle.transcriptPath} svg=${bundle.snapshotPaths.length}`);
           }
@@ -35217,7 +37457,7 @@ async function runScriptCli(argv = process.argv.slice(2)) {
 
 // cli/forge-render-section.ts
 import { writeFile as writeFile11 } from "fs/promises";
-import { basename as basename17, extname as extname13, resolve as resolve43 } from "path";
+import { basename as basename17, extname as extname14, resolve as resolve45 } from "path";
 function usage26() {
   console.error(
     "Usage: forgecad render section <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--format svg|png] [--param Key=Value] [--joint JointName=Value] [--plane XY|XZ|YZ] [--offset <number>] [--size <px>] [--edges <off|thin|bold>] [--chrome-path <path>] [--background <color>]"
@@ -35309,7 +37549,7 @@ function parseRenderSectionArgs(argv) {
 async function runRenderSectionCli(argv = process.argv.slice(2)) {
   const options = parseRenderSectionArgs(argv);
   requireExistingInputPaths(options.inputPaths);
-  const needsPng = options.format === "png" || (options.outputPath ? extname13(options.outputPath).toLowerCase() === ".png" : false);
+  const needsPng = options.format === "png" || (options.outputPath ? extname14(options.outputPath).toLowerCase() === ".png" : false);
   let resolvedChromePath;
   if (needsPng) {
     resolvedChromePath = findChromePath(options.chromePath) ?? void 0;
@@ -35333,9 +37573,9 @@ async function runRenderSectionCli(argv = process.argv.slice(2)) {
   }
 }
 async function renderSectionInput(options, scriptPath, resolvedChromePath) {
-  const outputFormat = options.format ?? (options.outputPath && extname13(options.outputPath).toLowerCase() === ".png" ? "png" : "svg");
+  const outputFormat = options.format ?? (options.outputPath && extname14(options.outputPath).toLowerCase() === ".png" ? "png" : "svg");
   const outputPath = batchOutputPath(scriptPath, options.outputPath, (inputPath) => defaultOutput(inputPath, outputFormat));
-  if (resolve43(outputPath) === resolve43(scriptPath)) {
+  if (resolve45(outputPath) === resolve45(scriptPath)) {
     throw new Error(`ERROR: output path would overwrite the input script. Specify an explicit output path.`);
   }
   const input = loadCliScriptInput(scriptPath);
@@ -35374,9 +37614,9 @@ async function renderSectionInput(options, scriptPath, resolvedChromePath) {
       background: options.background,
       chromePath: resolvedChromePath
     });
-    await writeFile11(resolve43(outputPath), png);
+    await writeFile11(resolve45(outputPath), png);
   } else {
-    await writeFile11(resolve43(outputPath), svgDocument.svg);
+    await writeFile11(resolve45(outputPath), svgDocument.svg);
   }
   const sz = [svgDocument.width.toFixed(1), svgDocument.height.toFixed(1)];
   const totalArea = sectionSketches.reduce((sum2, s) => sum2 + s.sketch.area(), 0);
@@ -35387,20 +37627,20 @@ async function renderSectionInput(options, scriptPath, resolvedChromePath) {
 
 // cli/update-check.ts
 import { spawn as spawn4 } from "child_process";
-import { existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync25, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync27, writeFileSync as writeFileSync21 } from "fs";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname13, join as join16 } from "path";
+import { dirname as dirname14, join as join17 } from "path";
 var PACKAGE_NAME = "forgecad";
 var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 3e3;
 var WORKER_FLAG = "--__update-check-worker";
 function cachePath() {
-  return join16(homedir9(), ".forgecad", "update-check.json");
+  return join17(homedir9(), ".forgecad", "update-check.json");
 }
 function readCache() {
   try {
-    const text = readFileSync25(cachePath(), "utf-8");
+    const text = readFileSync27(cachePath(), "utf-8");
     const parsed = JSON.parse(text);
     if (typeof parsed.checkedAt !== "number" || typeof parsed.latest !== "string") return null;
     return parsed;
@@ -35410,9 +37650,9 @@ function readCache() {
 }
 function writeCache(cache) {
   const p = cachePath();
-  const dir = dirname13(p);
-  if (!existsSync21(dir)) mkdirSync13(dir, { recursive: true });
-  writeFileSync20(p, JSON.stringify(cache), "utf-8");
+  const dir = dirname14(p);
+  if (!existsSync22(dir)) mkdirSync14(dir, { recursive: true });
+  writeFileSync21(p, JSON.stringify(cache), "utf-8");
 }
 function shouldSkip() {
   if (process.env.FORGE_NO_UPDATE_CHECK) return true;
@@ -35633,7 +37873,9 @@ var PARAM_OPTIONS = [
     repeatable: true
   }
 ];
-var JOINT_OPTIONS = PARAM_OPTIONS.filter((option) => option.name === "--joint");
+var PARAM_OVERRIDE_OPTIONS = PARAM_OPTIONS.filter(
+  (option) => option.name === "--param" || option.name === "-p"
+);
 var RENDER_OPTIONS = [
   ...PARAM_OPTIONS,
   {
@@ -36510,7 +38752,7 @@ var HISTORY_INSPECT_COMMANDS = [
         { name: "--params", description: "Print resolved parameter values after the history" },
         { name: "--source", description: "Show source file and line for each printed feature step" },
         { name: "--trace-ids", description: "Show trace ids for feature steps and final objects" },
-        ...PARAM_OPTIONS,
+        ...PARAM_OVERRIDE_OPTIONS,
         {
           name: "--backend",
           description: "Geometry backend (default: manifold; STEP inputs default to OCCT)",
@@ -36555,7 +38797,7 @@ var HISTORY_INSPECT_COMMANDS = [
         },
         { name: "--anchor", description: "Print one agent-ready feedback anchor when the query matches exactly one trace node" },
         { name: "--full", description: "Print all matching trace nodes" },
-        ...PARAM_OPTIONS,
+        ...PARAM_OVERRIDE_OPTIONS,
         {
           name: "--backend",
           description: "Geometry backend (default: manifold; STEP inputs default to OCCT)",
@@ -36916,7 +39158,7 @@ var commands = [
           valueLabel: "<live|default|high>",
           values: QUALITY_VALUES
         },
-        ...PARAM_OPTIONS
+        ...PARAM_OVERRIDE_OPTIONS
       ],
       positionals: [{ description: "Forge script or CAD asset", valueKind: "renderable", repeatable: true }]
     },
@@ -37006,7 +39248,7 @@ var commands = [
     completion: {
       options: [
         { name: "--json", description: "Print machine-readable JSON" },
-        ...PARAM_OPTIONS,
+        ...PARAM_OVERRIDE_OPTIONS,
         {
           name: "--quality",
           description: "Mesh quality preset",
@@ -37052,7 +39294,7 @@ var commands = [
           valueLabel: "<name>",
           values: HQ_PRESET_VALUES
         },
-        ...PARAM_OPTIONS,
+        ...PARAM_OVERRIDE_OPTIONS,
         {
           name: "--edges",
           description: "Edge overlay preset (default: off)",
@@ -37124,7 +39366,7 @@ var commands = [
     path: ["render", "sketch"],
     summary: "Render a 2D sketch .forge.js to PNG.",
     usage: [
-      "forgecad render sketch <script.forge.js> [input ...] [--output path] [--size <px>] [--background <color>] [--chrome-path <path>]"
+      "forgecad render sketch <script.forge.js> [input ...] [--output path] [--size <px>] [--background <color>] [--chrome-path <path>] [--param Key=Value]"
     ],
     examples: [
       "forgecad render sketch examples/01-fully-constrained-rect.forge.js",
@@ -37133,6 +39375,7 @@ var commands = [
     ],
     completion: {
       options: [
+        ...PARAM_OVERRIDE_OPTIONS,
         { name: "--size", description: "Output image size in pixels (square)", argument: "required", valueLabel: "<px>" },
         { name: "--background", description: "Background color (CSS color)", argument: "required", valueLabel: "<color>" },
         { name: "--chrome-path", description: "Chrome executable path", argument: "required", valueLabel: "<path>" },
@@ -37211,7 +39454,7 @@ var commands = [
     ],
     completion: {
       options: [
-        ...PARAM_OPTIONS,
+        ...PARAM_OVERRIDE_OPTIONS,
         { name: "--plane", description: "Cut plane", argument: "required", valueLabel: "<XY|XZ|YZ>", values: SECTION_PLANE_VALUES },
         { name: "--offset", description: "Shift the cut position along the plane normal", argument: "required", valueLabel: "<mm>" },
         { name: "--size", description: "Output PNG size in pixels (square)", argument: "required", valueLabel: "<px>" },
@@ -37274,13 +39517,13 @@ var commands = [
     path: ["cut-list"],
     summary: "Print a grouped sheet-material cut list from `sheetStock()` declarations.",
     description: 'Runs the script, collects every `sheetStock(...)` declaration, and prints a grouped terminal cut list with quantity, part name, size, and material.\n\nUse this when you want to answer "what rectangles do I actually need to cut?" without generating a PDF layout. For sheet packing, kerf-aware nesting, and cut sequencing, use `forgecad export cutting-layout` instead.',
-    usage: ["forgecad cut-list <script.forge.js> [input ...] [--joint JointName=Value]"],
+    usage: ["forgecad cut-list <script.forge.js> [input ...] [--param Key=Value] [--joint JointName=Value]"],
     examples: [
       "forgecad cut-list examples/api/sheet-stock-cut-list.forge.js",
       "forgecad cut-list examples/api/sheet-stock-cut-list.forge.js path/to/my-cabinet.forge.js"
     ],
     completion: {
-      options: JOINT_OPTIONS,
+      options: PARAM_OPTIONS,
       positionals: [{ description: "Forge script", valueKind: "forge-script", repeatable: true }]
     },
     run: runCutListCli
@@ -37289,7 +39532,7 @@ var commands = [
     group: "Export",
     path: ["export", "svg"],
     summary: "Export a sketch `.forge.js` file to SVG.",
-    usage: ["forgecad export svg <script.forge.js> [input ...] [--output path]"],
+    usage: ["forgecad export svg <script.forge.js> [input ...] [--output path] [--param Key=Value]"],
     examples: [
       "forgecad export svg examples/01-fully-constrained-rect.forge.js",
       "forgecad export svg examples/01-fully-constrained-rect.forge.js --output out/rect.svg",
@@ -37297,6 +39540,7 @@ var commands = [
     ],
     completion: {
       options: [
+        ...PARAM_OVERRIDE_OPTIONS,
         {
           name: "--output",
           description: "Output SVG path for a single input",
@@ -37313,7 +39557,7 @@ var commands = [
     group: "Export",
     path: ["export", "sketch-pdf"],
     summary: "Export a constrained sketch `.forge.js` to a single-page PDF with dimensions, constraints, and surfaces.",
-    usage: ["forgecad export sketch-pdf <script.forge.js> [input ...] [--output path]"],
+    usage: ["forgecad export sketch-pdf <script.forge.js> [input ...] [--output path] [--param Key=Value]"],
     examples: [
       "forgecad export sketch-pdf examples/constraints/01-fully-constrained-rect.forge.js",
       "forgecad export sketch-pdf examples/constraints/01-fully-constrained-rect.forge.js --output out/rect.pdf",
@@ -37321,6 +39565,7 @@ var commands = [
     ],
     completion: {
       options: [
+        ...PARAM_OVERRIDE_OPTIONS,
         {
           name: "--output",
           description: "Output PDF path for a single input",
@@ -37338,7 +39583,7 @@ var commands = [
     path: ["export", "step"],
     summary: "Export exact STEP through the native OCCT or Truck runtime exporter.",
     usage: [
-      "forgecad export step <model.forge.js|asset.step|asset.stp> [input ...] [--output path] [--backend occt|truck] [--joint JointName=Value]"
+      "forgecad export step <model.forge.js|asset.step|asset.stp> [input ...] [--output path] [--backend occt|truck] [--param Key=Value] [--joint JointName=Value]"
     ],
     examples: [
       "forgecad export step examples/api/boolean-operations.forge.js",
@@ -37348,7 +39593,7 @@ var commands = [
     ],
     completion: {
       options: [
-        ...JOINT_OPTIONS,
+        ...PARAM_OPTIONS,
         { name: "--output", description: "Output STEP path", argument: "required", valueLabel: "<path>", valueKind: "path" },
         {
           name: "--backend",
@@ -37365,14 +39610,16 @@ var commands = [
     group: "Export",
     path: ["export", "brep"],
     summary: "Export exact BREP through the native OCCT runtime exporter.",
-    usage: ["forgecad export brep <model.forge.js|asset.step|asset.stp> [input ...] [--output path] [--joint JointName=Value]"],
+    usage: [
+      "forgecad export brep <model.forge.js|asset.step|asset.stp> [input ...] [--output path] [--param Key=Value] [--joint JointName=Value]"
+    ],
     examples: [
       "forgecad export brep examples/api/boolean-operations.forge.js",
       "forgecad export brep examples/api/boolean-operations.forge.js examples/api/mixed-edge-finishes-proof.forge.js"
     ],
     completion: {
       options: [
-        ...JOINT_OPTIONS,
+        ...PARAM_OPTIONS,
         { name: "--output", description: "Output BREP path", argument: "required", valueLabel: "<path>", valueKind: "path" }
       ],
       positionals: [{ description: "Forge script or STEP file", valueKind: "exact-cad-input", repeatable: true }]
@@ -37384,7 +39631,7 @@ var commands = [
     path: ["export", "3mf"],
     summary: "Export a Forge script to 3MF (3D Manufacturing Format) for 3D printing.",
     usage: [
-      "forgecad export 3mf <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--quality default|live|high] [--backend manifold|occt|truck|sdf] [--joint JointName=Value]"
+      "forgecad export 3mf <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--quality default|live|high] [--backend manifold|occt|truck|sdf] [--param Key=Value] [--joint JointName=Value]"
     ],
     examples: [
       "forgecad export 3mf examples/products/cup.forge.js",
@@ -37395,7 +39642,7 @@ var commands = [
     ],
     completion: {
       options: [
-        ...JOINT_OPTIONS,
+        ...PARAM_OPTIONS,
         { name: "--output", description: "Output 3MF path", argument: "required", valueLabel: "<path>", valueKind: "path" },
         {
           name: "--quality",
@@ -37421,18 +39668,19 @@ var commands = [
     path: ["export", "stl"],
     summary: "Export a Forge script to binary STL.",
     usage: [
-      "forgecad export stl <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--quality default|live|high] [--backend manifold|occt|truck|sdf] [--joint JointName=Value]"
+      "forgecad export stl <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--quality default|live|high] [--backend manifold|occt|truck|sdf] [--param Key=Value] [--joint JointName=Value]"
     ],
     examples: [
       "forgecad export stl examples/products/cup.forge.js",
       "forgecad export stl examples/products/cup.forge.js --output out/cup.stl",
+      "forgecad export stl examples/products/cup.forge.js --param Diameter=80 --output out/cup.stl",
       "forgecad export stl examples/products/cup.forge.js examples/api/boolean-operations.forge.js",
       "forgecad export stl examples/products/cup.forge.js --quality high",
       "forgecad export stl examples/products/cup.forge.js --backend occt"
     ],
     completion: {
       options: [
-        ...JOINT_OPTIONS,
+        ...PARAM_OPTIONS,
         { name: "--output", description: "Output STL path", argument: "required", valueLabel: "<path>", valueKind: "path" },
         {
           name: "--quality",
@@ -37457,7 +39705,7 @@ var commands = [
     group: "Export",
     path: ["export", "gcode"],
     summary: "Export a G-code toolpath script to .gcode for direct 3D printing.",
-    usage: ["forgecad export gcode <script.forge.js> [input ...] [--output path] [--joint JointName=Value]"],
+    usage: ["forgecad export gcode <script.forge.js> [input ...] [--output path] [--param Key=Value] [--joint JointName=Value]"],
     examples: [
       "forgecad export gcode examples/gcode/parametric-vase.forge.js",
       "forgecad export gcode examples/gcode/parametric-vase.forge.js --output out/vase.gcode",
@@ -37465,7 +39713,7 @@ var commands = [
     ],
     completion: {
       options: [
-        ...JOINT_OPTIONS,
+        ...PARAM_OPTIONS,
         { name: "--output", description: "Output file path for a single input", argument: "required", valueLabel: "<path>" },
         { name: "-o", description: "Shorthand for --output", argument: "required", valueLabel: "<path>" }
       ],
@@ -37479,7 +39727,7 @@ var commands = [
     summary: "Export direct SDF scene data for GPU or server-side implicit rendering.",
     description: "Writes JSON SDF scene programs or a WebGPU distance-brick compute package without converting the model to STL/3MF meshes. Defaults to the SDF backend.",
     usage: [
-      "forgecad export implicit <model.forge.js|asset.step|asset.stp> [--output path] [--format json|webgpu-brick] [--quality live|default|high] [--backend manifold|occt|truck|sdf] [--workgroup-size 4x4x4]"
+      "forgecad export implicit <model.forge.js|asset.step|asset.stp> [--output path] [--format json|webgpu-brick] [--quality live|default|high] [--backend manifold|occt|truck|sdf] [--workgroup-size 4x4x4] [--param Key=Value] [--joint JointName=Value]"
     ],
     examples: [
       "forgecad export implicit examples/products/bottle.forge.js --quality live",
@@ -37488,7 +39736,6 @@ var commands = [
     completion: {
       options: [
         ...PARAM_OPTIONS,
-        ...JOINT_OPTIONS,
         { name: "--output", description: "Output file or package directory", argument: "required", valueLabel: "<path>" },
         { name: "-o", description: "Shorthand for --output", argument: "required", valueLabel: "<path>" },
         {
@@ -37529,7 +39776,7 @@ var commands = [
     group: "Export",
     path: ["export", "sdf"],
     summary: "Export a robot assembly as a Gazebo-ready SDF package.",
-    usage: ["forgecad export sdf <script.forge.js> [input ...] [--output dir] [--joint JointName=Value]"],
+    usage: ["forgecad export sdf <script.forge.js> [input ...] [--output dir] [--param Key=Value] [--joint JointName=Value]"],
     examples: [
       "forgecad export sdf path/to/robot.forge.js",
       "forgecad export sdf path/to/robot.forge.js --output out/robot_sdf",
@@ -37537,7 +39784,7 @@ var commands = [
     ],
     completion: {
       options: [
-        ...JOINT_OPTIONS,
+        ...PARAM_OPTIONS,
         {
           name: "--output",
           description: "Output package directory for a single input",
@@ -37554,15 +39801,16 @@ var commands = [
     group: "Export",
     path: ["export", "mjcf"],
     summary: "Export a robot assembly as a native MuJoCo MJCF package.",
-    usage: ["forgecad export mjcf <script.forge.js> [input ...] [--output dir] [--joint JointName=Value]"],
+    usage: ["forgecad export mjcf <script.forge.js> [input ...] [--output dir] [--param Key=Value] [--joint JointName=Value]"],
     examples: [
       "forgecad export mjcf path/to/robot.forge.js",
       "forgecad export mjcf path/to/robot.forge.js --output out/robot_mjcf",
+      "forgecad export mjcf path/to/robot.forge.js --param Wheelbase=180 --output out/robot_mjcf",
       "forgecad export mjcf path/to/robot.forge.js path/to/second-robot.forge.js"
     ],
     completion: {
       options: [
-        ...JOINT_OPTIONS,
+        ...PARAM_OPTIONS,
         {
           name: "--output",
           description: "Output package directory for a single input",
@@ -37579,7 +39827,7 @@ var commands = [
     group: "Export",
     path: ["export", "urdf"],
     summary: "Export a robot assembly as a URDF package (ROS/PyBullet/MuJoCo).",
-    usage: ["forgecad export urdf <script.forge.js> [input ...] [--output dir] [--joint JointName=Value]"],
+    usage: ["forgecad export urdf <script.forge.js> [input ...] [--output dir] [--param Key=Value] [--joint JointName=Value]"],
     examples: [
       "forgecad export urdf path/to/robot.forge.js",
       "forgecad export urdf path/to/robot.forge.js --output out/robot_urdf",
@@ -37587,7 +39835,7 @@ var commands = [
     ],
     completion: {
       options: [
-        ...JOINT_OPTIONS,
+        ...PARAM_OPTIONS,
         {
           name: "--output",
           description: "Output package directory for a single input",
@@ -37600,11 +39848,30 @@ var commands = [
     },
     run: runUrdfCli
   },
+  {
+    group: "Export",
+    path: ["export", "pinocchio"],
+    summary: "Export a robot assembly as a Pinocchio dynamics package (URDF + gravity-torque harness).",
+    description: "Reuses the URDF package (with per-link inertials computed from the solid) and adds a runnable Pinocchio harness. `scripts/run_pinocchio.py` sweeps each joint, computes the gravity-hold torque via `pin.computeGeneralizedGravity`, and writes `feedback.json` (the `forgecad.feedback/v1` contract); re-surface it with `forgecad sim dynamics <dir>`. Pinocchio (BSD-2) and Coal (BSD-3) are user-installed \u2014 Linux/macOS `pip install pin coal`, Windows conda-forge \u2014 never bundled.",
+    usage: ["forgecad export pinocchio <script.forge.js> [input ...] [--output dir] [--param Key=Value] [--joint JointName=Value]"],
+    examples: [
+      "forgecad export pinocchio examples/analysis/lever-arm-actuator.forge.js",
+      "forgecad export pinocchio path/to/robot.forge.js --output out/robot_pinocchio"
+    ],
+    completion: {
+      options: [
+        ...PARAM_OPTIONS,
+        { name: "--output", description: "Output package directory for a single input", argument: "required", valueLabel: "<dir>", valueKind: "directory" }
+      ],
+      positionals: [{ description: "Forge script", valueKind: "forge-script", repeatable: true }]
+    },
+    run: runPinocchioCli
+  },
   {
     group: "Export",
     path: ["export", "usd"],
     summary: "Export a SimReady assembly as an Isaac Sim-ready USD package.",
-    usage: ["forgecad export usd <script.forge.js> [input ...] [--output dir] [--joint JointName=Value]"],
+    usage: ["forgecad export usd <script.forge.js> [input ...] [--output dir] [--param Key=Value] [--joint JointName=Value]"],
     examples: [
       "forgecad export usd path/to/robot.forge.js",
       "forgecad export usd path/to/robot.forge.js path/to/arm.forge.js",
@@ -37612,7 +39879,7 @@ var commands = [
     ],
     completion: {
       options: [
-        ...JOINT_OPTIONS,
+        ...PARAM_OPTIONS,
         {
           name: "--output",
           description: "Output package directory for a single input",
@@ -37630,7 +39897,7 @@ var commands = [
     path: ["export", "report"],
     summary: "Generate a multi-view PDF report with BOM and dimensions.",
     usage: [
-      "forgecad export report <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--dim-angle-tol <deg>] [--joint JointName=Value]"
+      "forgecad export report <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--dim-angle-tol <deg>] [--param Key=Value] [--joint JointName=Value]"
     ],
     examples: [
       "forgecad export report examples/products/cup.forge.js",
@@ -37639,7 +39906,7 @@ var commands = [
     ],
     completion: {
       options: [
-        ...JOINT_OPTIONS,
+        ...PARAM_OPTIONS,
         {
           name: "--output",
           description: "Output PDF path for a single input",
@@ -37660,7 +39927,7 @@ var commands = [
     description: "Packs `sheetStock(...)` pieces onto stock sheets, writes a cutting-layout PDF or DXF, and prints the guillotine cut sequence in the terminal.\n\nPDF is the default review format. Use `--format dxf` or an `.dxf` output path when sending the packed layout to CAD/CAM tools; DXF output contains only the placed cut outlines by default. For the simpler grouped parts list without packing or layout export, use `forgecad cut-list`.",
     usage: [
       "forgecad export cutting-layout <script.forge.js> [input ...] [--output output.pdf|output.dxf]",
-      "  [--format pdf|dxf] [--sheet-width <mm>] [--sheet-height <mm>] [--kerf <mm>] [--joint JointName=Value]"
+      "  [--format pdf|dxf] [--sheet-width <mm>] [--sheet-height <mm>] [--kerf <mm>] [--param Key=Value] [--joint JointName=Value]"
     ],
     examples: [
       "forgecad export cutting-layout examples/api/sheet-stock-cut-list.forge.js",
@@ -37670,7 +39937,7 @@ var commands = [
     ],
     completion: {
       options: [
-        ...JOINT_OPTIONS,
+        ...PARAM_OPTIONS,
         { name: "--output", description: "Output PDF or DXF path (single input only)", argument: "required", valueLabel: "<path>" },
         { name: "--out", description: "Alias for --output", argument: "required", valueLabel: "<path>" },
         {
@@ -38423,23 +40690,145 @@ var commands = [
     path: ["check", "simready"],
     summary: "Validate source-authored robot and physics metadata before simulation export.",
     description: "Runs a Forge script and checks the returned `assembly(...).withSimulation(...)` contract without Isaac Sim, OpenUSD, or NVIDIA validators. The gate validates Sim.body metadata, explicit colliders, contact connectors, controller joints, numeric physics values, and the robot joint graph.",
-    usage: ["forgecad check simready <script.forge.js> [input ...] [--json] [--joint JointName=Value]"],
+    usage: ["forgecad check simready <script.forge.js> [input ...] [--json] [--param Key=Value] [--joint JointName=Value]"],
     examples: [
       "forgecad check simready examples/robotics/simready-diff-drive-rover.forge.js",
       "forgecad check simready examples/robotics/simready-diff-drive-rover.forge.js path/to/second-robot.forge.js",
-      "forgecad check simready robot.forge.js --json"
+      "forgecad check simready robot.forge.js --param Wheelbase=180 --json"
     ],
     completion: {
       options: [
+        ...PARAM_OPTIONS,
         { name: "--json", description: "Emit the machine-readable report to stdout" },
         { name: "--compact", description: "Minify JSON output" },
-        { name: "--no-fail-exit", description: "Always exit 0 after writing the report" },
-        ...JOINT_OPTIONS
+        { name: "--no-fail-exit", description: "Always exit 0 after writing the report" }
       ],
       positionals: [{ description: "Forge script", valueKind: "forge-script", repeatable: true }]
     },
     run: runCheckSimReadyCli
   },
+  {
+    group: "Inspect",
+    path: ["sim", "mass"],
+    summary: "Compute mass properties: volume, mass, center of mass, inertia tensor, principal moments.",
+    description: "Native-analytic mass-properties analysis computed directly from the model geometry \u2014 no external solver. Integrates the triangulated mesh (Mirtich/Eberly divergence theorem) to report volume, surface area, bounding box, mass-weighted center of mass, the full inertia tensor about the center of mass, principal moments and axes, and a per-object breakdown.\n\nVolume, center of mass, and principal axes are exact regardless of material. Pass `--density <kg/m3>` for accurate mass and inertia magnitude (default 1000 kg/m\xB3 water, reported as a warning). Emits the `forgecad.feedback/v1` JSON contract with `--json`.",
+    usage: ["forgecad sim mass <model.forge.js> [input ...] [--density kg/m3] [--json] [--param Key=Value] [--joint JointName=Value]"],
+    examples: [
+      "forgecad sim mass examples/analysis/tipping-tripod.forge.js",
+      "forgecad sim mass bracket.forge.js --density 2700 --json",
+      "forgecad sim mass rover.forge.js --param Wheelbase=180 --json"
+    ],
+    completion: {
+      options: [
+        ...PARAM_OPTIONS,
+        { name: "--density", description: "Uniform density in kg/m\xB3 for mass and inertia", argument: "required", valueLabel: "<kg/m3>" },
+        { name: "--json", description: "Emit the forgecad.feedback/v1 report to stdout" },
+        { name: "--compact", description: "Minify JSON output" }
+      ],
+      positionals: [{ description: "Forge script", valueKind: "forge-script", repeatable: true }]
+    },
+    run: runSimMassCli
+  },
+  {
+    group: "Inspect",
+    path: ["sim", "tolerance"],
+    summary: "Tolerance / GD&T stack-up: yield, Cp/Cpk, and which dimension to tighten.",
+    description: "Native-analytic tolerance stack-up \u2014 no external solver. Treats the model's continuous parameters as the varying manufacturing inputs and its numeric `verify.*` results as the measured responses (with spec limits from the verify call or `--spec`). Builds a finite-difference Jacobian, runs a deterministic Monte Carlo over the linearized surrogate, and reports per-response mean/sigma, Cp/Cpk, yield % and DPMO, worst-case and RSS envelopes, a ranked variance-contribution list, and a tolerance-allocation recommendation to reach the target Cpk.\n\nA nonlinearity guard errors (telling you to pass `--method full-rebuild`) rather than silently reporting a wrong yield. Exits non-zero when any response's Cpk is below `--target-cpk` (default 1.33). Emits the `forgecad.feedback/v1` JSON contract with `--json`.",
+    usage: ["forgecad sim tolerance <model.forge.js> [--tol Param=\xB1X] [--spec Resp=lo..hi] [--method linearized|full-rebuild] [--json]"],
+    examples: [
+      "forgecad sim tolerance examples/analysis/clearance-fit.forge.js --json",
+      "forgecad sim tolerance fit.forge.js --tol BoreDia=\xB10.02 --target-cpk 1.33 --json",
+      "forgecad sim tolerance fit.forge.js --method full-rebuild --samples 5000 --json"
+    ],
+    completion: {
+      options: [
+        ...PARAM_OPTIONS,
+        { name: "--method", description: "linearized (default) or full-rebuild", argument: "required", valueLabel: "<linearized|full-rebuild>" },
+        { name: "--samples", description: "Monte Carlo sample count", argument: "required", valueLabel: "<n>" },
+        { name: "--seed", description: "Deterministic RNG seed", argument: "required", valueLabel: "<n>" },
+        { name: "--sigma", description: "Tolerance band = N sigma (default 3)", argument: "required", valueLabel: "<n>" },
+        { name: "--target-cpk", description: "Target Cpk for pass/allocation (default 1.33)", argument: "required", valueLabel: "<n>" },
+        { name: "--tol", description: "Override an input band: Param=\xB1X or Param=lo..hi", argument: "required", valueLabel: "<spec>" },
+        { name: "--dist", description: "Input distribution: Param=normal|uniform", argument: "required", valueLabel: "<spec>" },
+        { name: "--spec", description: "Declare response spec limits: Resp=lsl..usl (* for open)", argument: "required", valueLabel: "<spec>" },
+        { name: "--nonlinearity-tol", description: "Curvature threshold tripping the guard (default 0.05)", argument: "required", valueLabel: "<n>" },
+        { name: "--json", description: "Emit the forgecad.feedback/v1 report to stdout" },
+        { name: "--compact", description: "Minify JSON output" },
+        { name: "--no-fail-exit", description: "Always exit 0 after writing the report" }
+      ],
+      positionals: [{ description: "Forge script", valueKind: "forge-script", repeatable: true }]
+    },
+    run: runSimToleranceCli
+  },
+  {
+    group: "Inspect",
+    path: ["sim", "mechanism"],
+    summary: "Mechanism budget: DOF, and the gravity-hold torque each joint must supply.",
+    description: "Native-analytic mechanism analysis from the assembly joint graph \u2014 no external solver, no time-stepping. Reports the actuated degrees of freedom (and a spatial Gr\xFCbler mobility diagnostic for closed loops), and for each actuated joint the gravity-hold torque (revolute) or force (prismatic) it must supply at the current pose, computed from the mass of the distal subtree. When a joint carries a `Sim.drive` effort budget, the report includes the margin and flags over-budget joints.\n\nThis is the deterministic budget tier; the dynamic/contact tier is `export pinocchio`. Exits non-zero when any joint exceeds its budget (or falls below `--min-torque-margin-pct`). Use `--joint Name=Value` to evaluate a specific pose. Emits the `forgecad.feedback/v1` JSON contract with `--json`.",
+    usage: ["forgecad sim mechanism <model.forge.js> [--min-torque-margin-pct N] [--joint Name=Value] [--json]"],
+    examples: [
+      "forgecad sim mechanism examples/analysis/lever-arm-actuator.forge.js --json",
+      "forgecad sim mechanism arm.forge.js --joint shoulder=45 --json",
+      "forgecad sim mechanism arm.forge.js --min-torque-margin-pct 20 --json"
+    ],
+    completion: {
+      options: [
+        ...PARAM_OPTIONS,
+        { name: "--min-torque-margin-pct", description: "Required actuator budget margin %", argument: "required", valueLabel: "<pct>" },
+        { name: "--density", description: "Fallback density kg/m\xB3 for parts without Sim.body mass", argument: "required", valueLabel: "<kg/m3>" },
+        { name: "--json", description: "Emit the forgecad.feedback/v1 report to stdout" },
+        { name: "--compact", description: "Minify JSON output" },
+        { name: "--no-fail-exit", description: "Always exit 0 after writing the report" }
+      ],
+      positionals: [{ description: "Forge script", valueKind: "forge-script", repeatable: true }]
+    },
+    run: runSimMechanismCli
+  },
+  {
+    group: "Inspect",
+    path: ["sim", "dynamics"],
+    summary: "Read back a Pinocchio dynamics run (feedback.json) as the forgecad.feedback/v1 contract.",
+    description: "Ingests the `feedback.json` written by an exported Pinocchio package's `run_pinocchio.py` and re-surfaces it through ForgeCAD, closing the read-back side of the dynamics loop. Pass the package directory (or the feedback.json directly). Reports `DYNAMICS.NOT_RUN` when the results are missing, and exits non-zero when the run reported a failing metric.",
+    usage: ["forgecad sim dynamics <pinocchio-package-dir|feedback.json> [--json] [--compact]"],
+    examples: [
+      "forgecad sim dynamics examples/analysis/lever-arm-actuator.pinocchiopkg",
+      "forgecad sim dynamics out/robot_pinocchio/feedback.json --json"
+    ],
+    completion: {
+      options: [
+        { name: "--json", description: "Emit the forgecad.feedback/v1 report to stdout" },
+        { name: "--compact", description: "Minify JSON output" },
+        { name: "--no-fail-exit", description: "Always exit 0 after writing the report" }
+      ],
+      positionals: [{ description: "Pinocchio package directory or feedback.json", valueKind: "path", repeatable: true }]
+    },
+    run: runSimDynamicsCli
+  },
+  {
+    group: "Checks",
+    path: ["check", "stability"],
+    summary: "Check static tip-over stability: center of mass vs the support footprint.",
+    description: "Native-analytic static stability check \u2014 no external solver. Computes the uniform-density center of mass, derives the support footprint as the convex hull of the lowest geometry, and reports the signed tip-over margin (distance from the CoM projection to the footprint edge; negative means it tips), the tilt angle at which it tips, the critical edge, and the center-of-mass shift needed to reach the required margin.\n\nExits non-zero when the margin is below `--min-margin-mm` (default 0). Use `--up x|y|z` to set the up axis (default z). Emits the `forgecad.feedback/v1` JSON contract with `--json`.",
+    usage: ["forgecad check stability <model.forge.js> [input ...] [--min-margin-mm N] [--up x|y|z] [--json] [--param Key=Value]"],
+    examples: [
+      "forgecad check stability examples/analysis/tipping-tripod.forge.js",
+      "forgecad check stability tower.forge.js --min-margin-mm 5 --json",
+      "forgecad check stability tower.forge.js --param BaseSpreadMm=120 --json"
+    ],
+    completion: {
+      options: [
+        ...PARAM_OPTIONS,
+        { name: "--min-margin-mm", description: "Required signed tip-over margin in mm", argument: "required", valueLabel: "<mm>" },
+        { name: "--up", description: "Up axis (gravity is its negative)", argument: "required", valueLabel: "<x|y|z>" },
+        { name: "--contact-tol", description: "Footprint contact tolerance in mm", argument: "required", valueLabel: "<mm>" },
+        { name: "--json", description: "Emit the forgecad.feedback/v1 report to stdout" },
+        { name: "--compact", description: "Minify JSON output" },
+        { name: "--no-fail-exit", description: "Always exit 0 after writing the report" }
+      ],
+      positionals: [{ description: "Forge script", valueKind: "forge-script", repeatable: true }]
+    },
+    run: runCheckStabilityCli
+  },
   {
     group: "Checks",
     path: ["check", "params"],
@@ -38805,7 +41194,7 @@ var commands = [
         { name: "--update", description: "Regenerate compiler snapshots" }
       ]
     },
-    run: async (args) => (await import("./check-compiler-SP7FAL7R.js")).runCheckCompilerCli(args)
+    run: async (args) => (await import("./check-compiler-HPF2T2FS.js")).runCheckCompilerCli(args)
   },
   {
     group: "Checks",
@@ -38828,7 +41217,7 @@ var commands = [
         { name: "--update", description: "Regenerate query-propagation snapshots" }
       ]
     },
-    run: async (args) => (await import("./check-query-propagation-BRLSHP22.js")).runCheckQueryPropagationCli(args)
+    run: async (args) => (await import("./check-query-propagation-HYSLTXAB.js")).runCheckQueryPropagationCli(args)
   },
   {
     group: "Checks",
@@ -39057,7 +41446,7 @@ var commands = [
 ];
 function readVersion() {
   try {
-    const pkg = JSON.parse(readFileSync26(resolvePackagePath(import.meta.url, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync28(resolvePackagePath(import.meta.url, "package.json"), "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -39555,7 +41944,7 @@ function oclifCommandTarget() {
   return import.meta.url.includes("/dist-cli/") ? "./dist-cli/forgecad.js" : "./cli/forgecad.ts";
 }
 function forgeCadOclifPjson() {
-  const pkg = JSON.parse(readFileSync26(resolvePackagePath(import.meta.url, "package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync28(resolvePackagePath(import.meta.url, "package.json"), "utf-8"));
   return {
     ...pkg,
     oclif: {