forgecad 0.9.15 → 0.9.16

package/dist/assets/{reportWorker-CdBz5bNg.js → reportWorker-0AGij1Ru.js}

@@ -1220,7 +1220,7 @@ function requireFiniteVec2(value, label) {
   }
   return [requireFiniteNumber$1(value[0], `${label}[0]`), requireFiniteNumber$1(value[1], `${label}[1]`)];
 }
-function requireFiniteVec3$2(value, label) {
+function requireFiniteVec3$4(value, label) {
   if (!Array.isArray(value) || value.length !== 3) {
     throw new Error(`${label} must be [x, y, z] with finite numbers, got ${formatValidationValue(value)}`);
   }
@@ -1236,7 +1236,7 @@ function requireNonZeroFiniteVec2(value, label) {
   return v;
 }
 function requireNonZeroFiniteVec3(value, label) {
-  const v = requireFiniteVec3$2(value, label);
+  const v = requireFiniteVec3$4(value, label);
   if (v[0] === 0 && v[1] === 0 && v[2] === 0) throw new Error(`${label} must not be [0, 0, 0]`);
   return v;
 }
@@ -1254,7 +1254,7 @@ function requireNonZeroFiniteScale2(value, label) {
   return scale2;
 }
 function requireNonZeroFiniteScale3(value, label) {
-  const scale2 = typeof value === "number" ? [requireFiniteNumber$1(value, label), requireFiniteNumber$1(value, label), requireFiniteNumber$1(value, label)] : requireFiniteVec3$2(value, label);
+  const scale2 = typeof value === "number" ? [requireFiniteNumber$1(value, label), requireFiniteNumber$1(value, label), requireFiniteNumber$1(value, label)] : requireFiniteVec3$4(value, label);
   if (Math.abs(scale2[0]) < 1e-12 || Math.abs(scale2[1]) < 1e-12 || Math.abs(scale2[2]) < 1e-12) {
     throw new Error(`${label} must have finite non-zero components, got ${formatValidationValue(value)}`);
   }
@@ -1449,7 +1449,7 @@ class Transform {
   static rotationAxis(axis, angleDeg, pivot = [0, 0, 0]) {
     const [ux, uy, uz] = normalizeVec3$4(requireNonZeroFiniteVec3(axis, "Transform.rotationAxis() axis"));
     const degrees2 = requireFiniteNumber$1(angleDeg, "Transform.rotationAxis() angleDeg");
-    const [px, py, pz] = requireFiniteVec3$2(pivot, "Transform.rotationAxis() pivot");
+    const [px, py, pz] = requireFiniteVec3$4(pivot, "Transform.rotationAxis() pivot");
     const rad = degrees2 * Math.PI / 180;
     const cos2 = Math.cos(rad);
     const sin2 = Math.sin(rad);
@@ -1470,9 +1470,9 @@ class Transform {
   /** Solve the rotation needed to move one point onto a target line or plane. */
   static rotateAroundTo(axis, pivot, movingPoint, targetPoint, options = {}) {
     const rotateAxis = requireNonZeroFiniteVec3(axis, "Transform.rotateAroundTo() axis");
-    const rotatePivot = requireFiniteVec3$2(pivot, "Transform.rotateAroundTo() pivot");
-    const moving = requireFiniteVec3$2(movingPoint, "Transform.rotateAroundTo() movingPoint");
-    const target = requireFiniteVec3$2(targetPoint, "Transform.rotateAroundTo() targetPoint");
+    const rotatePivot = requireFiniteVec3$4(pivot, "Transform.rotateAroundTo() pivot");
+    const moving = requireFiniteVec3$4(movingPoint, "Transform.rotateAroundTo() movingPoint");
+    const target = requireFiniteVec3$4(targetPoint, "Transform.rotateAroundTo() targetPoint");
     const angleDeg = solveRotateAroundAngle(rotateAxis, rotatePivot, moving, target, options);
     return Transform.rotationAxis(rotateAxis, angleDeg, rotatePivot);
   }
@@ -1502,6 +1502,7 @@ class Transform {
     return this.rotateAxis([0, 0, 1], angleDeg, pivot);
   }
   /** Scale after the current transform. */
+  // biome-ignore lint/suspicious/useAdjacentOverloadSignatures: Static Transform.scale() and chainable instance scale() intentionally share the CAD API name.
   scale(v) {
     return this.mul(Transform.scale(v));
   }
@@ -1511,11 +1512,11 @@ class Transform {
   }
   /** Transform a point using homogeneous coordinates. */
   point(p2) {
-    return transformPoint$1(this.m, requireFiniteVec3$2(p2, "Transform.point() point"), 1);
+    return transformPoint$1(this.m, requireFiniteVec3$4(p2, "Transform.point() point"), 1);
   }
   /** Transform a direction vector without translation. */
   vector(v) {
-    return transformPoint$1(this.m, requireFiniteVec3$2(v, "Transform.vector() vector"), 0);
+    return transformPoint$1(this.m, requireFiniteVec3$4(v, "Transform.vector() vector"), 0);
   }
   /** Return the transform as a raw 4x4 matrix array. */
   toArray() {
@@ -3245,7 +3246,7 @@ const EPSILON$4 = 1e-9;
 function add$6(a2, b) {
   return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
 }
-function scale$6(v, factor) {
+function scale$7(v, factor) {
   return [v[0] * factor, v[1] * factor, v[2] * factor];
 }
 function sub$8(a2, b) {
@@ -3260,9 +3261,9 @@ function cross$8(a2, b) {
 function rotateAroundAxis(v, axis, angleRad) {
   const c2 = Math.cos(angleRad);
   const s = Math.sin(angleRad);
-  const term1 = scale$6(v, c2);
-  const term2 = scale$6(cross$8(axis, v), s);
-  const term3 = scale$6(axis, dot$8(axis, v) * (1 - c2));
+  const term1 = scale$7(v, c2);
+  const term2 = scale$7(cross$8(axis, v), s);
+  const term3 = scale$7(axis, dot$8(axis, v) * (1 - c2));
   return add$6(add$6(term1, term2), term3);
 }
 function arcPointAt(segment, t) {
@@ -3290,7 +3291,7 @@ function routePointAt(plan, t) {
     const next = station + segment.length;
     if (target <= next || segment === plan.segments[plan.segments.length - 1]) {
       const localT = segment.length <= EPSILON$4 ? 1 : Math.max(0, Math.min(1, (target - station) / segment.length));
-      if (segment.kind === "line") return add$6(segment.from, scale$6(sub$8(segment.to, segment.from), localT));
+      if (segment.kind === "line") return add$6(segment.from, scale$7(sub$8(segment.to, segment.from), localT));
       return arcPointAt(segment, localT);
     }
     station = next;
@@ -3310,7 +3311,7 @@ function sampleRoute3DCompilePlan(plan, options) {
     pushUnique(points, start);
     for (let i = 1; i <= intervals; i += 1) {
       if (segment.kind === "line") {
-        pushUnique(points, add$6(segment.from, scale$6(sub$8(segment.to, segment.from), i / intervals)));
+        pushUnique(points, add$6(segment.from, scale$7(sub$8(segment.to, segment.from), i / intervals)));
       } else {
         pushUnique(points, arcPointAt(segment, i / intervals));
       }
@@ -5637,11 +5638,11 @@ function distSq$1(a2, b) {
   const dz = a2[2] - b[2];
   return dx * dx + dy * dy + dz * dz;
 }
-function vecLength$3(v) {
+function vecLength$4(v) {
   return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
 }
 function normalize$6(v) {
-  const len2 = vecLength$3(v);
+  const len2 = vecLength$4(v);
   if (len2 < 1e-12) return [0, 0, 0];
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
@@ -6371,14 +6372,14 @@ function resolveSdfMeshingSettings(tree, bounds, options = {}) {
   const quality = options.quality ?? "preview";
   const minEdgeLength = positiveOrDefault(options.minEdgeLength, DEFAULT_MIN_EDGE_LENGTH);
   const maxGridPoints = positiveOrDefault(options.maxGridPoints, DEFAULT_MAX_GRID_POINTS);
-  const tolerance = options.tolerance !== void 0 ? requirePositiveFinite$3(options.tolerance, "SDF tolerance") : void 0;
-  const minFeatureSize = options.minFeatureSize !== void 0 ? requirePositiveFinite$3(options.minFeatureSize, "SDF minFeatureSize") : void 0;
-  const maxTriangles = options.maxTriangles !== void 0 ? Math.floor(requirePositiveFinite$3(options.maxTriangles, "SDF maxTriangles")) : void 0;
+  const tolerance = options.tolerance !== void 0 ? requirePositiveFinite$4(options.tolerance, "SDF tolerance") : void 0;
+  const minFeatureSize = options.minFeatureSize !== void 0 ? requirePositiveFinite$4(options.minFeatureSize, "SDF minFeatureSize") : void 0;
+  const maxTriangles = options.maxTriangles !== void 0 ? Math.floor(requirePositiveFinite$4(options.maxTriangles, "SDF maxTriangles")) : void 0;
   const analysis = analyzeSdfTree(tree);
   const warnings = [];
   let edgeLength;
   if (options.edgeLength !== void 0) {
-    edgeLength = requirePositiveFinite$3(options.edgeLength, "SDF edgeLength");
+    edgeLength = requirePositiveFinite$4(options.edgeLength, "SDF edgeLength");
     if (edgeLength < minEdgeLength) {
       warnings.push(`edgeLength ${formatMm(edgeLength)} was clamped to minimum ${formatMm(minEdgeLength)}.`);
       edgeLength = minEdgeLength;
@@ -6471,8 +6472,8 @@ function resolveDefaultEdgeLength(bounds, quality, minEdgeLength, analysis, opti
   const maxDim = Math.max(dx, dy, dz, minEdgeLength);
   const divisor = quality === "draft" ? 60 : quality === "export" ? 160 : 100;
   const candidates = [maxDim / divisor];
-  if (options.tolerance !== void 0) candidates.push(requirePositiveFinite$3(options.tolerance, "SDF tolerance") * 2);
-  if (options.minFeatureSize !== void 0) candidates.push(requirePositiveFinite$3(options.minFeatureSize, "SDF minFeatureSize") / 2.5);
+  if (options.tolerance !== void 0) candidates.push(requirePositiveFinite$4(options.tolerance, "SDF tolerance") * 2);
+  if (options.minFeatureSize !== void 0) candidates.push(requirePositiveFinite$4(options.minFeatureSize, "SDF minFeatureSize") / 2.5);
   if (analysis.minMetricTpmsThickness < Infinity) candidates.push(analysis.minMetricTpmsThickness / 2);
   if (analysis.minTpmsCellSize < Infinity) candidates.push(analysis.minTpmsCellSize / 10);
   if (analysis.minRepeatSpacing < Infinity) candidates.push(analysis.minRepeatSpacing / 8);
@@ -6612,9 +6613,9 @@ function visitSdfNode(node, analysis) {
 }
 function positiveOrDefault(value, fallback) {
   if (value === void 0) return fallback;
-  return requirePositiveFinite$3(value, "SDF meshing option");
+  return requirePositiveFinite$4(value, "SDF meshing option");
 }
-function requirePositiveFinite$3(value, name) {
+function requirePositiveFinite$4(value, name) {
   if (!Number.isFinite(value) || value <= 0) {
     throw new Error(`${name} must be a positive finite number.`);
   }
@@ -8598,7 +8599,7 @@ function midpoint$3(a2, b) {
 function add$5(a2, b) {
   return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
 }
-function scale$5(v, s) {
+function scale$6(v, s) {
   return [v[0] * s, v[1] * s, v[2] * s];
 }
 function sub$7(a2, b) {
@@ -8627,7 +8628,7 @@ function average$1(points) {
   for (const point2 of points) {
     acc = add$5(acc, point2);
   }
-  return scale$5(acc, 1 / points.length);
+  return scale$6(acc, 1 / points.length);
 }
 function buildSurfaceSheetTopology(boundaries, options = {}) {
   var _a3, _b3, _c2, _d2;
@@ -8773,7 +8774,7 @@ function edgeCurveFaceName(curve) {
 function dotVec3$3(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
-function vecLength$2(v) {
+function vecLength$3(v) {
   return Math.hypot(v[0], v[1], v[2]);
 }
 function sameScalar$2(a2, b) {
@@ -8783,9 +8784,9 @@ function uniformDistanceScale(matrix) {
   const xAxis = [matrix[0], matrix[1], matrix[2]];
   const yAxis = [matrix[4], matrix[5], matrix[6]];
   const zAxis = [matrix[8], matrix[9], matrix[10]];
-  const sx = vecLength$2(xAxis);
-  const sy = vecLength$2(yAxis);
-  const sz = vecLength$2(zAxis);
+  const sx = vecLength$3(xAxis);
+  const sy = vecLength$3(yAxis);
+  const sz = vecLength$3(zAxis);
   if (sx <= 1e-9 || sy <= 1e-9 || sz <= 1e-9) return null;
   if (!sameScalar$2(sx, sy) || !sameScalar$2(sx, sz)) return null;
   const orthoTolerance = 1e-9 * Math.max(1, sx * sx);
@@ -8796,7 +8797,7 @@ function uniformDistanceScale(matrix) {
 }
 function transformSurfaceAxis(tx, axis) {
   const transformed = tx.vector(axis);
-  const length4 = vecLength$2(transformed);
+  const length4 = vecLength$3(transformed);
   return length4 > 1e-9 ? [transformed[0] / length4, transformed[1] / length4, transformed[2] / length4] : null;
 }
 function transformFaceSurface(surface, tx) {
@@ -9755,7 +9756,7 @@ let _wasm$1 = null;
 async function initManifoldWasm() {
   if (_wasm$1) return _wasm$1;
   performance.mark("manifold:start");
-  const Module = (await import("./manifold-BRI5prcH.js")).default;
+  const Module = (await import("./manifold-rZexZI0G.js")).default;
   performance.mark("manifold:imported");
   const wasm = await Module();
   wasm.setup();
@@ -18408,7 +18409,7 @@ function add$4(a2, b) {
 function sub$6(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
-function scale$4(v, scalar) {
+function scale$5(v, scalar) {
   return [v[0] * scalar, v[1] * scalar, v[2] * scalar];
 }
 function cross$6(a2, b) {
@@ -18657,7 +18658,7 @@ function createBoundedHalfSpace(bounds, normal, originOffset) {
   const n = [normal[0] / normalLength, normal[1] / normalLength, normal[2] / normalLength];
   const signedOffset = originOffset / normalLength;
   const corners = boundsCorners(bounds);
-  const planeOrigin = scale$4(n, signedOffset);
+  const planeOrigin = scale$5(n, signedOffset);
   const { uAxis, vAxis } = perpendicularAxes(n);
   const diagonal = Math.hypot(bounds.max[0] - bounds.min[0], bounds.max[1] - bounds.min[1], bounds.max[2] - bounds.min[2]);
   const margin = Math.max(diagonal * 0.05, 1e-3);
@@ -18682,7 +18683,7 @@ function createBoundedHalfSpace(bounds, normal, originOffset) {
   const height = Math.max(maxDistance + margin, margin);
   const centerU = (minU + maxU) / 2;
   const centerV = (minV + maxV) / 2;
-  const translation = add$4(add$4(planeOrigin, scale$4(uAxis, centerU)), scale$4(vAxis, centerV));
+  const translation = add$4(add$4(planeOrigin, scale$5(uAxis, centerU)), scale$5(vAxis, centerV));
   const matrix = [
     uAxis[0],
     uAxis[1],
@@ -27870,7 +27871,7 @@ function placementReferenceNames(refs, kind) {
     (entryKind) => Object.keys(refs[entryKind]).sort().map((name) => `${entryKind}.${name}`)
   );
 }
-function requireFiniteVec3$1(v, label) {
+function requireFiniteVec3$3(v, label) {
   const [x2, y2, z2] = v;
   if (!Number.isFinite(x2) || !Number.isFinite(y2) || !Number.isFinite(z2)) {
     throw new Error(`${label} must contain finite numbers, got [${x2}, ${y2}, ${z2}]`);
@@ -27910,8 +27911,8 @@ function normalizePortInput(input) {
   const hasStartEnd = input.start != null && input.end != null;
   const hasOriginAxis = input.origin != null && input.axis != null;
   if (hasStartEnd) {
-    const start = requireFiniteVec3$1(input.start, "port start");
-    const end = requireFiniteVec3$1(input.end, "port end");
+    const start = requireFiniteVec3$3(input.start, "port start");
+    const end = requireFiniteVec3$3(input.end, "port end");
     origin = [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2, (start[2] + end[2]) / 2];
     const dir = [end[0] - start[0], end[1] - start[1], end[2] - start[2]];
     const dirLen = len3$2(dir);
@@ -27920,11 +27921,11 @@ function normalizePortInput(input) {
     }
     axis = normalize3$2(dir);
     extent = dirLen / 2;
-    if (input.origin != null) origin = requireFiniteVec3$1(input.origin, "port origin");
-    if (input.axis != null) axis = normalize3$2(requireFiniteVec3$1(input.axis, "port axis"));
+    if (input.origin != null) origin = requireFiniteVec3$3(input.origin, "port origin");
+    if (input.axis != null) axis = normalize3$2(requireFiniteVec3$3(input.axis, "port axis"));
   } else if (hasOriginAxis) {
-    origin = requireFiniteVec3$1(input.origin, "port origin");
-    const rawAxis = requireFiniteVec3$1(input.axis, "port axis");
+    origin = requireFiniteVec3$3(input.origin, "port origin");
+    const rawAxis = requireFiniteVec3$3(input.axis, "port axis");
     if (len3$2(rawAxis) < 1e-10) {
       throw new Error("Port axis must be non-zero");
     }
@@ -27933,14 +27934,14 @@ function normalizePortInput(input) {
       extent = input.extent;
     }
   } else if (input.origin != null) {
-    origin = requireFiniteVec3$1(input.origin, "port origin");
+    origin = requireFiniteVec3$3(input.origin, "port origin");
     axis = [0, 0, 1];
   } else {
     throw new Error("Port requires either { origin, axis } or { start, end }");
   }
   let up;
   if (input.up != null) {
-    const rawUp = requireFiniteVec3$1(input.up, "port up");
+    const rawUp = requireFiniteVec3$3(input.up, "port up");
     if (len3$2(rawUp) < 1e-10) {
       throw new Error("Port up vector must be non-zero");
     }
@@ -29315,7 +29316,7 @@ class ShapeGroup {
     return { min: bb.min, max: bb.max };
   }
   resolveRotatePoint(point2) {
-    if (Array.isArray(point2)) return requireFiniteVec3$2(point2, "ShapeGroup.rotateAroundTo() point");
+    if (Array.isArray(point2)) return requireFiniteVec3$4(point2, "ShapeGroup.rotateAroundTo() point");
     const bb = this._bbox();
     return resolveAnchor3D(bb.min, bb.max, point2);
   }
@@ -29368,7 +29369,7 @@ class ShapeGroup {
     const sp = resolveAnchor3D(sbb.min, sbb.max, selfAnchor);
     let dx = tp[0] - sp[0], dy = tp[1] - sp[1], dz = tp[2] - sp[2];
     if (offset2) {
-      const offsetPoint = requireFiniteVec3$2(offset2, "ShapeGroup.attachTo() offset");
+      const offsetPoint = requireFiniteVec3$4(offset2, "ShapeGroup.attachTo() offset");
       dx += offsetPoint[0];
       dy += offsetPoint[1];
       dz += offsetPoint[2];
@@ -29423,7 +29424,7 @@ class ShapeGroup {
   rotateAroundAxis(axis, angleDeg, pivot = [0, 0, 0]) {
     const rotateAxis = requireNonZeroFiniteVec3(axis, "ShapeGroup.rotateAroundAxis() axis");
     const degrees2 = requireFiniteNumber$1(angleDeg, "ShapeGroup.rotateAroundAxis() angleDeg");
-    const rotatePivot = requireFiniteVec3$2(pivot, "ShapeGroup.rotateAroundAxis() pivot");
+    const rotatePivot = requireFiniteVec3$4(pivot, "ShapeGroup.rotateAroundAxis() pivot");
     return this.transform(Transform.rotationAxis(rotateAxis, degrees2, rotatePivot));
   }
   /**
@@ -29432,7 +29433,7 @@ class ShapeGroup {
    */
   rotateAroundTo(axis, pivot, movingPoint, targetPoint, options = {}) {
     const rotateAxis = requireNonZeroFiniteVec3(axis, "ShapeGroup.rotateAroundTo() axis");
-    const rotatePivot = requireFiniteVec3$2(pivot, "ShapeGroup.rotateAroundTo() pivot");
+    const rotatePivot = requireFiniteVec3$4(pivot, "ShapeGroup.rotateAroundTo() pivot");
     return this.transform(
       Transform.rotateAroundTo(
         rotateAxis,
@@ -29483,7 +29484,7 @@ class ShapeGroup {
   /** Scale uniformly or per-axis from an explicit pivot point. */
   scaleAround(pivot, v) {
     const scale2 = requireNonZeroFiniteScale3(v, "ShapeGroup.scaleAround() scale");
-    const scalePivot = requireFiniteVec3$2(pivot, "ShapeGroup.scaleAround() pivot");
+    const scalePivot = requireFiniteVec3$4(pivot, "ShapeGroup.scaleAround() pivot");
     const matrix = Transform.scale(scale2).toArray();
     if (scalePivot[0] === 0 && scalePivot[1] === 0 && scalePivot[2] === 0) {
       return this.mapChildrenTransform((c2) => {
@@ -29506,7 +29507,7 @@ class ShapeGroup {
   }
   /** Mirror across a plane through an explicit point. */
   mirrorThrough(point2, normal) {
-    const mirrorPoint = requireFiniteVec3$2(point2, "ShapeGroup.mirrorThrough() point");
+    const mirrorPoint = requireFiniteVec3$4(point2, "ShapeGroup.mirrorThrough() point");
     const mirrorNormal = requireNonZeroFiniteVec3(normal, "ShapeGroup.mirrorThrough() normal");
     const matrix = mirrorPlaneMatrix(mirrorNormal);
     if (mirrorPoint[0] === 0 && mirrorPoint[1] === 0 && mirrorPoint[2] === 0) {
@@ -29594,8 +29595,8 @@ class ShapeGroup {
    * ```
    */
   placeReference(ref, target, offset2) {
-    const targetPoint = requireFiniteVec3$2(target, "ShapeGroup.placeReference() target");
-    const offsetPoint = offset2 === void 0 ? void 0 : requireFiniteVec3$2(offset2, "ShapeGroup.placeReference() offset");
+    const targetPoint = requireFiniteVec3$4(target, "ShapeGroup.placeReference() target");
+    const offsetPoint = offset2 === void 0 ? void 0 : requireFiniteVec3$4(offset2, "ShapeGroup.placeReference() offset");
     const sourcePoint = this.referencePoint(ref);
     let dx = targetPoint[0] - sourcePoint[0];
     let dy = targetPoint[1] - sourcePoint[1];
@@ -31785,7 +31786,7 @@ function buildSdfFunctionDefinition(source, options) {
     jsExpression: expression,
     ...shader.ok ? { shaderExpression: shader.expression } : { shaderUnsupportedReason: shader.reason },
     raymarchStepLimit: resolveRaymarchStepLimit(options.bounds, options.maxStep),
-    ...options.lipschitz !== void 0 ? { raymarchLipschitz: requirePositiveFinite$2(options.lipschitz, "sdf.fromFunction() lipschitz") } : {}
+    ...options.lipschitz !== void 0 ? { raymarchLipschitz: requirePositiveFinite$3(options.lipschitz, "sdf.fromFunction() lipschitz") } : {}
   };
 }
 function extractSdfExpression(source) {
@@ -31953,7 +31954,7 @@ function formatNumericLiteralsForGlsl(source) {
   return result;
 }
 function resolveRaymarchStepLimit(bounds, maxStep) {
-  if (maxStep !== void 0) return requirePositiveFinite$2(maxStep, "sdf.fromFunction() maxStep");
+  if (maxStep !== void 0) return requirePositiveFinite$3(maxStep, "sdf.fromFunction() maxStep");
   const dx = bounds.max[0] - bounds.min[0];
   const dy = bounds.max[1] - bounds.min[1];
   const dz = bounds.max[2] - bounds.min[2];
@@ -31961,7 +31962,7 @@ function resolveRaymarchStepLimit(bounds, maxStep) {
   if (!Number.isFinite(diagonal) || diagonal <= 0) return 0.1;
   return Math.max(0.025, Math.min(0.5, diagonal / 240));
 }
-function requirePositiveFinite$2(value, label) {
+function requirePositiveFinite$3(value, label) {
   if (!Number.isFinite(value) || value <= 0) throw new Error(`${label} must be a positive finite number.`);
   return value;
 }
@@ -32074,7 +32075,7 @@ class Pattern2DBuilder {
     return new Pattern2DImpl({
       kind: "surfacePattern:sineWave",
       direction: normalizeDirection$1(options.direction ?? [1, 0], "sdf.pattern2d().sineWave() direction"),
-      wavelength: requirePositiveFinite$1(options.wavelength, "sdf.pattern2d().sineWave() wavelength"),
+      wavelength: requirePositiveFinite$2(options.wavelength, "sdf.pattern2d().sineWave() wavelength"),
       amplitude: requireFinite$a(options.amplitude ?? 1, "sdf.pattern2d().sineWave() amplitude"),
       phase: requireFinite$a(options.phase ?? 0, "sdf.pattern2d().sineWave() phase"),
       bias: requireFinite$a(options.bias ?? 0, "sdf.pattern2d().sineWave() bias")
@@ -32085,19 +32086,19 @@ class Pattern2DBuilder {
     return new Pattern2DImpl({
       kind: "surfacePattern:stripes",
       direction: normalizeDirection$1(options.direction ?? [1, 0], "sdf.pattern2d().stripes() direction"),
-      spacing: requirePositiveFinite$1(options.spacing, "sdf.pattern2d().stripes() spacing"),
-      width: requirePositiveFinite$1(options.width, "sdf.pattern2d().stripes() width"),
-      depth: requireNonNegativeFinite$1(options.depth ?? 1, "sdf.pattern2d().stripes() depth")
+      spacing: requirePositiveFinite$2(options.spacing, "sdf.pattern2d().stripes() spacing"),
+      width: requirePositiveFinite$2(options.width, "sdf.pattern2d().stripes() width"),
+      depth: requireNonNegativeFinite$2(options.depth ?? 1, "sdf.pattern2d().stripes() depth")
     });
   }
   /** Create an over-under woven relief pattern in UV space. */
   overUnderWeave(options) {
     return new Pattern2DImpl({
       kind: "surfacePattern:overUnderWeave",
-      spacing: normalizeVec2(options.spacing, "sdf.pattern2d().overUnderWeave() spacing", requirePositiveFinite$1),
-      threadWidth: normalizeVec2(options.threadWidth, "sdf.pattern2d().overUnderWeave() threadWidth", requirePositiveFinite$1),
-      depth: requireNonNegativeFinite$1(options.depth ?? 0.8, "sdf.pattern2d().overUnderWeave() depth"),
-      underScale: requireNonNegativeFinite$1(options.underScale ?? 0.15, "sdf.pattern2d().overUnderWeave() underScale")
+      spacing: normalizeVec2(options.spacing, "sdf.pattern2d().overUnderWeave() spacing", requirePositiveFinite$2),
+      threadWidth: normalizeVec2(options.threadWidth, "sdf.pattern2d().overUnderWeave() threadWidth", requirePositiveFinite$2),
+      depth: requireNonNegativeFinite$2(options.depth ?? 0.8, "sdf.pattern2d().overUnderWeave() depth"),
+      underScale: requireNonNegativeFinite$2(options.underScale ?? 0.15, "sdf.pattern2d().overUnderWeave() underScale")
     });
   }
 }
@@ -32120,13 +32121,13 @@ function requireFinite$a(value, label) {
   }
   return value;
 }
-function requirePositiveFinite$1(value, label) {
+function requirePositiveFinite$2(value, label) {
   if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
     throw new Error(`${label} must be a positive finite number. Received: ${String(value)}`);
   }
   return value;
 }
-function requireNonNegativeFinite$1(value, label) {
+function requireNonNegativeFinite$2(value, label) {
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
     throw new Error(`${label} must be a non-negative finite number. Received: ${String(value)}`);
   }
@@ -32244,7 +32245,7 @@ Fix: use a known preset or pass material props directly.`
     material: validateMaterialProps(material)
   };
 }
-function requirePositiveFinite(value, label) {
+function requirePositiveFinite$1(value, label) {
   if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
     throw new Error(`${label} must be a positive finite number. Received: ${String(value)}`);
   }
@@ -32256,15 +32257,15 @@ function requirePositiveInteger(value, label) {
   }
   return value;
 }
-function requireNonNegativeFinite(value, label) {
+function requireNonNegativeFinite$1(value, label) {
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
     throw new Error(`${label} must be a non-negative finite number. Received: ${String(value)}`);
   }
   return value;
 }
 function resolveBlendRadius(input, label, fallback = 4) {
-  if (typeof input === "number") return requirePositiveFinite(input, `${label} radius`);
-  if ((input == null ? void 0 : input.radius) !== void 0) return requirePositiveFinite(input.radius, `${label} radius`);
+  if (typeof input === "number") return requirePositiveFinite$1(input, `${label} radius`);
+  if ((input == null ? void 0 : input.radius) !== void 0) return requirePositiveFinite$1(input.radius, `${label} radius`);
   return fallback;
 }
 function formatExpressionNumber(value) {
@@ -32274,7 +32275,7 @@ function formatExpressionNumber(value) {
 }
 function roundedBoxNode(halfExtents, radius) {
   const minHalf = Math.min(halfExtents[0], halfExtents[1], halfExtents[2]);
-  const r = Math.min(requirePositiveFinite(radius, "SdfShape.round() radius"), Math.max(1e-3, minHalf - 1e-3));
+  const r = Math.min(requirePositiveFinite$1(radius, "SdfShape.round() radius"), Math.max(1e-3, minHalf - 1e-3));
   const inner = [halfExtents[0] - r, halfExtents[1] - r, halfExtents[2] - r];
   const [ix, iy, iz] = inner.map(formatExpressionNumber);
   const rr = formatExpressionNumber(r);
@@ -32517,9 +32518,9 @@ class SdfShape {
   clipBox(x2, y2, z2) {
     return this.intersect(
       box$1(
-        requirePositiveFinite(x2, "SdfShape.clipBox() x"),
-        requirePositiveFinite(y2, "SdfShape.clipBox() y"),
-        requirePositiveFinite(z2, "SdfShape.clipBox() z")
+        requirePositiveFinite$1(x2, "SdfShape.clipBox() x"),
+        requirePositiveFinite$1(y2, "SdfShape.clipBox() y"),
+        requirePositiveFinite$1(z2, "SdfShape.clipBox() z")
       )
     );
   }
@@ -32551,7 +32552,7 @@ class SdfShape {
     return this.withNode({
       kind: "sdf:smoothUnion",
       children: [this._node, other._node],
-      radius: requirePositiveFinite(radius, "SdfShape.smoothUnion() radius")
+      radius: requirePositiveFinite$1(radius, "SdfShape.smoothUnion() radius")
     });
   }
   /** Smooth difference — smoothly carves other from this. */
@@ -32559,7 +32560,7 @@ class SdfShape {
     return this.withNode({
       kind: "sdf:smoothDifference",
       children: [this._node, other._node],
-      radius: requirePositiveFinite(radius, "SdfShape.smoothSubtract() radius")
+      radius: requirePositiveFinite$1(radius, "SdfShape.smoothSubtract() radius")
     });
   }
   /** Smooth intersection — smoothly intersects. */
@@ -32567,7 +32568,7 @@ class SdfShape {
     return this.withNode({
       kind: "sdf:smoothIntersection",
       children: [this._node, other._node],
-      radius: requirePositiveFinite(radius, "SdfShape.smoothIntersect() radius")
+      radius: requirePositiveFinite$1(radius, "SdfShape.smoothIntersect() radius")
     });
   }
   /** Morph between this shape and another. t=0 → this, t=1 → other. */
@@ -32625,7 +32626,7 @@ class SdfShape {
   }
   /** Uniformly scale this SDF around the origin. */
   scale(factor) {
-    return this.withNode({ kind: "sdf:scale", child: this._node, factor: requirePositiveFinite(factor, "SdfShape.scale() factor") });
+    return this.withNode({ kind: "sdf:scale", child: this._node, factor: requirePositiveFinite$1(factor, "SdfShape.scale() factor") });
   }
   // ── Domain operations ──
   /** Twist around the Z axis. */
@@ -32638,15 +32639,15 @@ class SdfShape {
   }
   /** Bend around the Z axis with given radius. */
   bend(radius) {
-    return this.withNode({ kind: "sdf:bend", child: this._node, radius: requirePositiveFinite(radius, "SdfShape.bend() radius") });
+    return this.withNode({ kind: "sdf:bend", child: this._node, radius: requirePositiveFinite$1(radius, "SdfShape.bend() radius") });
   }
   /** Repeat in space. Spacing of 0 on an axis means no repetition. Count of 0 = infinite. */
   repeat(spacing, count) {
     return this.withNode({
       kind: "sdf:repeat",
       child: this._node,
-      spacing: requireFiniteVec3$2(spacing, "SdfShape.repeat() spacing"),
-      count: count === void 0 ? [0, 0, 0] : requireFiniteVec3$2(count, "SdfShape.repeat() count")
+      spacing: requireFiniteVec3$4(spacing, "SdfShape.repeat() spacing"),
+      count: count === void 0 ? [0, 0, 0] : requireFiniteVec3$4(count, "SdfShape.repeat() count")
     });
   }
   /**
@@ -32661,7 +32662,7 @@ class SdfShape {
       kind: "sdf:circularArray",
       child: this._node,
       count: requirePositiveInteger(count, "SdfShape.circularArray() count"),
-      offset: requireNonNegativeFinite(offset2, "SdfShape.circularArray() offset")
+      offset: requireNonNegativeFinite$1(offset2, "SdfShape.circularArray() offset")
     });
   }
   /** Hollow out, keeping only a shell of given thickness. */
@@ -32669,7 +32670,7 @@ class SdfShape {
     return this.withNode({
       kind: "sdf:shell",
       child: this._node,
-      thickness: requirePositiveFinite(thickness, "SdfShape.shell() thickness")
+      thickness: requirePositiveFinite$1(thickness, "SdfShape.shell() thickness")
     });
   }
   /**
@@ -32749,70 +32750,70 @@ class SdfShape {
       kind: "sdf:onion",
       child: this._node,
       layers: requirePositiveInteger(layers, "SdfShape.onion() layers"),
-      thickness: requirePositiveFinite(thickness, "SdfShape.onion() thickness")
+      thickness: requirePositiveFinite$1(thickness, "SdfShape.onion() thickness")
     });
   }
 }
 function sphere$1(radius) {
-  return new SdfShape({ kind: "sdf:sphere", radius: requirePositiveFinite(radius, "sdf.sphere() radius") });
+  return new SdfShape({ kind: "sdf:sphere", radius: requirePositiveFinite$1(radius, "sdf.sphere() radius") });
 }
 function box$1(x2, y2, z2) {
   return new SdfShape({
     kind: "sdf:box",
     halfExtents: [
-      requirePositiveFinite(x2, "sdf.box() x") / 2,
-      requirePositiveFinite(y2, "sdf.box() y") / 2,
-      requirePositiveFinite(z2, "sdf.box() z") / 2
+      requirePositiveFinite$1(x2, "sdf.box() x") / 2,
+      requirePositiveFinite$1(y2, "sdf.box() y") / 2,
+      requirePositiveFinite$1(z2, "sdf.box() z") / 2
     ]
   });
 }
 function cylinder$1(height, radius) {
   return new SdfShape({
     kind: "sdf:cylinder",
-    height: requirePositiveFinite(height, "sdf.cylinder() height"),
-    radius: requirePositiveFinite(radius, "sdf.cylinder() radius")
+    height: requirePositiveFinite$1(height, "sdf.cylinder() height"),
+    radius: requirePositiveFinite$1(radius, "sdf.cylinder() radius")
   });
 }
 function torus$1(majorRadius, minorRadius) {
   return new SdfShape({
     kind: "sdf:torus",
-    majorRadius: requirePositiveFinite(majorRadius, "sdf.torus() majorRadius"),
-    minorRadius: requirePositiveFinite(minorRadius, "sdf.torus() minorRadius")
+    majorRadius: requirePositiveFinite$1(majorRadius, "sdf.torus() majorRadius"),
+    minorRadius: requirePositiveFinite$1(minorRadius, "sdf.torus() minorRadius")
   });
 }
 function capsule(height, radius) {
   return new SdfShape({
     kind: "sdf:capsule",
-    height: requirePositiveFinite(height, "sdf.capsule() height"),
-    radius: requirePositiveFinite(radius, "sdf.capsule() radius")
+    height: requirePositiveFinite$1(height, "sdf.capsule() height"),
+    radius: requirePositiveFinite$1(radius, "sdf.capsule() radius")
   });
 }
 function cone(height, radius) {
   return new SdfShape({
     kind: "sdf:cone",
-    height: requirePositiveFinite(height, "sdf.cone() height"),
-    radius: requirePositiveFinite(radius, "sdf.cone() radius")
+    height: requirePositiveFinite$1(height, "sdf.cone() height"),
+    radius: requirePositiveFinite$1(radius, "sdf.cone() radius")
   });
 }
 function smoothUnion(a2, b, options) {
   return new SdfShape({
     kind: "sdf:smoothUnion",
     children: [a2._node, b._node],
-    radius: requirePositiveFinite(options.radius, "sdf.smoothUnion() radius")
+    radius: requirePositiveFinite$1(options.radius, "sdf.smoothUnion() radius")
   });
 }
 function smoothDifference(a2, b, options) {
   return new SdfShape({
     kind: "sdf:smoothDifference",
     children: [a2._node, b._node],
-    radius: requirePositiveFinite(options.radius, "sdf.smoothDifference() radius")
+    radius: requirePositiveFinite$1(options.radius, "sdf.smoothDifference() radius")
   });
 }
 function smoothIntersection(a2, b, options) {
   return new SdfShape({
     kind: "sdf:smoothIntersection",
     children: [a2._node, b._node],
-    radius: requirePositiveFinite(options.radius, "sdf.smoothIntersection() radius")
+    radius: requirePositiveFinite$1(options.radius, "sdf.smoothIntersection() radius")
   });
 }
 function morph(a2, b, t) {
@@ -32995,9 +32996,9 @@ function weave(options) {
   });
 }
 function basketWeave(options) {
-  const SP = requirePositiveFinite((options == null ? void 0 : options.spacing) ?? 3, "sdf.basketWeave() spacing");
-  const TW = requirePositiveFinite((options == null ? void 0 : options.threadWidth) ?? 1.5, "sdf.basketWeave() threadWidth");
-  const D2 = requireNonNegativeFinite((options == null ? void 0 : options.depth) ?? 0.8, "sdf.basketWeave() depth");
+  const SP = requirePositiveFinite$1((options == null ? void 0 : options.spacing) ?? 3, "sdf.basketWeave() spacing");
+  const TW = requirePositiveFinite$1((options == null ? void 0 : options.threadWidth) ?? 1.5, "sdf.basketWeave() threadWidth");
+  const D2 = requireNonNegativeFinite$1((options == null ? void 0 : options.depth) ?? 0.8, "sdf.basketWeave() depth");
   return pattern2d().overUnderWeave({ spacing: SP, threadWidth: TW, depth: D2 });
 }
 function fromFunction(fn, options) {
@@ -33026,18 +33027,18 @@ function twist(shape, degreesPerUnit) {
   return shape.twist(requireFiniteNumber$1(degreesPerUnit, "sdf.twist() degreesPerUnit"));
 }
 function bend(shape, radius) {
-  return shape.bend(requirePositiveFinite(radius, "sdf.bend() radius"));
+  return shape.bend(requirePositiveFinite$1(radius, "sdf.bend() radius"));
 }
 function repeat(shape, spacing, count) {
   return shape.repeat(
-    requireFiniteVec3$2(spacing, "sdf.repeat() spacing"),
-    count === void 0 ? void 0 : requireFiniteVec3$2(count, "sdf.repeat() count")
+    requireFiniteVec3$4(spacing, "sdf.repeat() spacing"),
+    count === void 0 ? void 0 : requireFiniteVec3$4(count, "sdf.repeat() count")
   );
 }
 function circularArray(shape, count, offset2 = 0) {
   return shape.circularArray(
     requirePositiveInteger(count, "sdf.circularArray() count"),
-    requireNonNegativeFinite(offset2, "sdf.circularArray() offset")
+    requireNonNegativeFinite$1(offset2, "sdf.circularArray() offset")
   );
 }
 function resolveTpmsOptions(options) {
@@ -33818,11 +33819,11 @@ function mergeTopology(base, overlay) {
   return merged;
 }
 const ANALYTIC_SURFACE_EPS = 1e-9;
-function vecLength$1(v) {
+function vecLength$2(v) {
   return Math.hypot(v[0], v[1], v[2]);
 }
 function normalizeVec3OrNull(v) {
-  const length4 = vecLength$1(v);
+  const length4 = vecLength$2(v);
   return length4 > ANALYTIC_SURFACE_EPS ? [v[0] / length4, v[1] / length4, v[2] / length4] : null;
 }
 function dotVec3$1(a2, b) {
@@ -33874,9 +33875,9 @@ function matrixUniformDistanceScale(matrix) {
   const xAxis = [matrix[0], matrix[1], matrix[2]];
   const yAxis = [matrix[4], matrix[5], matrix[6]];
   const zAxis = [matrix[8], matrix[9], matrix[10]];
-  const sx = vecLength$1(xAxis);
-  const sy = vecLength$1(yAxis);
-  const sz = vecLength$1(zAxis);
+  const sx = vecLength$2(xAxis);
+  const sy = vecLength$2(yAxis);
+  const sz = vecLength$2(zAxis);
   if (sx <= ANALYTIC_SURFACE_EPS || sy <= ANALYTIC_SURFACE_EPS || sz <= ANALYTIC_SURFACE_EPS) return null;
   if (!sameScalar(sx, sy) || !sameScalar(sx, sz)) return null;
   const orthoTolerance = ANALYTIC_SURFACE_EPS * Math.max(1, sx * sx);
@@ -34564,7 +34565,7 @@ function withBaseDimensionsAndMergedSourceSpans(base, sources, out, preserveOutp
   return result;
 }
 function resolveRotationPoint(shape, point2) {
-  if (Array.isArray(point2)) return requireFiniteVec3$2(point2, "rotateAroundTo(): point");
+  if (Array.isArray(point2)) return requireFiniteVec3$4(point2, "rotateAroundTo(): point");
   return shape.referencePoint(point2);
 }
 function setShapeDimensions(shape, dims, options = {}) {
@@ -35456,8 +35457,8 @@ class Shape {
    * ```
    */
   placeReference(ref, target, offset2) {
-    const targetPoint = requireFiniteVec3$2(target, "Shape.placeReference() target");
-    const offsetPoint = offset2 === void 0 ? void 0 : requireFiniteVec3$2(offset2, "Shape.placeReference() offset");
+    const targetPoint = requireFiniteVec3$4(target, "Shape.placeReference() target");
+    const offsetPoint = offset2 === void 0 ? void 0 : requireFiniteVec3$4(offset2, "Shape.placeReference() offset");
     const sourcePoint = this.referencePoint(ref);
     let dx = targetPoint[0] - sourcePoint[0];
     let dy = targetPoint[1] - sourcePoint[1];
@@ -35562,7 +35563,7 @@ class Shape {
   /** Scale the shape uniformly or per-axis from an explicit pivot point. */
   scaleAround(pivot, v) {
     const scale2 = requireNonZeroFiniteScale3(v, "Shape.scaleAround() scale");
-    const scalePivot = requireFiniteVec3$2(pivot, "Shape.scaleAround() pivot");
+    const scalePivot = requireFiniteVec3$4(pivot, "Shape.scaleAround() pivot");
     if (scalePivot[0] === 0 && scalePivot[1] === 0 && scalePivot[2] === 0) {
       const nextPlan2 = appendShapeCompileTransform(getShapeCompilePlanInternal(this), {
         kind: "scale",
@@ -35600,7 +35601,7 @@ class Shape {
   }
   /** Mirror across a plane through an explicit point, defined by its normal vector. */
   mirrorThrough(point2, normal) {
-    const mirrorPoint = requireFiniteVec3$2(point2, "Shape.mirrorThrough() point");
+    const mirrorPoint = requireFiniteVec3$4(point2, "Shape.mirrorThrough() point");
     const mirrorNormal = requireNonZeroFiniteVec3(normal, "Shape.mirrorThrough() normal");
     if (mirrorPoint[0] === 0 && mirrorPoint[1] === 0 && mirrorPoint[2] === 0) {
       const transformedPlan2 = appendShapeCompileTransform(getShapeCompilePlanInternal(this), {
@@ -35658,7 +35659,7 @@ class Shape {
   rotateAroundAxis(axis, angleDeg, pivot = [0, 0, 0]) {
     const rotateAxis = requireNonZeroFiniteVec3(axis, "Shape.rotateAroundAxis() axis");
     const degrees2 = requireFiniteNumber$1(angleDeg, "Shape.rotateAroundAxis() angleDeg");
-    const rotatePivot = requireFiniteVec3$2(pivot, "Shape.rotateAroundAxis() pivot");
+    const rotatePivot = requireFiniteVec3$4(pivot, "Shape.rotateAroundAxis() pivot");
     const len2 = Math.sqrt(rotateAxis[0] ** 2 + rotateAxis[1] ** 2 + rotateAxis[2] ** 2) || 1;
     const normalizedAxis = [rotateAxis[0] / len2, rotateAxis[1] / len2, rotateAxis[2] / len2];
     const matrix = rotationAroundAxisMatrix(normalizedAxis, degrees2, rotatePivot);
@@ -35683,7 +35684,7 @@ class Shape {
    */
   rotateAroundTo(axis, pivot, movingPoint, targetPoint, options = {}) {
     const rotateAxis = requireNonZeroFiniteVec3(axis, "Shape.rotateAroundTo() axis");
-    const rotatePivot = requireFiniteVec3$2(pivot, "Shape.rotateAroundTo() pivot");
+    const rotatePivot = requireFiniteVec3$4(pivot, "Shape.rotateAroundTo() pivot");
     const moving = resolveRotationPoint(this, movingPoint);
     const target = resolveRotationPoint(this, targetPoint);
     const angleDeg = solveRotateAroundAngle(rotateAxis, rotatePivot, moving, target, options);
@@ -36006,7 +36007,7 @@ class Shape {
     const sp = this.referencePoint(selfAnchor);
     let dx = tp[0] - sp[0], dy = tp[1] - sp[1], dz = tp[2] - sp[2];
     if (offset2) {
-      const offsetPoint = requireFiniteVec3$2(offset2, "Shape.attachTo() offset");
+      const offsetPoint = requireFiniteVec3$4(offset2, "Shape.attachTo() offset");
       dx += offsetPoint[0];
       dy += offsetPoint[1];
       dz += offsetPoint[2];
@@ -38244,6 +38245,107 @@ function collectJointsView(options = {}, base = null, motionSource) {
 function jointsView(options = {}) {
   _collected$8 = collectJointsView(options, _collected$8);
 }
+function requireFiniteVec3$2(input, label) {
+  if (!Array.isArray(input) || input.length !== 3) throw new Error(`${label} must be a [x, y, z] tuple`);
+  const out = [input[0], input[1], input[2]];
+  if (!Number.isFinite(out[0]) || !Number.isFinite(out[1]) || !Number.isFinite(out[2])) {
+    throw new Error(`${label} must contain finite numbers`);
+  }
+  return out;
+}
+function vecDot$1(a2, b) {
+  return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
+}
+function vecCross$1(a2, b) {
+  return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
+}
+function vecLength$1(v) {
+  return Math.hypot(v[0], v[1], v[2]);
+}
+function vecNormalize$1(v, label) {
+  const length4 = vecLength$1(v);
+  if (length4 < 1e-10) throw new Error(`${label} must be non-zero`);
+  return [v[0] / length4, v[1] / length4, v[2] / length4];
+}
+function orthonormalizeFrame(axisInput, upInput) {
+  const axis = vecNormalize$1(axisInput, "frame axis");
+  if (vecLength$1(upInput) < 1e-10) throw new Error("frame up vector must be non-zero");
+  const upProjection = vecDot$1(upInput, axis);
+  const upOrtho = [upInput[0] - upProjection * axis[0], upInput[1] - upProjection * axis[1], upInput[2] - upProjection * axis[2]];
+  if (vecLength$1(upOrtho) < 1e-10) throw new Error("frame axis and up must not be parallel");
+  const up = vecNormalize$1(upOrtho, "frame up vector");
+  const right = vecNormalize$1(vecCross$1(up, axis), "frame right vector");
+  return { axis, up, right };
+}
+function frameTransform(origin, axisInput, upInput) {
+  const { axis, up, right } = orthonormalizeFrame(axisInput, upInput);
+  return Transform.from([
+    right[0],
+    right[1],
+    right[2],
+    0,
+    up[0],
+    up[1],
+    up[2],
+    0,
+    axis[0],
+    axis[1],
+    axis[2],
+    0,
+    origin[0],
+    origin[1],
+    origin[2],
+    1
+  ]);
+}
+function normalizeAssemblyFrame(name, input) {
+  if (!input || typeof input !== "object") throw new Error(`frame("${name}") options are required`);
+  const origin = requireFiniteVec3$2(input.origin, `frame("${name}") origin`);
+  const rawAxis = requireFiniteVec3$2(input.axis, `frame("${name}") axis`);
+  const rawUp = requireFiniteVec3$2(input.up, `frame("${name}") up`);
+  const { axis, up } = orthonormalizeFrame(rawAxis, rawUp);
+  return {
+    name,
+    origin,
+    axis,
+    up,
+    fixed: input.fixed ?? false,
+    metadata: input.metadata ? { ...input.metadata } : void 0
+  };
+}
+function cloneAssemblyFrame(frame) {
+  return {
+    name: frame.name,
+    origin: [...frame.origin],
+    axis: [...frame.axis],
+    up: [...frame.up],
+    fixed: frame.fixed,
+    metadata: frame.metadata ? { ...frame.metadata } : void 0
+  };
+}
+function cloneAssemblyFrameEdge(edge) {
+  return {
+    name: edge.name,
+    a: edge.a,
+    b: edge.b,
+    metadata: edge.metadata ? { ...edge.metadata } : void 0
+  };
+}
+function frameDefTransform(frame) {
+  return frameTransform(frame.origin, frame.axis, frame.up);
+}
+function frameFromTransform(frame, transform) {
+  return {
+    ...cloneAssemblyFrame(frame),
+    origin: transform.point([0, 0, 0]),
+    up: vecNormalize$1(transform.vector([0, 1, 0]), `solved frame "${frame.name}" up`),
+    axis: vecNormalize$1(transform.vector([0, 0, 1]), `solved frame "${frame.name}" axis`),
+    transform
+  };
+}
+function relativeFrameTransform(parent, child) {
+  return composeChain(frameDefTransform(child), frameDefTransform(parent).inverse());
+}
 var define_process_env_default$1 = {};
 let collectedAssemblies = [];
 function resetCollectedAssemblies() {
@@ -38377,12 +38479,22 @@ function motionTransform(joint2, value) {
   const dz = joint2.axis[2] * value;
   return Transform.identity().translate(dx, dy, dz);
 }
+function frameJointMotionTransform(joint2, value) {
+  if (joint2.type === "fixed") return Transform.identity();
+  if (joint2.type === "revolute") return Transform.rotationAxis([0, 0, 1], value);
+  return Transform.translation(0, 0, value);
+}
 function clampJointValue(joint2, value) {
   let clamped = Number.isFinite(value) ? value : joint2.defaultValue;
   if (joint2.min != null) clamped = Math.max(joint2.min, clamped);
   if (joint2.max != null) clamped = Math.min(joint2.max, clamped);
   return { value: clamped, wasClamped: clamped !== value };
 }
+function clampFrameJointDefault(jointName, value, min2, max2) {
+  if (min2 !== void 0 && value < min2) throw new Error(`Frame joint "${jointName}" default must be >= min`);
+  if (max2 !== void 0 && value > max2) throw new Error(`Frame joint "${jointName}" default must be <= max`);
+  return value;
+}
 function finiteVec3(input, label) {
   if (!Array.isArray(input) || input.length !== 3) throw new Error(`${label} must be a [x, y, z] tuple`);
   const out = [input[0], input[1], input[2]];
@@ -38394,6 +38506,9 @@ function finiteVec3(input, label) {
 function cloneVec3$3(v) {
   return [v[0], v[1], v[2]];
 }
+function cloneAngleReference(reference) {
+  return reference ? { kind: "worldDirection", direction: cloneVec3$3(reference.direction) } : void 0;
+}
 function vecDistance(a2, b) {
   return Math.hypot(b[0] - a2[0], b[1] - a2[1], b[2] - a2[2]);
 }
@@ -38413,12 +38528,10 @@ function vecNormalize(a2) {
   const len2 = vecLength(a2);
   return len2 < 1e-12 ? [0, 0, 0] : [a2[0] / len2, a2[1] / len2, a2[2] / len2];
 }
-function signedAngleAboutAxis(a2, b, c2, axisUnit) {
-  const ba = vecSub(a2, b);
-  const bc = vecSub(c2, b);
-  const cross2 = vecCross(ba, bc);
+function signedAngleBetweenVectorsAboutAxis(reference, target, axisUnit) {
+  const cross2 = vecCross(reference, target);
   const sin2 = vecDot(cross2, axisUnit);
-  const cos2 = vecDot(ba, bc);
+  const cos2 = vecDot(reference, target);
   return Math.atan2(sin2, cos2) * 180 / Math.PI;
 }
 function normalizeAngleDeltaDeg(value) {
@@ -38539,7 +38652,7 @@ function deriveExplodeHintsFromMates(constraints, result, bodies, ctx) {
   return hints;
 }
 class SolvedAssembly {
-  constructor(name, parts, transforms, jointValues, solveWarnings, _mateMetadata = null, _kinematics = null, usedPortRefs) {
+  constructor(name, parts, transforms, jointValues, solveWarnings, _mateMetadata = null, _kinematics = null, _frames = /* @__PURE__ */ new Map(), usedPortRefs) {
     __publicField(this, "_usedPortRefs");
     this.name = name;
     this.parts = parts;
@@ -38548,6 +38661,7 @@ class SolvedAssembly {
     this.solveWarnings = solveWarnings;
     this._mateMetadata = _mateMetadata;
     this._kinematics = _kinematics;
+    this._frames = _frames;
     this._usedPortRefs = usedPortRefs ?? /* @__PURE__ */ new Set();
   }
   /** Return any warnings generated during solve (clamped joints, unconverged mates, etc.). */
@@ -38573,7 +38687,7 @@ class SolvedAssembly {
     var _a3;
     return ((_a3 = this._mateMetadata) == null ? void 0 : _a3.converged) ?? null;
   }
-  /** Solved assembly-native kinematic graph, or null when no links were declared. */
+  /** Solved assembly-native kinematic or frame-edge overlay data, or null when no rig overlay data was declared. */
   get kinematics() {
     return this._kinematics;
   }
@@ -38584,6 +38698,19 @@ class SolvedAssembly {
     if (!link) throw new Error(`Unknown kinematic link "${linkName}"`);
     return cloneVec3$3(link.position);
   }
+  /** Return the solved world transform for a named rig frame. */
+  getFrame(frameName) {
+    const frame = this._frames.get(frameName);
+    if (!frame) throw new Error(`Unknown frame "${frameName}"`);
+    return frame.transform;
+  }
+  /** Return solved rig frames, including origin, axis, up, and transform. */
+  get frames() {
+    return [...this._frames.values()].map((frame) => ({
+      ...cloneAssemblyFrame(frame),
+      transform: frame.transform
+    }));
+  }
   /**
    * Return the world-space `Transform` for the named part at the solved pose.
    *
@@ -38836,14 +38963,19 @@ class Assembly {
     __publicField(this, "parts", /* @__PURE__ */ new Map());
     __publicField(this, "joints", /* @__PURE__ */ new Map());
     __publicField(this, "jointCouplings", /* @__PURE__ */ new Map());
+    __publicField(this, "frames", /* @__PURE__ */ new Map());
+    __publicField(this, "frameJoints", /* @__PURE__ */ new Map());
+    __publicField(this, "frameEdges", /* @__PURE__ */ new Map());
     __publicField(this, "links", /* @__PURE__ */ new Map());
     __publicField(this, "linkEdges", /* @__PURE__ */ new Map());
     __publicField(this, "linkAngles", /* @__PURE__ */ new Map());
+    __publicField(this, "derivedLinks", /* @__PURE__ */ new Map());
     __publicField(this, "_mateFns", []);
     __publicField(this, "_refs", createPlacementReferences());
     __publicField(this, "_portsByPart", /* @__PURE__ */ new Map());
     __publicField(this, "_usedPortRefs", /* @__PURE__ */ new Set());
     __publicField(this, "_connectCounter", 0);
+    __publicField(this, "_frameEdgeCounter", 0);
     __publicField(this, "_linkEdgeCounter", 0);
     __publicField(this, "_linkAngleCounter", 0);
     this.name = name;
@@ -38853,6 +38985,7 @@ class Assembly {
     const next = new Assembly(this.name);
     next._refs = clonePlacementReferences(this._refs);
     next._connectCounter = this._connectCounter;
+    next._frameEdgeCounter = this._frameEdgeCounter;
     next._linkEdgeCounter = this._linkEdgeCounter;
     next._linkAngleCounter = this._linkAngleCounter;
     next._mateFns.push(...this._mateFns);
@@ -38862,7 +38995,8 @@ class Assembly {
         part: record.part,
         base: record.base,
         metadata: record.metadata ? { ...record.metadata } : void 0,
-        mates: record.mates.map((mate) => ({ ...mate }))
+        mates: record.mates.map((mate) => ({ ...mate })),
+        bindToFrame: record.bindToFrame
       });
     }
     for (const [name, joint2] of this.joints) {
@@ -38891,6 +39025,27 @@ class Assembly {
         offset: coupling.offset
       });
     }
+    for (const [name, frame] of this.frames) {
+      next.frames.set(name, cloneAssemblyFrame(frame));
+    }
+    for (const [name, joint2] of this.frameJoints) {
+      next.frameJoints.set(name, {
+        name: joint2.name,
+        type: joint2.type,
+        parent: joint2.parent,
+        child: joint2.child,
+        rest: joint2.rest,
+        min: joint2.min,
+        max: joint2.max,
+        defaultValue: joint2.defaultValue,
+        unit: joint2.unit,
+        control: joint2.control,
+        metadata: joint2.metadata ? { ...joint2.metadata } : void 0
+      });
+    }
+    for (const [name, edge] of this.frameEdges) {
+      next.frameEdges.set(name, cloneAssemblyFrameEdge(edge));
+    }
     for (const [name, link] of this.links) {
       next.links.set(name, {
         name: link.name,
@@ -38918,6 +39073,7 @@ class Assembly {
         a: angle.a,
         b: angle.b,
         c: angle.c,
+        reference: cloneAngleReference(angle.reference),
         target: angle.target,
         min: angle.min,
         max: angle.max,
@@ -38925,6 +39081,9 @@ class Assembly {
         metadata: angle.metadata ? { ...angle.metadata } : void 0
       });
     }
+    for (const [name, derived] of this.derivedLinks) {
+      next.derivedLinks.set(name, { ...derived });
+    }
     for (const [partName, ports] of this._portsByPart) {
       next._portsByPart.set(partName, clonePortMap(ports));
     }
@@ -39062,6 +39221,129 @@ class Assembly {
       port: resolved.connector
     };
   }
+  /**
+   * Add a named rig frame to the assembly.
+   *
+   * A frame is a solved pose: `origin` plus orientation. `axis` is the frame's
+   * primary direction and `up` fixes roll around that axis. Use frames for
+   * robot links, joint axes, and parts that must carry orientation. Use
+   * `link()` for solved points in distance/angle graphs.
+   *
+   * @category Assembly
+   */
+  frame(name, options) {
+    const id = typeof name === "string" ? name.trim() : "";
+    if (!id) throw new Error("frame() name must be non-empty");
+    if (this.frames.has(id)) throw new Error(`Frame "${id}" already exists`);
+    this.frames.set(id, normalizeAssemblyFrame(id, options));
+    return this;
+  }
+  resolveFrameJointEndpoint(jointName, value, role) {
+    const frameName = typeof value === "string" ? value.trim() : "";
+    if (!frameName) throw new Error(`Frame joint "${jointName}" ${role} must be non-empty`);
+    const frame = this.frames.get(frameName);
+    if (!frame) throw new Error(`Frame joint "${jointName}" unknown ${role} frame "${frameName}"`);
+    return frame;
+  }
+  addFrameJoint(type, name, options) {
+    const id = typeof name === "string" ? name.trim() : "";
+    if (!id) throw new Error(`${type}Joint() name must be non-empty`);
+    if (!options || typeof options !== "object") throw new Error(`${type}Joint("${id}") options are required`);
+    if (this.frameJoints.has(id) || this.joints.has(id)) throw new Error(`Joint "${id}" already exists`);
+    const parent = this.resolveFrameJointEndpoint(id, options.parent, "parent");
+    const child = this.resolveFrameJointEndpoint(id, options.child, "child");
+    if (parent.name === child.name) throw new Error(`Frame joint "${id}" cannot connect a frame to itself`);
+    if (child.fixed) throw new Error(`Frame joint "${id}" cannot drive fixed frame "${child.name}"`);
+    for (const joint2 of this.frameJoints.values()) {
+      if (joint2.child === child.name) throw new Error(`Frame "${child.name}" already has parent joint "${joint2.name}"`);
+    }
+    const movingOptions = options;
+    const min2 = movingOptions.min;
+    const max2 = movingOptions.max;
+    if (min2 !== void 0 && !Number.isFinite(min2)) throw new Error(`Frame joint "${id}" min must be finite`);
+    if (max2 !== void 0 && !Number.isFinite(max2)) throw new Error(`Frame joint "${id}" max must be finite`);
+    if (min2 !== void 0 && max2 !== void 0 && min2 > max2) throw new Error(`Frame joint "${id}" min must be <= max`);
+    const defaultValue = type === "fixed" ? 0 : movingOptions.default ?? 0;
+    if (!Number.isFinite(defaultValue)) throw new Error(`Frame joint "${id}" default must be finite`);
+    this.frameJoints.set(id, {
+      name: id,
+      type,
+      parent: parent.name,
+      child: child.name,
+      rest: relativeFrameTransform(parent, child),
+      min: min2,
+      max: max2,
+      defaultValue: clampFrameJointDefault(id, defaultValue, min2, max2),
+      unit: movingOptions.unit,
+      control: type !== "fixed" && movingOptions.control !== false,
+      metadata: options.metadata ? { ...options.metadata } : void 0
+    });
+    return this;
+  }
+  /**
+   * Rigidly attach a child rig frame to a parent rig frame.
+   *
+   * Fixed joints carry frame hierarchy but do not expose a Motion control.
+   *
+   * @category Assembly
+   */
+  fixedJoint(name, options) {
+    return this.addFrameJoint("fixed", name, options);
+  }
+  /**
+   * Add a revolute rig-frame joint.
+   *
+   * The child frame rotates around the parent frame's `axis` direction. Moving
+   * frame joints appear in Motion by default; pass `control: false` to keep the
+   * joint solved at its default value without showing a Motion control.
+   *
+   * @category Assembly
+   */
+  revoluteJoint(name, options) {
+    return this.addFrameJoint("revolute", name, options);
+  }
+  /**
+   * Add a prismatic rig-frame joint.
+   *
+   * The child frame translates along the parent frame's `axis` direction. Moving
+   * frame joints appear in Motion by default; pass `control: false` to keep the
+   * joint solved at its default value without showing a Motion control.
+   *
+   * @category Assembly
+   */
+  prismaticJoint(name, options) {
+    return this.addFrameJoint("prismatic", name, options);
+  }
+  /**
+   * Add a visual skeleton edge between two rig frame origins.
+   *
+   * Frame edges follow the solved frame poses produced by `fixedJoint()`,
+   * `revoluteJoint()`, and `prismaticJoint()`. They do not add constraints,
+   * degrees of freedom, parts, or geometry; use them to make a frame-only rig
+   * readable in the Motion/rig inspection overlay.
+   *
+   * @category Assembly
+   */
+  edgeBetweenFrames(a2, b, options = {}) {
+    const frameA = typeof a2 === "string" ? a2.trim() : "";
+    const frameB = typeof b === "string" ? b.trim() : "";
+    if (!frameA) throw new Error("edgeBetweenFrames() first frame must be non-empty");
+    if (!frameB) throw new Error("edgeBetweenFrames() second frame must be non-empty");
+    if (!this.frames.has(frameA)) throw new Error(`edgeBetweenFrames() unknown frame "${frameA}"`);
+    if (!this.frames.has(frameB)) throw new Error(`edgeBetweenFrames() unknown frame "${frameB}"`);
+    if (frameA === frameB) throw new Error("edgeBetweenFrames() requires two different frames");
+    if (options.name !== void 0 && typeof options.name !== "string") throw new Error("edgeBetweenFrames() name must be a string");
+    const name = (options.name ?? `${frameA}_${frameB}_${this._frameEdgeCounter++}`).trim();
+    if (!name) throw new Error("edgeBetweenFrames() name must be non-empty");
+    if (this.frameEdges.has(name)) throw new Error(`Frame edge "${name}" already exists`);
+    this.frameEdges.set(name, {
+      name,
+      a: frameA,
+      b: frameB,
+      metadata: options.metadata ? { ...options.metadata } : void 0
+    });
+    return this;
+  }
   /**
    * Add a named kinematic link to the assembly graph.
    *
@@ -39109,6 +39391,11 @@ class Assembly {
     if (options.min !== void 0 && options.max !== void 0 && options.min > options.max) {
       throw new Error(`Link edge "${name}" min must be <= max`);
     }
+    const isStructural = !options.visualOnly && options.length !== "free";
+    if (isStructural) {
+      this.assertNotDerivedStructuralLink(a2, "edgeBetweenLinks()");
+      this.assertNotDerivedStructuralLink(b, "edgeBetweenLinks()");
+    }
     let length4;
     if (options.visualOnly || options.length === "free") {
       length4 = null;
@@ -39117,6 +39404,11 @@ class Assembly {
       length4 = options.length;
     } else {
       length4 = vecDistance(linkA.at, linkB.at);
+      if (length4 <= 1e-10) {
+        throw new Error(
+          `edgeBetweenLinks("${a2}", "${b}") captured a zero structural length. Pass an explicit numeric length, move the links apart with link(..., { at }), or use { length: "free" } / { visualOnly: true }.`
+        );
+      }
     }
     this.linkEdges.set(name, {
       name,
@@ -39141,13 +39433,135 @@ class Assembly {
    * @category Assembly
    */
   addAngleBetweenLinks(a2, b, c2, options = {}) {
-    var _a3, _b3;
     for (const id of [a2, b, c2]) {
       if (!this.links.has(id)) throw new Error(`addAngleBetweenLinks() unknown link "${id}"`);
+      this.assertNotDerivedStructuralLink(id, "addAngleBetweenLinks()");
     }
     if (a2 === b || b === c2 || a2 === c2) throw new Error("addAngleBetweenLinks() requires three different links");
     const name = options.name ?? `${a2}_${b}_${c2}_${this._linkAngleCounter++}`;
     if (this.linkAngles.has(name)) throw new Error(`Link angle "${name}" already exists`);
+    const normalized = this.normalizeAngleOptions(name, options);
+    this.linkAngles.set(name, {
+      name,
+      a: a2,
+      b,
+      c: c2,
+      ...normalized
+    });
+    return this;
+  }
+  /**
+   * Add an absolute angle relationship from a world direction to a link segment.
+   *
+   * The first link is the vertex/pivot and the second link is the moving point.
+   * A value of `0` places `fromLink -> toLink` along `direction` in the
+   * mechanism plane; positive angles rotate counter-clockwise in that plane.
+   *
+   * Use `Points.polar(1, angleDeg)` when the reference direction is planar and
+   * angle-based instead of axis-aligned.
+   *
+   * @category Assembly
+   */
+  addAngleBetweenLinkSegmentAndWorldDirection(fromLink, toLink, direction2, options = {}) {
+    const caller = "addAngleBetweenLinkSegmentAndWorldDirection()";
+    for (const id of [fromLink, toLink]) {
+      if (!this.links.has(id)) throw new Error(`${caller} unknown link "${id}"`);
+      this.assertNotDerivedStructuralLink(id, caller);
+    }
+    if (fromLink === toLink) throw new Error(`${caller} requires two different links`);
+    const referenceDirection = finiteVec3(direction2, `${caller} direction`);
+    if (vecLength(referenceDirection) <= 1e-10) throw new Error(`${caller} direction must be non-zero`);
+    const name = options.name ?? `${fromLink}_${toLink}_from_direction_${this._linkAngleCounter++}`;
+    if (this.linkAngles.has(name)) throw new Error(`Link angle "${name}" already exists`);
+    this.linkAngles.set(name, {
+      name,
+      b: fromLink,
+      c: toLink,
+      reference: { kind: "worldDirection", direction: vecNormalize(referenceDirection) },
+      ...this.normalizeAngleOptions(name, options)
+    });
+    return this;
+  }
+  /**
+   * @deprecated Use `addAngleBetweenLinkSegmentAndWorldDirection(fromLink, toLink, [1, 0, 0], options)`.
+   * @skillSuppress Compatibility-only renamed API. Use `addAngleBetweenLinkSegmentAndWorldDirection()` instead.
+   */
+  addAngleOfLinkSegmentFromXAxis(fromLink, toLink, options = {}) {
+    throw new Error(
+      "addAngleOfLinkSegmentFromXAxis() has been replaced by addAngleBetweenLinkSegmentAndWorldDirection(fromLink, toLink, [1, 0, 0], options). Update your script."
+    );
+  }
+  /**
+   * @deprecated Use `addAngleBetweenLinkSegmentAndWorldDirection(fromLink, toLink, [0, 1, 0], options)`.
+   * @skillSuppress Compatibility-only renamed API. Use `addAngleBetweenLinkSegmentAndWorldDirection()` instead.
+   */
+  addAngleOfLinkSegmentFromYAxis(fromLink, toLink, options = {}) {
+    throw new Error(
+      "addAngleOfLinkSegmentFromYAxis() has been replaced by addAngleBetweenLinkSegmentAndWorldDirection(fromLink, toLink, [0, 1, 0], options). Update your script."
+    );
+  }
+  assertNotDerivedStructuralLink(name, caller) {
+    if (!this.derivedLinks.has(name)) return;
+    throw new Error(
+      `${caller} cannot structurally constrain derived link "${name}". Derived links are recomputed after the primary link solve.`
+    );
+  }
+  assertCanBecomeDerivedLink(name) {
+    const link = this.links.get(name);
+    if (link == null ? void 0 : link.fixed) throw new Error(`Derived link "${name}" cannot be fixed`);
+    for (const edge of this.linkEdges.values()) {
+      if (edge.visualOnly || edge.length == null) continue;
+      if (edge.a === name || edge.b === name) throw new Error(`Derived link "${name}" cannot already have structural edge "${edge.name}"`);
+    }
+    for (const angle of this.linkAngles.values()) {
+      if (angle.a === name || angle.b === name || angle.c === name) {
+        throw new Error(`Derived link "${name}" cannot already participate in angle "${angle.name}"`);
+      }
+    }
+  }
+  addDerivedLink(direction2, name, fromLink, referenceLink, distance2) {
+    const id = typeof name === "string" ? name.trim() : "";
+    if (!id) throw new Error(`${direction2 === "toward" ? "linkToward" : "linkAwayFrom"}() name must be non-empty`);
+    if (!this.links.has(fromLink)) throw new Error(`Derived link "${id}" unknown fromLink "${fromLink}"`);
+    if (!this.links.has(referenceLink)) throw new Error(`Derived link "${id}" unknown reference link "${referenceLink}"`);
+    if (id === fromLink || id === referenceLink || fromLink === referenceLink) {
+      throw new Error(`Derived link "${id}" requires three different links`);
+    }
+    if (!Number.isFinite(distance2) || distance2 < 0) {
+      throw new Error(`Derived link "${id}" distance must be a finite value >= 0`);
+    }
+    if (!this.links.has(id)) {
+      this.link(id);
+    }
+    this.assertCanBecomeDerivedLink(id);
+    this.derivedLinks.set(id, { name: id, fromLink, referenceLink, distance: distance2, direction: direction2 });
+    return this;
+  }
+  /**
+   * Create a derived link at a fixed distance from `fromLink` toward `towardLink`.
+   *
+   * Derived links are trace/reference points. They are recomputed after the
+   * primary link solve and cannot participate in structural edges or angle
+   * constraints.
+   *
+   * @category Assembly
+   */
+  linkToward(name, fromLink, towardLink, distance2) {
+    return this.addDerivedLink("toward", name, fromLink, towardLink, distance2);
+  }
+  /**
+   * Create a derived link at a fixed distance from `fromLink` away from `awayFromLink`.
+   *
+   * Use this for coupler trace/extension points such as the Chebyshev lambda
+   * linkage's point beyond the rocker joint.
+   *
+   * @category Assembly
+   */
+  linkAwayFrom(name, fromLink, awayFromLink, distance2) {
+    return this.addDerivedLink("awayFrom", name, fromLink, awayFromLink, distance2);
+  }
+  normalizeAngleOptions(name, options) {
+    var _a3, _b3;
     const control = options.control === true ? { min: options.min, max: options.max, default: options.value } : options.control ? { ...options.control } : void 0;
     const min2 = ((_a3 = options.limit) == null ? void 0 : _a3.min) ?? options.min;
     const max2 = ((_b3 = options.limit) == null ? void 0 : _b3.max) ?? options.max;
@@ -39156,18 +39570,7 @@ class Assembly {
     if (min2 !== void 0 && max2 !== void 0 && min2 > max2) throw new Error(`Link angle "${name}" min must be <= max`);
     const target = options.value ?? (control == null ? void 0 : control.default);
     if (target !== void 0 && !Number.isFinite(target)) throw new Error(`Link angle "${name}" value must be finite`);
-    this.linkAngles.set(name, {
-      name,
-      a: a2,
-      b,
-      c: c2,
-      target,
-      min: min2,
-      max: max2,
-      control,
-      metadata: options.metadata ? { ...options.metadata } : void 0
-    });
-    return this;
+    return { target, min: min2, max: max2, control, metadata: options.metadata ? { ...options.metadata } : void 0 };
   }
   /** Return the assembly-native kinematic graph definition. */
   describeKinematics() {
@@ -39194,30 +39597,23 @@ class Assembly {
         a: angle.a,
         b: angle.b,
         c: angle.c,
+        reference: cloneAngleReference(angle.reference),
         target: angle.target,
         min: angle.min,
         max: angle.max,
         control: angle.control ? { ...angle.control } : void 0,
         metadata: angle.metadata ? { ...angle.metadata } : void 0
-      }))
+      })),
+      derivedLinks: [...this.derivedLinks.values()].map((derived) => ({ ...derived }))
     };
   }
   /**
-   * Add a virtual reference frame (no geometry) to the assembly graph.
-   *
-   * **Details**
-   *
-   * Useful when you need a named pivot point or coordinate frame that has no
-   * visual geometry. Acts like a zero-volume part and can be connected to
-   * other parts via joints.
-   *
-   * @param name - Unique part name for the frame in the assembly graph
-   * @param options - Optional transform and metadata
-   * @returns `this` for chaining
-   * @category Assembly
+   * @deprecated `addFrame()` has been removed. Use `frame()` for rig frames, or
+   * `addPart(name, group())` for an empty placeholder part.
+   * @internal
    */
-  addFrame(name, options = {}) {
-    return this.addPart(name, group(), options);
+  addFrame(_name2, _options = {}) {
+    throw new Error("addFrame() has been removed. Use frame() for rig frames, or addPart(name, group()) for an empty placeholder part.");
   }
   /**
    * Add a named part to the assembly.
@@ -39257,6 +39653,16 @@ class Assembly {
   addPart(name, part, options = {}) {
     if (this.parts.has(name)) throw new Error(`Part "${name}" already exists`);
     const mates = options.mate == null ? [] : Array.isArray(options.mate) ? options.mate : [options.mate];
+    if (options.bindToFrame != null && typeof options.bindToFrame !== "string") {
+      throw new Error(`addPart("${name}") bindToFrame must be a frame name string`);
+    }
+    const bindToFrame = typeof options.bindToFrame === "string" ? options.bindToFrame.trim() : "";
+    if (bindToFrame && mates.length > 0) {
+      throw new Error(`addPart("${name}") cannot use both bindToFrame and mate`);
+    }
+    if (bindToFrame && !this.frames.has(bindToFrame)) {
+      throw new Error(`addPart("${name}") bindToFrame references unknown frame "${bindToFrame}"`);
+    }
     this.parts.set(name, {
       name,
       part,
@@ -39274,7 +39680,8 @@ class Assembly {
           if (aimLink === toLink) throw new Error(`addPart("${name}") mate[${index2}] aimLink must differ from toLink`);
         }
         return aimLink ? { connector, toLink, aimLink } : { connector, toLink };
-      })
+      }),
+      bindToFrame: bindToFrame || void 0
     });
     let ports = {};
     if (part instanceof Shape) {
@@ -39320,10 +39727,15 @@ class Assembly {
    * @internal
    */
   addJoint(name, type, parent, child, options = {}) {
-    if (this.joints.has(name)) throw new Error(`Joint "${name}" already exists`);
+    if (this.joints.has(name) || this.frameJoints.has(name)) throw new Error(`Joint "${name}" already exists`);
     if (!this.parts.has(parent)) throw new Error(`Unknown parent part "${parent}"`);
     if (!this.parts.has(child)) throw new Error(`Unknown child part "${child}"`);
     if (parent === child) throw new Error(`Joint "${name}" cannot connect a part to itself`);
+    const parentRecord = this.parts.get(parent);
+    const childRecord = this.parts.get(child);
+    if (parentRecord.bindToFrame || childRecord.bindToFrame) {
+      throw new Error(`Joint "${name}" cannot connect frame-bound parts. Use frame joints for parts added with bindToFrame.`);
+    }
     if (options.frame && options.origin) {
       throw new Error(`Joint "${name}" cannot have both frame and origin`);
     }
@@ -39600,7 +40012,578 @@ class Assembly {
       "addGearCoupling() has been removed from the modeling API. Express gear behavior through assembly kinematic constraints instead."
     );
   }
+  solveFrames(state) {
+    const transforms = /* @__PURE__ */ new Map();
+    const frames = /* @__PURE__ */ new Map();
+    const jointValues = {};
+    const warnings = [];
+    if (this.frames.size === 0) return { frames, transforms, jointValues, warnings };
+    const incoming = /* @__PURE__ */ new Map();
+    const jointsByParent = /* @__PURE__ */ new Map();
+    for (const joint2 of this.frameJoints.values()) {
+      if (incoming.has(joint2.child)) {
+        throw new Error(`Frame "${joint2.child}" has multiple parent joints`);
+      }
+      incoming.set(joint2.child, joint2.name);
+      const list = jointsByParent.get(joint2.parent) ?? [];
+      list.push(joint2);
+      jointsByParent.set(joint2.parent, list);
+    }
+    const roots = [...this.frames.keys()].filter((name) => !incoming.has(name));
+    if (roots.length === 0) throw new Error("Frame graph has no root frame");
+    const visiting = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const resolveJointValue = (joint2) => {
+      if (joint2.type === "fixed") {
+        jointValues[joint2.name] = 0;
+        return 0;
+      }
+      const hasStateValue = Object.prototype.hasOwnProperty.call(state, joint2.name);
+      let raw = joint2.defaultValue;
+      if (joint2.control === false) {
+        if (hasStateValue) {
+          warnings.push(`Frame joint "${joint2.name}" state override ignored because control is false`);
+        }
+      } else {
+        raw = state[joint2.name] ?? joint2.defaultValue;
+      }
+      const finite = Number.isFinite(raw) ? raw : joint2.defaultValue;
+      let clamped = finite;
+      if (joint2.min != null) clamped = Math.max(joint2.min, clamped);
+      if (joint2.max != null) clamped = Math.min(joint2.max, clamped);
+      if (clamped !== raw) {
+        warnings.push(`Frame joint "${joint2.name}" clamped from ${raw} to ${clamped}${joint2.unit ?? ""}`);
+      }
+      jointValues[joint2.name] = clamped;
+      return clamped;
+    };
+    const visit = (frameName, worldTransform) => {
+      if (visiting.has(frameName)) throw new Error(`Frame joint cycle detected at "${frameName}"`);
+      const frame = this.frames.get(frameName);
+      if (!frame) throw new Error(`Unknown frame "${frameName}"`);
+      visiting.add(frameName);
+      transforms.set(frameName, worldTransform);
+      frames.set(frameName, frameFromTransform(frame, worldTransform));
+      visited.add(frameName);
+      for (const joint2 of jointsByParent.get(frameName) ?? []) {
+        const value = resolveJointValue(joint2);
+        const childWorld = composeChain(joint2.rest, frameJointMotionTransform(joint2, value), worldTransform);
+        visit(joint2.child, childWorld);
+      }
+      visiting.delete(frameName);
+    };
+    for (const rootName of roots) {
+      const root = this.frames.get(rootName);
+      visit(rootName, frameDefTransform(root));
+    }
+    if (visited.size !== this.frames.size) {
+      const missing = [...this.frames.keys()].filter((name) => !visited.has(name));
+      throw new Error(`Frame graph unresolved for frames: ${missing.join(", ")}`);
+    }
+    return { frames, transforms, jointValues, warnings };
+  }
+  solveFrameEdges(frames) {
+    const solved = [];
+    for (const edge of this.frameEdges.values()) {
+      const a2 = frames.get(edge.a);
+      const b = frames.get(edge.b);
+      if (!a2) throw new Error(`Frame edge "${edge.name}" references unresolved frame "${edge.a}"`);
+      if (!b) throw new Error(`Frame edge "${edge.name}" references unresolved frame "${edge.b}"`);
+      const start = cloneVec3$3(a2.origin);
+      const end = cloneVec3$3(b.origin);
+      solved.push({
+        ...cloneAssemblyFrameEdge(edge),
+        start,
+        end,
+        solvedLength: vecDistance(start, end)
+      });
+    }
+    return solved;
+  }
+  attachFrameEdgesToKinematics(metadata, frameEdges) {
+    if (frameEdges.length === 0) return metadata;
+    if (metadata) return { ...metadata, frameEdges };
+    return {
+      links: [],
+      edges: [],
+      angles: [],
+      derivedLinks: [],
+      frameEdges,
+      controls: {},
+      floatingComponents: [],
+      diagnostics: [],
+      maxResidual: 0,
+      converged: true
+    };
+  }
   solveKinematicLinks(state) {
+    if (this.links.size === 0) {
+      return { metadata: null, linkPositions: /* @__PURE__ */ new Map(), warnings: [] };
+    }
+    const plane = this.buildKinematicWorkplane();
+    if (!plane) {
+      return this.solveKinematicLinksLegacy(state);
+    }
+    return this.solveKinematicLinksPlanar(state, plane);
+  }
+  buildKinematicWorkplane() {
+    const derivedNames = new Set(this.derivedLinks.keys());
+    const primaryLinks = [...this.links.values()].filter((link) => !derivedNames.has(link.name));
+    const originLink = primaryLinks.find((link) => link.fixed) ?? primaryLinks[0];
+    const origin = originLink ? cloneVec3$3(originLink.at) : [0, 0, 0];
+    let normal = null;
+    for (const angle of this.linkAngles.values()) {
+      const b = this.links.get(angle.b).at;
+      const c2 = this.links.get(angle.c).at;
+      const reference = angle.reference ? angle.reference.direction : angle.a ? vecSub(this.links.get(angle.a).at, b) : null;
+      if (!reference) continue;
+      const n = vecCross(reference, vecSub(c2, b));
+      if (vecLength(n) < 1e-9) continue;
+      const unit = vecNormalize(n);
+      if (!normal) {
+        normal = unit;
+      } else if (Math.abs(vecDot(normal, unit)) < 0.999) {
+        return null;
+      }
+    }
+    normal ?? (normal = [0, 0, 1]);
+    const projectDir = (v) => {
+      const d2 = vecDot(v, normal);
+      const projected = [v[0] - normal[0] * d2, v[1] - normal[1] * d2, v[2] - normal[2] * d2];
+      const len2 = vecLength(projected);
+      return len2 > 1e-9 ? [projected[0] / len2, projected[1] / len2, projected[2] / len2] : null;
+    };
+    let xAxis = null;
+    const fixed = primaryLinks.filter((link) => link.fixed);
+    for (let i = 0; i < fixed.length && !xAxis; i++) {
+      for (let j = i + 1; j < fixed.length && !xAxis; j++) {
+        xAxis = projectDir(vecSub(fixed[j].at, fixed[i].at));
+      }
+    }
+    for (const edge of this.linkEdges.values()) {
+      if (xAxis) break;
+      if (derivedNames.has(edge.a) || derivedNames.has(edge.b)) continue;
+      const a2 = this.links.get(edge.a);
+      const b = this.links.get(edge.b);
+      if (a2 && b) xAxis = projectDir(vecSub(b.at, a2.at));
+    }
+    for (const link of primaryLinks) {
+      if (xAxis) break;
+      xAxis = projectDir(vecSub(link.at, origin));
+    }
+    xAxis ?? (xAxis = projectDir(Math.abs(normal[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0]) ?? [1, 0, 0]);
+    const yAxis = vecNormalize(vecCross(normal, xAxis));
+    for (const link of primaryLinks) {
+      const offPlane = Math.abs(vecDot(vecSub(link.at, origin), normal));
+      if (offPlane > 1e-6) return null;
+    }
+    return { origin, xAxis, yAxis, normal };
+  }
+  solveKinematicLinksPlanar(state, plane) {
+    var _a3, _b3, _c2, _d2, _e2, _f, _g;
+    const derivedNames = new Set(this.derivedLinks.keys());
+    const primaryLinks = [...this.links.values()].filter((link) => !derivedNames.has(link.name));
+    const controls = {};
+    const diagnosticSet = /* @__PURE__ */ new Set();
+    const diagnostics = [];
+    const addDiagnostic = (message) => {
+      if (diagnosticSet.has(message)) return;
+      diagnosticSet.add(message);
+      diagnostics.push(message);
+    };
+    const project = (p2) => {
+      const rel = vecSub(p2, plane.origin);
+      return [vecDot(rel, plane.xAxis), vecDot(rel, plane.yAxis)];
+    };
+    const unproject = (p2) => [
+      plane.origin[0] + plane.xAxis[0] * p2[0] + plane.yAxis[0] * p2[1],
+      plane.origin[1] + plane.xAxis[1] * p2[0] + plane.yAxis[1] * p2[1],
+      plane.origin[2] + plane.xAxis[2] * p2[0] + plane.yAxis[2] * p2[1]
+    ];
+    const unprojectVector = (v) => [
+      plane.xAxis[0] * v[0] + plane.yAxis[0] * v[1],
+      plane.xAxis[1] * v[0] + plane.yAxis[1] * v[1],
+      plane.xAxis[2] * v[0] + plane.yAxis[2] * v[1]
+    ];
+    const projectVector = (v) => [vecDot(v, plane.xAxis), vecDot(v, plane.yAxis)];
+    const initialPositions2d = /* @__PURE__ */ new Map();
+    for (const link of primaryLinks) initialPositions2d.set(link.name, project(link.at));
+    const neighbors = /* @__PURE__ */ new Map();
+    for (const link of primaryLinks) neighbors.set(link.name, /* @__PURE__ */ new Set());
+    for (const edge of this.linkEdges.values()) {
+      if (derivedNames.has(edge.a) || derivedNames.has(edge.b)) continue;
+      (_a3 = neighbors.get(edge.a)) == null ? void 0 : _a3.add(edge.b);
+      (_b3 = neighbors.get(edge.b)) == null ? void 0 : _b3.add(edge.a);
+    }
+    for (const angle of this.linkAngles.values()) {
+      if (angle.a) {
+        (_c2 = neighbors.get(angle.a)) == null ? void 0 : _c2.add(angle.b);
+        (_d2 = neighbors.get(angle.b)) == null ? void 0 : _d2.add(angle.a);
+      }
+      (_e2 = neighbors.get(angle.b)) == null ? void 0 : _e2.add(angle.c);
+      (_f = neighbors.get(angle.c)) == null ? void 0 : _f.add(angle.b);
+    }
+    const floatingComponents = [];
+    const gaugeFixed = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set();
+    for (const link of primaryLinks.map((link2) => link2.name)) {
+      if (seen.has(link)) continue;
+      const stack = [link];
+      const component = [];
+      seen.add(link);
+      while (stack.length > 0) {
+        const next = stack.pop();
+        component.push(next);
+        for (const neighbor of neighbors.get(next) ?? []) {
+          if (seen.has(neighbor)) continue;
+          seen.add(neighbor);
+          stack.push(neighbor);
+        }
+      }
+      if (!component.some((name) => {
+        var _a4;
+        return (_a4 = this.links.get(name)) == null ? void 0 : _a4.fixed;
+      })) {
+        const sorted = [...component].sort();
+        const gaugeLink = sorted[0];
+        gaugeFixed.add(gaugeLink);
+        floatingComponents.push({ links: sorted, gaugeLink });
+      }
+    }
+    const angleValueForState = (angle, inputState, recordControl) => {
+      var _a4, _b4, _c3, _d3;
+      if (!angle.control && angle.target === void 0) return null;
+      const raw = inputState[angle.name] ?? angle.target ?? ((_a4 = angle.control) == null ? void 0 : _a4.default) ?? 0;
+      let value = Number.isFinite(raw) ? raw : ((_b4 = angle.control) == null ? void 0 : _b4.default) ?? angle.target ?? 0;
+      const min2 = ((_c3 = angle.control) == null ? void 0 : _c3.min) ?? angle.min;
+      const max2 = ((_d3 = angle.control) == null ? void 0 : _d3.max) ?? angle.max;
+      if (min2 != null) value = Math.max(min2, value);
+      if (max2 != null) value = Math.min(max2, value);
+      if (recordControl) controls[angle.name] = value;
+      return value;
+    };
+    const controlledAngleValue = (angle) => angleValueForState(angle, state, true);
+    const edgeLengthBetween = (x2, y2) => {
+      for (const edge of this.linkEdges.values()) {
+        if (edge.visualOnly || edge.length == null) continue;
+        if (edge.a === x2 && edge.b === y2 || edge.a === y2 && edge.b === x2) return edge.length;
+      }
+      return null;
+    };
+    const seedDirection = (index2) => {
+      const angle = index2 * Math.PI * (3 - Math.sqrt(5));
+      return [Math.cos(angle), Math.sin(angle)];
+    };
+    const rotate2d = (v, angleDeg) => {
+      const rad = angleDeg * Math.PI / 180;
+      const c2 = Math.cos(rad);
+      const s = Math.sin(rad);
+      return [v[0] * c2 - v[1] * s, v[0] * s + v[1] * c2];
+    };
+    const angleReferenceVector2d = (angle, seedPositions) => {
+      if (angle.reference) return projectVector(angle.reference.direction);
+      if (!angle.a) return null;
+      const a2 = seedPositions.get(angle.a);
+      const b = seedPositions.get(angle.b);
+      if (!a2 || !b) return null;
+      return [a2[0] - b[0], a2[1] - b[1]];
+    };
+    const angleReferenceLabel = (angle) => angle.reference ? `world direction [${angle.reference.direction.join(", ")}]` : `reference links "${angle.a}" and "${angle.b}"`;
+    const signedArea2d2 = (a2, b, p2) => (b[0] - a2[0]) * (p2[1] - a2[1]) - (b[1] - a2[1]) * (p2[0] - a2[0]);
+    const circleCircleCandidates = (a2, radiusA, b, radiusB) => {
+      const dx = b[0] - a2[0];
+      const dy = b[1] - a2[1];
+      const d2 = Math.hypot(dx, dy);
+      if (d2 <= 1e-10) return [];
+      const along = (radiusA * radiusA - radiusB * radiusB + d2 * d2) / (2 * d2);
+      const h2 = radiusA * radiusA - along * along;
+      if (h2 < -1e-7) return [];
+      const h = Math.sqrt(Math.max(0, h2));
+      const ux = dx / d2;
+      const uy = dy / d2;
+      const base = [a2[0] + ux * along, a2[1] + uy * along];
+      const offset2 = [-uy * h, ux * h];
+      return [
+        [base[0] + offset2[0], base[1] + offset2[1]],
+        [base[0] - offset2[0], base[1] - offset2[1]]
+      ];
+    };
+    const chooseCandidate = (targetName, anchors, candidates, seedPositions, branchReference2) => {
+      if (candidates.length === 0) return null;
+      const anchorAName = anchors[0].name;
+      const anchorBName = anchors[1].name;
+      const anchorA = seedPositions.get(anchorAName);
+      const anchorB = seedPositions.get(anchorBName);
+      let referenceSign = 0;
+      if (branchReference2) {
+        const refA = branchReference2.get(anchorAName);
+        const refB = branchReference2.get(anchorBName);
+        const refTarget = branchReference2.get(targetName);
+        if (refA && refB && refTarget) {
+          const area2 = signedArea2d2(refA, refB, refTarget);
+          if (Math.abs(area2) > 1e-7) referenceSign = Math.sign(area2);
+        }
+      }
+      const authored = initialPositions2d.get(targetName) ?? [0, 0];
+      let best = null;
+      let bestScore = Number.POSITIVE_INFINITY;
+      for (const candidate of candidates) {
+        const candidateSign = Math.sign(signedArea2d2(anchorA, anchorB, candidate));
+        const branchPenalty = referenceSign !== 0 && candidateSign !== referenceSign ? 1e12 : 0;
+        const authoredDistance = Math.hypot(candidate[0] - authored[0], candidate[1] - authored[1]);
+        const constraintResidual = anchors.reduce((sum2, anchor) => {
+          const p2 = seedPositions.get(anchor.name);
+          return sum2 + Math.abs(Math.hypot(candidate[0] - p2[0], candidate[1] - p2[1]) - anchor.length);
+        }, 0);
+        const score = branchPenalty + constraintResidual * 1e6 + authoredDistance;
+        if (score < bestScore) {
+          bestScore = score;
+          best = candidate;
+        }
+      }
+      return best;
+    };
+    const buildSeedPositions = (inputState, branchReference2, diagnosticPrefix = "") => {
+      const seedPositions = new Map(initialPositions2d);
+      const seeded = /* @__PURE__ */ new Set();
+      const angleDriven = /* @__PURE__ */ new Set();
+      const isLocked = (name) => {
+        var _a4;
+        return ((_a4 = this.links.get(name)) == null ? void 0 : _a4.fixed) === true || gaugeFixed.has(name);
+      };
+      for (const link of primaryLinks) {
+        const p2 = seedPositions.get(link.name);
+        if (link.fixed || gaugeFixed.has(link.name) || Math.hypot(p2[0], p2[1]) > 1e-9) seeded.add(link.name);
+      }
+      if (seeded.size === 0 && primaryLinks.length > 0) seeded.add(primaryLinks[0].name);
+      let seedIndex = 1;
+      let changed = true;
+      for (let pass = 0; pass < primaryLinks.length * 3 && changed; pass++) {
+        changed = false;
+        for (const angle of this.linkAngles.values()) {
+          const target = angleValueForState(angle, inputState, false);
+          const radius = edgeLengthBetween(angle.b, angle.c);
+          const hasReference = !!angle.reference || angle.a !== void 0 && seeded.has(angle.a);
+          if (target == null || radius == null || isLocked(angle.c) || !hasReference || !seeded.has(angle.b)) continue;
+          const b = seedPositions.get(angle.b);
+          const ref = angleReferenceVector2d(angle, seedPositions);
+          if (!ref) continue;
+          const refLen = Math.hypot(ref[0], ref[1]);
+          if (refLen <= 1e-10) {
+            addDiagnostic(
+              `${diagnosticPrefix}Angle "${angle.name}" cannot drive link "${angle.c}" because ${angleReferenceLabel(angle)} has no usable direction in the mechanism plane.`
+            );
+            continue;
+          }
+          const dir = rotate2d([ref[0] / refLen, ref[1] / refLen], target);
+          seedPositions.set(angle.c, [b[0] + dir[0] * radius, b[1] + dir[1] * radius]);
+          seeded.add(angle.c);
+          angleDriven.add(angle.c);
+          changed = true;
+        }
+        for (const link of primaryLinks) {
+          if (isLocked(link.name) || angleDriven.has(link.name)) continue;
+          const anchors = [];
+          for (const edge of this.linkEdges.values()) {
+            if (edge.visualOnly || edge.length == null || derivedNames.has(edge.a) || derivedNames.has(edge.b)) continue;
+            if (edge.a === link.name && seeded.has(edge.b)) anchors.push({ name: edge.b, length: edge.length });
+            if (edge.b === link.name && seeded.has(edge.a)) anchors.push({ name: edge.a, length: edge.length });
+          }
+          if (anchors.length < 2) continue;
+          const a2 = anchors[0];
+          const b = anchors[1];
+          const candidates = circleCircleCandidates(seedPositions.get(a2.name), a2.length, seedPositions.get(b.name), b.length);
+          const chosen = chooseCandidate(link.name, anchors, candidates, seedPositions, branchReference2);
+          if (!chosen) {
+            const pa = seedPositions.get(a2.name);
+            const pb = seedPositions.get(b.name);
+            const centerDistance = Math.hypot(pb[0] - pa[0], pb[1] - pa[1]);
+            const minDistance = Math.abs(a2.length - b.length);
+            const maxDistance = a2.length + b.length;
+            addDiagnostic(
+              `${diagnosticPrefix}Link "${link.name}" cannot be placed from anchors "${a2.name}" and "${b.name}": distance between anchors is ${centerDistance.toFixed(6)}, but required circle intersection range is ${minDistance.toFixed(6)}..${maxDistance.toFixed(6)}. This control state is outside the selected assembly mode, or the model needs more initial link positions to select a different mode.`
+            );
+            continue;
+          }
+          seedPositions.set(link.name, chosen);
+          seeded.add(link.name);
+          changed = true;
+        }
+        for (const edge of this.linkEdges.values()) {
+          if (edge.visualOnly || edge.length == null || derivedNames.has(edge.a) || derivedNames.has(edge.b)) continue;
+          const aSeeded = seeded.has(edge.a);
+          const bSeeded = seeded.has(edge.b);
+          if (aSeeded === bSeeded) continue;
+          const anchorName = aSeeded ? edge.a : edge.b;
+          const targetName = aSeeded ? edge.b : edge.a;
+          if (isLocked(targetName) || angleDriven.has(targetName)) continue;
+          const anchor = seedPositions.get(anchorName);
+          const current = seedPositions.get(targetName);
+          const delta = [current[0] - anchor[0], current[1] - anchor[1]];
+          const deltaLen = Math.hypot(delta[0], delta[1]);
+          const dir = deltaLen > 1e-9 ? [delta[0] / deltaLen, delta[1] / deltaLen] : seedDirection(seedIndex++);
+          seedPositions.set(targetName, [anchor[0] + dir[0] * edge.length, anchor[1] + dir[1] * edge.length]);
+          seeded.add(targetName);
+          changed = true;
+        }
+      }
+      const refLength = Math.max(1, ...[...this.linkEdges.values()].map((edge) => edge.length ?? 0));
+      for (const link of primaryLinks) {
+        if (seeded.has(link.name)) continue;
+        if (this.linkEdges.size > 0 || this.linkAngles.size > 0) {
+          addDiagnostic(
+            `${diagnosticPrefix}Link "${link.name}" could not be constructed from the current kinematic graph. Give it an initial position, add a structural distance to an already-placed link, or add a controlling angle.`
+          );
+        } else {
+          const dir = seedDirection(seedIndex++);
+          seedPositions.set(link.name, [dir[0] * refLength, dir[1] * refLength]);
+          seeded.add(link.name);
+        }
+      }
+      return seedPositions;
+    };
+    const defaultControlState = {};
+    let hasDefaultControlState = false;
+    for (const angle of this.linkAngles.values()) {
+      if (!angle.control && angle.target === void 0) continue;
+      const value = ((_g = angle.control) == null ? void 0 : _g.default) ?? angle.target;
+      if (Number.isFinite(value)) {
+        defaultControlState[angle.name] = value;
+        hasDefaultControlState = true;
+      }
+    }
+    const branchReference = hasDefaultControlState ? buildSeedPositions(defaultControlState, void 0, "Default assembly mode: ") : void 0;
+    const positions2d = buildSeedPositions(state, branchReference);
+    const positions = /* @__PURE__ */ new Map();
+    for (const link of primaryLinks) {
+      const point2 = positions2d.get(link.name);
+      if (!point2) {
+        addDiagnostic(`Link "${link.name}" has no solved planar position after kinematic construction.`);
+        continue;
+      }
+      positions.set(link.name, unproject(point2));
+    }
+    const solvedDerivedLinks = this.evaluateDerivedLinks(positions);
+    for (const derived of solvedDerivedLinks) positions.set(derived.name, cloneVec3$3(derived.position));
+    const solvedEdges = [];
+    const solvedAngles = [];
+    let maxResidual = diagnostics.length > 0 ? Number.POSITIVE_INFINITY : 0;
+    for (const edge of this.linkEdges.values()) {
+      const edgeA = positions.get(edge.a);
+      const edgeB = positions.get(edge.b);
+      const solvedLength = edgeA && edgeB ? vecDistance(edgeA, edgeB) : Number.NaN;
+      let residual = 0;
+      if (!edgeA || !edgeB) {
+        residual = Number.POSITIVE_INFINITY;
+        addDiagnostic(`Edge "${edge.name}" could not be evaluated because one of its links has no solved position.`);
+      } else {
+        if (edge.length != null) residual = solvedLength - edge.length;
+        if (edge.min != null && solvedLength < edge.min) residual = Math.min(residual, solvedLength - edge.min);
+        if (edge.max != null && solvedLength > edge.max) residual = Math.max(residual, solvedLength - edge.max);
+      }
+      maxResidual = Math.max(maxResidual, Math.abs(residual));
+      solvedEdges.push({
+        name: edge.name,
+        a: edge.a,
+        b: edge.b,
+        length: edge.length,
+        solvedLength,
+        residual,
+        visualOnly: edge.visualOnly
+      });
+    }
+    for (const angle of this.linkAngles.values()) {
+      const angleB = positions.get(angle.b);
+      const angleC = positions.get(angle.c);
+      const reference = angleReferenceVector2d(angle, positions2d);
+      const solvedValue = reference && angleB && angleC ? signedAngleBetweenVectorsAboutAxis(unprojectVector(reference), vecSub(angleC, angleB), plane.normal) : Number.NaN;
+      const target = controlledAngleValue(angle) ?? angle.target;
+      let residual = target == null ? 0 : normalizeAngleDeltaDeg(solvedValue - target);
+      if (!reference || !angleB || !angleC) {
+        residual = Number.POSITIVE_INFINITY;
+        addDiagnostic(`Angle "${angle.name}" could not be evaluated because its reference or one of its links has no solved position.`);
+      } else {
+        if (angle.min != null && solvedValue < angle.min) residual = Math.min(residual, solvedValue - angle.min);
+        if (angle.max != null && solvedValue > angle.max) residual = Math.max(residual, solvedValue - angle.max);
+      }
+      maxResidual = Math.max(maxResidual, Math.abs(residual));
+      solvedAngles.push({
+        name: angle.name,
+        a: angle.a,
+        b: angle.b,
+        c: angle.c,
+        reference: cloneAngleReference(angle.reference),
+        target,
+        solvedValue,
+        residual,
+        control: angle.control ? { ...angle.control } : void 0
+      });
+    }
+    const warnings = [];
+    for (const component of floatingComponents) {
+      warnings.push(`Kinematic component is floating; using link "${component.gaugeLink}" as a numerical display gauge`);
+    }
+    if (maxResidual > 1e-3) {
+      warnings.push(`Kinematic graph residual ${maxResidual.toFixed(6)} exceeds tolerance`);
+    }
+    return {
+      metadata: {
+        links: [...this.links.values()].map((link) => ({
+          name: link.name,
+          position: cloneVec3$3(positions.get(link.name) ?? link.at),
+          fixed: link.fixed,
+          gaugeFixed: gaugeFixed.has(link.name) || void 0
+        })),
+        edges: solvedEdges,
+        angles: solvedAngles,
+        derivedLinks: solvedDerivedLinks,
+        controls,
+        floatingComponents,
+        diagnostics,
+        maxResidual,
+        converged: diagnostics.length === 0 && maxResidual <= 1e-3
+      },
+      linkPositions: positions,
+      warnings
+    };
+  }
+  evaluateDerivedLinks(basePositions) {
+    const output = /* @__PURE__ */ new Map();
+    const visiting = /* @__PURE__ */ new Set();
+    const resolve = (name) => {
+      const existing = basePositions.get(name);
+      if (existing && !this.derivedLinks.has(name)) return existing;
+      const cached = output.get(name);
+      if (cached) return cached.position;
+      const derived = this.derivedLinks.get(name);
+      if (!derived) {
+        const position2 = basePositions.get(name);
+        if (!position2) throw new Error(`Derived link references unknown solved link "${name}"`);
+        return position2;
+      }
+      if (visiting.has(name)) throw new Error(`Derived link cycle detected at "${name}"`);
+      visiting.add(name);
+      const from = resolve(derived.fromLink);
+      const reference = resolve(derived.referenceLink);
+      const rawDir = derived.direction === "toward" ? vecSub(reference, from) : vecSub(from, reference);
+      const dir = vecNormalize(rawDir);
+      if (vecLength(dir) < 1e-10) {
+        throw new Error(`Derived link "${name}" cannot be solved because "${derived.fromLink}" and "${derived.referenceLink}" coincide`);
+      }
+      const position = [
+        from[0] + dir[0] * derived.distance,
+        from[1] + dir[1] * derived.distance,
+        from[2] + dir[2] * derived.distance
+      ];
+      visiting.delete(name);
+      const solved = { ...derived, position };
+      output.set(name, solved);
+      return position;
+    };
+    for (const name of this.derivedLinks.keys()) resolve(name);
+    return [...output.values()];
+  }
+  solveKinematicLinksLegacy(state) {
     var _a3, _b3, _c2, _d2, _e2, _f;
     if (this.links.size === 0) {
       return { metadata: null, linkPositions: /* @__PURE__ */ new Map(), warnings: [] };
@@ -39616,8 +40599,10 @@ class Assembly {
       (_b3 = neighbors.get(edge.b)) == null ? void 0 : _b3.add(edge.a);
     }
     for (const angle of this.linkAngles.values()) {
-      (_c2 = neighbors.get(angle.a)) == null ? void 0 : _c2.add(angle.b);
-      (_d2 = neighbors.get(angle.b)) == null ? void 0 : _d2.add(angle.a);
+      if (angle.a) {
+        (_c2 = neighbors.get(angle.a)) == null ? void 0 : _c2.add(angle.b);
+        (_d2 = neighbors.get(angle.b)) == null ? void 0 : _d2.add(angle.a);
+      }
       (_e2 = neighbors.get(angle.b)) == null ? void 0 : _e2.add(angle.c);
       (_f = neighbors.get(angle.c)) == null ? void 0 : _f.add(angle.b);
     }
@@ -39672,27 +40657,36 @@ class Assembly {
       const link = this.links.get(name);
       return !link.fixed && !gaugeFixed.has(name) && !controlledLinks.has(name);
     };
+    const angleReferenceVector = (angle, source) => {
+      if (angle.reference) return cloneVec3$3(angle.reference.direction);
+      if (!angle.a) return null;
+      const a2 = source.get(angle.a);
+      const b = source.get(angle.b);
+      if (!a2 || !b) return null;
+      return vecSub(a2, b);
+    };
     const anglePlaneNormal = (angle) => {
-      const a2 = this.links.get(angle.a).at;
       const b = this.links.get(angle.b).at;
       const c2 = this.links.get(angle.c).at;
-      const n = vecCross(vecSub(a2, b), vecSub(c2, b));
+      const reference = angle.reference ? angle.reference.direction : angle.a ? vecSub(this.links.get(angle.a).at, b) : null;
+      if (!reference) return [0, 0, 1];
+      const n = vecCross(reference, vecSub(c2, b));
       return vecLength(n) < 1e-9 ? [0, 0, 1] : vecNormalize(n);
     };
     const applyAngleControls = () => {
       for (const angle of this.linkAngles.values()) {
         const target = controlledAngleValue(angle);
         if (target == null) continue;
-        const a2 = positions.get(angle.a);
         const b = positions.get(angle.b);
         const c2 = positions.get(angle.c);
         if (!isMovable(angle.c) && !controlledLinks.has(angle.c)) continue;
         const radius = edgeLengthBetween(angle.b, angle.c) ?? vecDistance(b, c2);
         if (radius <= 1e-10) continue;
-        const ba = vecSub(a2, b);
-        const len2 = vecLength(ba);
+        const reference = angleReferenceVector(angle, positions);
+        if (!reference) continue;
+        const len2 = vecLength(reference);
         if (len2 <= 1e-10) continue;
-        const baUnit = [ba[0] / len2, ba[1] / len2, ba[2] / len2];
+        const baUnit = [reference[0] / len2, reference[1] / len2, reference[2] / len2];
         const rotated = rotateAboutAxis(baUnit, anglePlaneNormal(angle), target);
         positions.set(angle.c, [b[0] + rotated[0] * radius, b[1] + rotated[1] * radius, b[2] + rotated[2] * radius]);
         controlledLinks.add(angle.c);
@@ -39722,6 +40716,8 @@ class Assembly {
     }
     controlledLinks.clear();
     applyAngleControls();
+    const solvedDerivedLinks = this.evaluateDerivedLinks(positions);
+    for (const derived of solvedDerivedLinks) positions.set(derived.name, cloneVec3$3(derived.position));
     const solvedEdges = [];
     const solvedAngles = [];
     let maxResidual = 0;
@@ -39743,14 +40739,13 @@ class Assembly {
       });
     }
     for (const angle of this.linkAngles.values()) {
-      const solvedValue = signedAngleAboutAxis(
-        positions.get(angle.a),
-        positions.get(angle.b),
-        positions.get(angle.c),
-        anglePlaneNormal(angle)
-      );
+      const reference = angleReferenceVector(angle, positions);
+      const b = positions.get(angle.b);
+      const c2 = positions.get(angle.c);
+      const solvedValue = reference ? signedAngleBetweenVectorsAboutAxis(reference, vecSub(c2, b), anglePlaneNormal(angle)) : Number.NaN;
       const target = controlledAngleValue(angle) ?? angle.target;
       let residual = target == null ? 0 : normalizeAngleDeltaDeg(solvedValue - target);
+      if (!reference) residual = Number.POSITIVE_INFINITY;
       if (angle.min != null && solvedValue < angle.min) residual = Math.min(residual, solvedValue - angle.min);
       if (angle.max != null && solvedValue > angle.max) residual = Math.max(residual, solvedValue - angle.max);
       maxResidual = Math.max(maxResidual, Math.abs(residual));
@@ -39759,6 +40754,7 @@ class Assembly {
         a: angle.a,
         b: angle.b,
         c: angle.c,
+        reference: cloneAngleReference(angle.reference),
         target,
         solvedValue,
         residual,
@@ -39782,8 +40778,10 @@ class Assembly {
         })),
         edges: solvedEdges,
         angles: solvedAngles,
+        derivedLinks: solvedDerivedLinks,
         controls,
         floatingComponents,
+        diagnostics: [],
         maxResidual,
         converged: maxResidual <= 1e-3
       },
@@ -39831,8 +40829,12 @@ class Assembly {
     const incoming = /* @__PURE__ */ new Map();
     const jointsByParent = /* @__PURE__ */ new Map();
     const warnings = [];
+    const frameSolve = this.solveFrames(state);
+    warnings.push(...frameSolve.warnings);
     const kinematicSolve = this.solveKinematicLinks(state);
     warnings.push(...kinematicSolve.warnings);
+    const solvedFrameEdges = this.solveFrameEdges(frameSolve.frames);
+    const kinematicMetadata = this.attachFrameEdgesToKinematics(kinematicSolve.metadata, solvedFrameEdges);
     for (const joint2 of this.joints.values()) {
       if (incoming.has(joint2.child)) {
         throw new Error(`Part "${joint2.child}" has multiple parent joints`);
@@ -39842,8 +40844,9 @@ class Assembly {
       list.push(joint2);
       jointsByParent.set(joint2.parent, list);
     }
-    const roots = [...this.parts.keys()].filter((name) => !incoming.has(name));
-    if (roots.length === 0 && this.parts.size > 0) {
+    const unboundPartNames = [...this.parts.values()].filter((part) => !part.bindToFrame).map((part) => part.name);
+    const roots = unboundPartNames.filter((name) => !incoming.has(name));
+    if (roots.length === 0 && unboundPartNames.length > 0) {
       throw new Error("Assembly has no root part (cyclic joint graph)");
     }
     const mateBaseOverrides = /* @__PURE__ */ new Map();
@@ -39946,7 +40949,7 @@ class Assembly {
     const world = /* @__PURE__ */ new Map();
     const visiting = /* @__PURE__ */ new Set();
     const visited = /* @__PURE__ */ new Set();
-    const jointValues = {};
+    const jointValues = { ...frameSolve.jointValues };
     const resolvingJointValues = /* @__PURE__ */ new Set();
     const resolveJointValue = (jointName) => {
       const cached = jointValues[jointName];
@@ -39996,6 +40999,13 @@ class Assembly {
       const rootBase = mateBaseOverrides.get(rootName) ?? kinematicBaseForPart(root) ?? root.base;
       dfs(rootName, rootBase);
     }
+    for (const rec of this.parts.values()) {
+      if (!rec.bindToFrame) continue;
+      const frameTransform2 = frameSolve.transforms.get(rec.bindToFrame);
+      if (!frameTransform2) throw new Error(`Part "${rec.name}" references unresolved frame "${rec.bindToFrame}"`);
+      world.set(rec.name, composeChain(rec.base, frameTransform2));
+      visited.add(rec.name);
+    }
     if (visited.size !== this.parts.size) {
       const missing = [...this.parts.keys()].filter((name) => !visited.has(name));
       throw new Error(`Assembly graph unresolved for parts: ${missing.join(", ")}`);
@@ -40051,7 +41061,8 @@ class Assembly {
       jointValues,
       warnings,
       mateMetadata,
-      kinematicSolve.metadata,
+      kinematicMetadata,
+      frameSolve.frames,
       this._usedPortRefs
     );
   }
@@ -40164,7 +41175,7 @@ class Assembly {
     return collectJointsView(this.buildJointsViewOptions(options, state, false), null, "assembly");
   }
   buildJointsViewOptions(options, state, relativeLinkControls) {
-    var _a3, _b3, _c2, _d2;
+    var _a3, _b3, _c2, _d2, _e2, _f;
     const solved = this.solve(state);
     const def = this.describe();
     const joints = [];
@@ -40208,7 +41219,31 @@ class Assembly {
       }
       joints.push(entry);
     }
-    if (this.linkAngles.size > 0 && this.parts.size > 0) {
+    for (const j of def.frameJoints) {
+      if (j.type === "fixed" || j.control === false) continue;
+      const parentWorld = solved.getFrame(j.parent);
+      const pivot = parentWorld.point([0, 0, 0]);
+      const axisWorld = parentWorld.vector([0, 0, 1]);
+      const axisLen = Math.hypot(axisWorld[0], axisWorld[1], axisWorld[2]);
+      const normalizedAxis = axisLen > 1e-10 ? [axisWorld[0] / axisLen, axisWorld[1] / axisLen, axisWorld[2] / axisLen] : [0, 0, 1];
+      const entry = {
+        name: j.name,
+        child: j.child,
+        parent: j.parent,
+        type: j.type,
+        axis: normalizedAxis,
+        pivot,
+        min: j.min,
+        max: j.max,
+        default: ((_c2 = options.defaults) == null ? void 0 : _c2[j.name]) ?? j.defaultValue,
+        unit: j.unit
+      };
+      if ((_d2 = options.overrides) == null ? void 0 : _d2[j.name]) {
+        Object.assign(entry, options.overrides[j.name]);
+      }
+      joints.push(entry);
+    }
+    if (this.linkAngles.size > 0) {
       const mateLinksOf = /* @__PURE__ */ new Map();
       for (const part of this.parts.values()) {
         if (part.mates.length > 0) mateLinksOf.set(part.name, new Set(part.mates.map((m2) => m2.toLink)));
@@ -40229,18 +41264,20 @@ class Assembly {
       for (const angle of this.linkAngles.values()) {
         if (angle.control) controlMoving.set(angle.c, angle);
       }
+      const controlledAngleChild = (angle) => spanPart(angle.b, angle.c) ?? firstPartMatedTo(angle.c) ?? angle.c;
       const normalAtSolvedPose = (angle) => {
-        const a2 = solved.getLinkPosition(angle.a);
         const b = solved.getLinkPosition(angle.b);
         const c2 = solved.getLinkPosition(angle.c);
-        const n = vecCross(vecSub(a2, b), vecSub(c2, b));
+        const reference = angle.reference ? angle.reference.direction : angle.a ? vecSub(solved.getLinkPosition(angle.a), b) : null;
+        if (!reference) return [0, 0, 1];
+        const n = vecCross(reference, vecSub(c2, b));
         return vecLength(n) < 1e-9 ? [0, 0, 1] : vecNormalize(n);
       };
       for (const angle of this.linkAngles.values()) {
         if (!angle.control) continue;
-        const child = spanPart(angle.b, angle.c) ?? firstPartMatedTo(angle.c) ?? angle.c;
+        const child = controlledAngleChild(angle);
         const parentAngle = controlMoving.get(angle.b);
-        const parent = parentAngle ? spanPart(parentAngle.b, parentAngle.c) ?? firstPartMatedTo(parentAngle.c) : firstPartMatedTo(angle.b);
+        const parent = parentAngle ? controlledAngleChild(parentAngle) : firstPartMatedTo(angle.b);
         const defValue = angle.control.default ?? angle.target ?? 0;
         const absMin = angle.control.min ?? angle.min;
         const absMax = angle.control.max ?? angle.max;
@@ -40253,10 +41290,10 @@ class Assembly {
           pivot: solved.getLinkPosition(angle.b),
           min: absMin !== void 0 && relativeLinkControls ? absMin - defValue : absMin,
           max: absMax !== void 0 && relativeLinkControls ? absMax - defValue : absMax,
-          default: relativeLinkControls ? 0 : ((_c2 = options.defaults) == null ? void 0 : _c2[angle.name]) ?? defValue,
+          default: relativeLinkControls ? 0 : ((_e2 = options.defaults) == null ? void 0 : _e2[angle.name]) ?? defValue,
           unit: angle.control.unit
         };
-        if ((_d2 = options.overrides) == null ? void 0 : _d2[angle.name]) {
+        if ((_f = options.overrides) == null ? void 0 : _f[angle.name]) {
           Object.assign(entry, options.overrides[angle.name]);
         }
         joints.push(entry);
@@ -40318,7 +41355,8 @@ class Assembly {
         part: part.part,
         base: part.base,
         metadata: part.metadata ? { ...part.metadata } : void 0,
-        mates: part.mates.map((mate) => ({ ...mate }))
+        mates: part.mates.map((mate) => ({ ...mate })),
+        bindToFrame: part.bindToFrame
       })),
       joints: [...this.joints.values()].map((joint2) => ({
         name: joint2.name,
@@ -40342,7 +41380,22 @@ class Assembly {
         terms: coupling.terms.map((term) => ({ joint: term.joint, ratio: term.ratio })),
         offset: coupling.offset
       })),
-      kinematics: this.describeKinematics()
+      kinematics: this.describeKinematics(),
+      frames: [...this.frames.values()].map((frame) => cloneAssemblyFrame(frame)),
+      frameJoints: [...this.frameJoints.values()].map((joint2) => ({
+        name: joint2.name,
+        type: joint2.type,
+        parent: joint2.parent,
+        child: joint2.child,
+        rest: joint2.rest,
+        min: joint2.min,
+        max: joint2.max,
+        defaultValue: joint2.defaultValue,
+        unit: joint2.unit,
+        control: joint2.control,
+        metadata: joint2.metadata ? { ...joint2.metadata } : void 0
+      })),
+      frameEdges: [...this.frameEdges.values()].map((edge) => cloneAssemblyFrameEdge(edge))
     };
   }
 }
@@ -40569,6 +41622,9 @@ class ImportedAssembly {
   mergeInto(parent, options) {
     const def = this._assembly.describe();
     const pfx = options.prefix ? `${options.prefix}.` : "";
+    if (def.frames.length > 0 || def.frameJoints.length > 0 || def.frameEdges.length > 0) {
+      throw new Error("mergeInto() does not yet support rig frames. Import and solve the frame-based sub-assembly directly for now.");
+    }
     const childSet = new Set(def.joints.map((j) => j.child));
     const roots = def.parts.filter((p2) => !childSet.has(p2.name));
     if (roots.length === 0) {
@@ -40599,14 +41655,26 @@ class ImportedAssembly {
       });
     }
     for (const angle of def.kinematics.angles) {
-      parent.addAngleBetweenLinks(`${pfx}${angle.a}`, `${pfx}${angle.b}`, `${pfx}${angle.c}`, {
+      const options2 = {
         name: `${pfx}${angle.name}`,
         value: angle.target,
         min: angle.min,
         max: angle.max,
         control: angle.control,
         metadata: angle.metadata
-      });
+      };
+      if (angle.reference) {
+        parent.addAngleBetweenLinkSegmentAndWorldDirection(`${pfx}${angle.b}`, `${pfx}${angle.c}`, angle.reference.direction, options2);
+      } else if (angle.a) {
+        parent.addAngleBetweenLinks(`${pfx}${angle.a}`, `${pfx}${angle.b}`, `${pfx}${angle.c}`, options2);
+      }
+    }
+    for (const derived of def.kinematics.derivedLinks) {
+      if (derived.direction === "toward") {
+        parent.linkToward(`${pfx}${derived.name}`, `${pfx}${derived.fromLink}`, `${pfx}${derived.referenceLink}`, derived.distance);
+      } else {
+        parent.linkAwayFrom(`${pfx}${derived.name}`, `${pfx}${derived.fromLink}`, `${pfx}${derived.referenceLink}`, derived.distance);
+      }
     }
     for (const p2 of def.parts) {
       parent.addPart(`${pfx}${p2.name}`, p2.part, {
@@ -45122,7 +46190,7 @@ const EPSILON$2 = 1e-9;
 function add$3(a2, b) {
   return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
 }
-function scale$3(v, factor) {
+function scale$4(v, factor) {
   return [v[0] * factor, v[1] * factor, v[2] * factor];
 }
 function sub$5(a2, b) {
@@ -45197,9 +46265,9 @@ function buildBend(points, directions, cornerIndex, radius) {
   const angle = Math.acos(turnDot);
   const trim = radius * Math.tan(angle / 2);
   const axis = normalize$4(cross$4(dIn, dOut), `corner ${cornerIndex} bend axis`);
-  const start = add$3(points[cornerIndex], scale$3(dIn, -trim));
-  const end = add$3(points[cornerIndex], scale$3(dOut, trim));
-  const center = add$3(start, scale$3(normalize$4(cross$4(axis, dIn), `corner ${cornerIndex} bend normal`), radius));
+  const start = add$3(points[cornerIndex], scale$4(dIn, -trim));
+  const end = add$3(points[cornerIndex], scale$4(dOut, trim));
+  const center = add$3(start, scale$4(normalize$4(cross$4(axis, dIn), `corner ${cornerIndex} bend normal`), radius));
   return { cornerIndex, trim, start, end, center, axis, sweepDeg: angle * 180 / Math.PI, length: radius * angle };
 }
 function assertBendFits(bend2, radius, segmentLengths, bends) {
@@ -45230,7 +46298,7 @@ function buildRoute3DPlanFromPolyline(pointsInput, options = {}) {
   const segmentLengths = points.slice(1).map((point2, index2) => length$1(sub$5(point2, points[index2])));
   const directions = segmentLengths.map((segmentLength, index2) => {
     if (segmentLength <= EPSILON$2) throw new Error(`Curve.Route.fromPolyline: segment ${index2} is zero length.`);
-    return scale$3(sub$5(points[index2 + 1], points[index2]), 1 / segmentLength);
+    return scale$4(sub$5(points[index2 + 1], points[index2]), 1 / segmentLength);
   });
   const bends = new Array(points.length).fill(null);
   if (radius > EPSILON$2) {
@@ -45263,7 +46331,7 @@ function buildRoute3DPlanFromPolyline(pointsInput, options = {}) {
     segments,
     length: routeLength,
     ports: {
-      [startPort]: portFrame(startPort, points[0], scale$3(directions[0], -1), 0, up),
+      [startPort]: portFrame(startPort, points[0], scale$4(directions[0], -1), 0, up),
       [endPort]: portFrame(endPort, points[points.length - 1], directions[directions.length - 1], routeLength, up)
     }
   };
@@ -45766,7 +46834,7 @@ function variableSweep(spine, sections, options = {}) {
     sources: ["sweep"]
   });
 }
-function requirePositive$9(value, label) {
+function requirePositive$8(value, label) {
   if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
     throw new Error(`${label} must be a finite number > 0, got ${JSON.stringify(value)}`);
   }
@@ -45785,10 +46853,10 @@ function requireIntegerAtLeast(value, label, min2) {
   return value;
 }
 function normalizeHelixOptions(options, apiName) {
-  const radius = requirePositive$9(options.radius, `${apiName}.radius`);
-  const pitch = options.pitch == null ? void 0 : requirePositive$9(options.pitch, `${apiName}.pitch`);
-  const turns = options.turns == null ? void 0 : requirePositive$9(options.turns, `${apiName}.turns`);
-  const height = options.height == null ? void 0 : requirePositive$9(options.height, `${apiName}.height`);
+  const radius = requirePositive$8(options.radius, `${apiName}.radius`);
+  const pitch = options.pitch == null ? void 0 : requirePositive$8(options.pitch, `${apiName}.pitch`);
+  const turns = options.turns == null ? void 0 : requirePositive$8(options.turns, `${apiName}.turns`);
+  const height = options.height == null ? void 0 : requirePositive$8(options.height, `${apiName}.height`);
   const provided = [pitch != null, turns != null, height != null].filter(Boolean).length;
   if (provided < 2) {
     throw new Error(`${apiName}: provide any two of pitch, turns, and height so the third can be derived.`);
@@ -45874,7 +46942,7 @@ function buildHelixCoil(profileOrOptions, maybeOptions) {
   if (!options) throw new Error("Helix.coil: options are required.");
   const spec2 = normalizeHelixOptions(options, "Helix.coil");
   const profile = hasCustomProfile ? profileOrOptions : circle2d(
-    requirePositive$9(options.wireRadius, "Helix.coil.wireRadius"),
+    requirePositive$8(options.wireRadius, "Helix.coil.wireRadius"),
     requireIntegerAtLeast(options.profileSegments ?? 24, "Helix.coil.profileSegments", 8)
   );
   if (profile.isEmpty()) throw new Error("Helix.coil: profile must not be empty.");
@@ -46457,6 +47525,12 @@ const Curve = {
 function sub$4(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
+function addVec(a2, b) {
+  return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
+}
+function scale$3(v, s) {
+  return [v[0] * s, v[1] * s, v[2] * s];
+}
 function dot$4(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
@@ -46473,6 +47547,56 @@ function normalize$3(v) {
 function clampDot(d2) {
   return Math.max(-1, Math.min(1, d2));
 }
+function requirePositiveFinite(value, label) {
+  if (!Number.isFinite(value) || value <= 0) throw new Error(`${label} must be a finite number > 0`);
+  return value;
+}
+function requireNonNegativeFinite(value, label) {
+  if (!Number.isFinite(value) || value < 0) throw new Error(`${label} must be a finite number >= 0`);
+  return value;
+}
+function requireFiniteVec3$1(value, label) {
+  if (value == null) return void 0;
+  if (!Array.isArray(value) || value.length !== 3) throw new Error(`${label} must be [x, y, z]`);
+  const result = [Number(value[0]), Number(value[1]), Number(value[2])];
+  if (!Number.isFinite(result[0]) || !Number.isFinite(result[1]) || !Number.isFinite(result[2])) {
+    throw new Error(`${label} must contain finite coordinates`);
+  }
+  return result;
+}
+function normalizedDirection(value, label) {
+  const len2 = vecLen(value);
+  if (len2 < 1e-12) throw new Error(`${label} must not be the zero vector`);
+  return [value[0] / len2, value[1] / len2, value[2] / len2];
+}
+function stablePerpendicularAxis$1(direction2) {
+  const seed = Math.abs(direction2[1]) < 0.9 ? [0, 1, 0] : [1, 0, 0];
+  return normalizedDirection(sub$4(seed, scale$3(direction2, dot$4(direction2, seed))), "elbow: turn plane");
+}
+function rotateDirection(v, axis, angleRad) {
+  const c2 = Math.cos(angleRad);
+  const s = Math.sin(angleRad);
+  const axisDot = dot$4(axis, v);
+  const axisCross = cross$3(axis, v);
+  return [
+    v[0] * c2 + axisCross[0] * s + axis[0] * axisDot * (1 - c2),
+    v[1] * c2 + axisCross[1] * s + axis[1] * axisDot * (1 - c2),
+    v[2] * c2 + axisCross[2] * s + axis[2] * axisDot * (1 - c2)
+  ];
+}
+function angleBetweenDirections(from, to) {
+  return Math.acos(clampDot(dot$4(from, to)));
+}
+function turnAxisForDirections(from, to) {
+  const axis = cross$3(from, to);
+  if (vecLen(axis) >= 1e-12) return normalizedDirection(axis, "elbow: turn axis");
+  if (dot$4(from, to) > 0) throw new Error("elbow: from and to directions are collinear; angle too small");
+  return stablePerpendicularAxis$1(from);
+}
+function profileForPipeRadius(pipeRadius, wall, segments) {
+  const outer = circle2d(pipeRadius, segments);
+  return wall != null && wall > 0 ? difference2d(outer, circle2d(pipeRadius - wall, segments)) : outer;
+}
 function pipeRoute(points, radius, options) {
   if (points.length < 2) throw new Error("pipeRoute needs at least 2 points");
   const bendR = (options == null ? void 0 : options.bendRadius) ?? radius * 4;
@@ -46504,88 +47628,40 @@ function simplifyStraightPipeRoutePoints(points) {
   return simplified;
 }
 function elbow(pipeRadius, bendRadius, angle, options) {
-  let angleDeg;
-  let wall;
-  let segs;
-  let fromDir;
-  let toDir;
-  if (typeof angle === "object" && angle !== null) {
-    angleDeg = 90;
-    wall = angle.wall;
-    segs = angle.segments ?? 32;
-    fromDir = angle.from;
-    toDir = angle.to;
+  requirePositiveFinite(pipeRadius, "elbow: pipeRadius");
+  requirePositiveFinite(bendRadius, "elbow: bendRadius");
+  const opts = typeof angle === "object" && angle !== null ? angle : options;
+  const wall = opts == null ? void 0 : opts.wall;
+  const segments = (opts == null ? void 0 : opts.segments) ?? 32;
+  if (!Number.isFinite(segments) || segments < 3) throw new Error("elbow: segments must be a finite number >= 3");
+  if (wall != null && requireNonNegativeFinite(wall, "elbow: wall") >= pipeRadius) {
+    throw new Error("elbow: wall must be smaller than pipeRadius");
+  }
+  const from = normalizedDirection(requireFiniteVec3$1(opts == null ? void 0 : opts.from, "elbow: from") ?? [0, 0, 1], "elbow: from");
+  const toInput = requireFiniteVec3$1(opts == null ? void 0 : opts.to, "elbow: to");
+  const angleDegInput = typeof angle === "number" ? angle : void 0;
+  const angleRadInput = (angleDegInput ?? 90) * Math.PI / 180;
+  let angleRad;
+  let turnAxis;
+  if (toInput) {
+    const to = normalizedDirection(toInput, "elbow: to");
+    angleRad = angleBetweenDirections(from, to);
+    turnAxis = turnAxisForDirections(from, to);
   } else {
-    angleDeg = angle ?? 90;
-    wall = options == null ? void 0 : options.wall;
-    segs = (options == null ? void 0 : options.segments) ?? 32;
-    fromDir = options == null ? void 0 : options.from;
-    toDir = options == null ? void 0 : options.to;
-  }
-  if (fromDir && toDir) {
-    const nFrom = normalize$3(fromDir);
-    const nTo = normalize$3(toDir);
-    const d2 = clampDot(dot$4(nFrom, nTo));
-    angleDeg = Math.acos(d2) * 180 / Math.PI;
-  }
-  if (angleDeg < 0.01) throw new Error("elbow: angle too small");
-  const circlePts = [];
-  for (let i = 0; i < segs; i++) {
-    const a2 = i / segs * Math.PI * 2;
-    circlePts.push([bendRadius + pipeRadius * Math.cos(a2), pipeRadius * Math.sin(a2)]);
-  }
-  const bendSegs = Math.max(4, Math.ceil(segs * angleDeg / 360));
-  const outerPlan = {
-    kind: "revolve",
-    profile: { kind: "polygon", points: circlePts, transforms: [] },
-    degrees: angleDeg,
-    segments: bendSegs
-  };
-  let bendShape = buildShapeFromCompilePlan(outerPlan);
-  if (wall != null && wall > 0) {
-    const innerPts = [];
-    const innerR = pipeRadius - wall;
-    for (let i = 0; i < segs; i++) {
-      const a2 = i / segs * Math.PI * 2;
-      innerPts.push([bendRadius + innerR * Math.cos(a2), innerR * Math.sin(a2)]);
-    }
-    const innerPlan = {
-      kind: "revolve",
-      profile: { kind: "polygon", points: innerPts, transforms: [] },
-      degrees: angleDeg,
-      segments: bendSegs
-    };
-    const innerBend = buildShapeFromCompilePlan(innerPlan);
-    bendShape = bendShape.subtract(innerBend);
-  }
-  if (fromDir && toDir) {
-    const nFrom = normalize$3(fromDir);
-    const nTo = normalize$3(toDir);
-    const crossVec = cross$3(nFrom, nTo);
-    const crossLen = vecLen(crossVec);
-    if (crossLen < 1e-10) return bendShape;
-    const axis = normalize$3(crossVec);
-    const perpDir = cross$3(axis, nFrom);
-    bendShape = bendShape.transform([
-      perpDir[0],
-      perpDir[1],
-      perpDir[2],
-      0,
-      nFrom[0],
-      nFrom[1],
-      nFrom[2],
-      0,
-      axis[0],
-      axis[1],
-      axis[2],
-      0,
-      0,
-      0,
-      0,
-      1
-    ]);
+    if (!Number.isFinite(angleRadInput) || angleRadInput <= 1e-6 || angleRadInput > Math.PI) {
+      throw new Error("elbow: angle must be finite and in the range (0, 180] degrees");
+    }
+    turnAxis = stablePerpendicularAxis$1(from);
+    angleRad = angleRadInput;
   }
-  return bendShape;
+  if (angleRad <= 1e-6) throw new Error("elbow: angle too small");
+  const inward = normalizedDirection(cross$3(turnAxis, from), "elbow: bend normal");
+  const center = scale$3(inward, bendRadius);
+  const endRadial = rotateDirection(scale$3(inward, -bendRadius), turnAxis, angleRad);
+  const end = addVec(center, endRadial);
+  const profile = profileForPipeRadius(pipeRadius, wall, Math.floor(segments));
+  const pathSamples = Math.max(6, Math.ceil(segments * (angleRad * 180 / Math.PI) / 360) + 1);
+  return sweep(profile, Curve.Arc({ start: [0, 0, 0], end, tangent: from }), { samples: pathSamples, up: turnAxis });
 }
 const EPS$7 = 1e-9;
 function assertFinitePositive(apiName, name, value) {
@@ -47084,7 +48160,7 @@ function spurGear(options) {
   });
   return attachGearMeta(shapeWithConnectors, meta2);
 }
-function requirePositive$8(scope, name, value) {
+function requirePositive$7(scope, name, value) {
   if (!isFinitePositive(value)) throw new Error(`${scope}: "${name}" must be > 0`);
 }
 function requireOptionalBore(scope, boreDiameter, maxDiameter) {
@@ -47106,8 +48182,8 @@ function cutBore$1(shape, boreDiameter) {
   return shape.subtract(cutter);
 }
 function gearBodyDisk(options) {
-  requirePositive$8("gearBodyDisk", "outerRadius", options.outerRadius);
-  requirePositive$8("gearBodyDisk", "faceWidth", options.faceWidth);
+  requirePositive$7("gearBodyDisk", "outerRadius", options.outerRadius);
+  requirePositive$7("gearBodyDisk", "faceWidth", options.faceWidth);
   const bore = requireOptionalBore("gearBodyDisk", options.boreDiameter, options.outerRadius * 2);
   const segments = resolveSegments(options.segments);
   const outer = circle2d(options.outerRadius, segments);
@@ -47115,14 +48191,14 @@ function gearBodyDisk(options) {
   return sketchExtrude(profile, options.faceWidth);
 }
 function gearBodyDiskWithHub(options) {
-  requirePositive$8("gearBodyDiskWithHub", "hubDiameter", options.hubDiameter);
+  requirePositive$7("gearBodyDiskWithHub", "hubDiameter", options.hubDiameter);
   if (options.hubDiameter >= options.outerRadius * 2) {
     throw new Error('gearBodyDiskWithHub: "hubDiameter" must be smaller than the outer diameter');
   }
   const bore = requireOptionalBore("gearBodyDiskWithHub", options.boreDiameter, options.hubDiameter);
   const base = gearBodyDisk({ ...options, boreDiameter: 0 });
   const hubFaceWidth = options.hubFaceWidth ?? options.faceWidth * 1.5;
-  requirePositive$8("gearBodyDiskWithHub", "hubFaceWidth", hubFaceWidth);
+  requirePositive$7("gearBodyDiskWithHub", "hubFaceWidth", hubFaceWidth);
   const hub = cylinder(hubFaceWidth, options.hubDiameter * 0.5, void 0, options.segments).translate(
     0,
     0,
@@ -47131,11 +48207,11 @@ function gearBodyDiskWithHub(options) {
   return cutBore$1(base.add(hub), bore);
 }
 function gearBodySpoked(options) {
-  requirePositive$8("gearBodySpoked", "outerRadius", options.outerRadius);
-  requirePositive$8("gearBodySpoked", "faceWidth", options.faceWidth);
-  requirePositive$8("gearBodySpoked", "rimWidth", options.rimWidth);
-  requirePositive$8("gearBodySpoked", "hubDiameter", options.hubDiameter);
-  requirePositive$8("gearBodySpoked", "spokeWidth", options.spokeWidth);
+  requirePositive$7("gearBodySpoked", "outerRadius", options.outerRadius);
+  requirePositive$7("gearBodySpoked", "faceWidth", options.faceWidth);
+  requirePositive$7("gearBodySpoked", "rimWidth", options.rimWidth);
+  requirePositive$7("gearBodySpoked", "hubDiameter", options.hubDiameter);
+  requirePositive$7("gearBodySpoked", "spokeWidth", options.spokeWidth);
   if (!Number.isInteger(options.spokeCount) || options.spokeCount < 2) {
     throw new Error('gearBodySpoked: "spokeCount" must be an integer >= 2');
   }
@@ -47158,12 +48234,12 @@ function gearBodySpoked(options) {
 }
 function gearBodyFromProfile(profile, options) {
   if (!(profile instanceof Sketch)) throw new Error('gearBodyFromProfile: "profile" must be a Sketch');
-  requirePositive$8("gearBodyFromProfile", "faceWidth", options.faceWidth);
+  requirePositive$7("gearBodyFromProfile", "faceWidth", options.faceWidth);
   const bore = options.boreDiameter ?? 0;
   if (!Number.isFinite(bore) || bore < 0) throw new Error('gearBodyFromProfile: "boreDiameter" must be >= 0');
   return cutBore$1(sketchExtrude(profile, options.faceWidth), bore);
 }
-function requirePositive$7(scope, name, value) {
+function requirePositive$6(scope, name, value) {
   if (!isFinitePositive(value)) throw new Error(`${scope}: "${name}" must be > 0`);
 }
 function requireFiniteAngle(scope, name, value) {
@@ -47225,7 +48301,7 @@ function buildSpurTeethRegion(options, name, faceWidth) {
 }
 function buildSolidArcRegion(options, name, faceWidth) {
   const scope = "driveWheel.addSolidArcBetween";
-  requirePositive$7(scope, "outerRadius", options.outerRadius);
+  requirePositive$6(scope, "outerRadius", options.outerRadius);
   const innerRadius = options.innerRadius ?? 0;
   if (!Number.isFinite(innerRadius) || innerRadius < 0) throw new Error(`${scope}: "innerRadius" must be >= 0`);
   if (innerRadius >= options.outerRadius) throw new Error(`${scope}: "innerRadius" must be smaller than "outerRadius"`);
@@ -47291,7 +48367,7 @@ class DriveWheelBuilder {
     __publicField(this, "boreDiameter");
     __publicField(this, "regions", []);
     if (options.body !== void 0 && !(options.body instanceof Shape)) throw new Error('driveWheel: "body" must be a Shape');
-    if (options.faceWidth !== void 0) requirePositive$7("driveWheel", "faceWidth", options.faceWidth);
+    if (options.faceWidth !== void 0) requirePositive$6("driveWheel", "faceWidth", options.faceWidth);
     const boreDiameter = options.boreDiameter ?? 0;
     if (!Number.isFinite(boreDiameter) || boreDiameter < 0) throw new Error('driveWheel: "boreDiameter" must be >= 0');
     this.body = options.body;
@@ -47326,7 +48402,7 @@ class DriveWheelBuilder {
     if (options.innerRadius !== void 0 && (!Number.isFinite(options.innerRadius) || options.innerRadius < 0)) {
       throw new Error(`${scope}: "innerRadius" must be >= 0`);
     }
-    if (options.outerRadius !== void 0) requirePositive$7(scope, "outerRadius", options.outerRadius);
+    if (options.outerRadius !== void 0) requirePositive$6(scope, "outerRadius", options.outerRadius);
     this.regions.push({
       shape: shape.clone(),
       meta: {
@@ -47392,7 +48468,7 @@ class DriveWheelBuilder {
   resolveFaceWidth(scope, localFaceWidth) {
     const faceWidth = localFaceWidth ?? this.faceWidth;
     if (faceWidth === void 0) throw new Error(`${scope}: "faceWidth" is required unless driveWheel({ faceWidth }) was set`);
-    requirePositive$7(scope, "faceWidth", faceWidth);
+    requirePositive$6(scope, "faceWidth", faceWidth);
     if (this.faceWidth !== void 0 && localFaceWidth !== void 0 && Math.abs(this.faceWidth - localFaceWidth) > EPSILON$1) {
       throw new Error(`${scope}: region faceWidth must match driveWheel faceWidth`);
     }
@@ -48545,1860 +49621,6 @@ function washer(size, options) {
   const bore = cylinder(dims.t + 1, dims.id / 2, void 0, segs);
   return outer.subtract(bore);
 }
-function requirePositive$6(value, name) {
-  if (!Number.isFinite(value) || value <= 0) throw new Error(`${name} must be a positive finite number`);
-  return value;
-}
-function requireNonNegative(value, name) {
-  if (!Number.isFinite(value) || value < 0) throw new Error(`${name} must be a non-negative finite number`);
-  return value;
-}
-function metricWasherSizeForPin(pinDiameter) {
-  if (pinDiameter <= 2) return "M2";
-  if (pinDiameter <= 2.5) return "M2.5";
-  if (pinDiameter <= 3) return "M3";
-  if (pinDiameter <= 4) return "M4";
-  if (pinDiameter <= 5) return "M5";
-  if (pinDiameter <= 6) return "M6";
-  if (pinDiameter <= 8) return "M8";
-  return "M10";
-}
-function cylinderAlongX(length4, radius, xCenter, segments) {
-  return cylinder(length4, radius, void 0, segments).pointAlong([1, 0, 0]).translate(xCenter - length4 / 2, 0, 0);
-}
-function tubeAlongX(length4, outerRadius, innerRadius, xCenter, segments) {
-  return cylinderAlongX(length4, outerRadius, xCenter, segments).subtract(cylinderAlongX(length4 + 0.4, innerRadius, xCenter, segments));
-}
-function cylinderAlongY(length4, radius, yCenter, segments) {
-  return cylinder(length4, radius, void 0, segments).pointAlong([0, 1, 0]).translate(0, yCenter - length4 / 2, 0);
-}
-function tubeAlongY(length4, outerRadius, innerRadius, yCenter, segments) {
-  return cylinderAlongY(length4, outerRadius, yCenter, segments).subtract(cylinderAlongY(length4 + 0.4, innerRadius, yCenter, segments));
-}
-function tubeAlongZ(height, outerRadius, innerRadius, segments) {
-  return cylinder(height, outerRadius, void 0, segments).subtract(
-    cylinder(height + 0.4, innerRadius, void 0, segments).translate(0, 0, -0.2)
-  );
-}
-function washerAlongX(size, xCenter, segments) {
-  const dims = WASHER_TABLE[size];
-  return washer(size, { segments }).pointAlong([1, 0, 0]).translate(xCenter - dims.t / 2, 0, 0);
-}
-function resolveBoltInset(raw, fallback) {
-  if (raw === void 0) return [fallback, fallback];
-  if (typeof raw === "number") return [requirePositive$6(raw, "boltInset"), requirePositive$6(raw, "boltInset")];
-  if (raw.length !== 2) throw new Error("boltInset tuple must be [x, y]");
-  return [requirePositive$6(raw[0], "boltInset[0]"), requirePositive$6(raw[1], "boltInset[1]")];
-}
-function validateBoltPositionsForServiceCover(args) {
-  args.positions.forEach(([x2, y2], index2) => {
-    if (!Number.isFinite(x2) || !Number.isFinite(y2)) {
-      throw new Error(`boltedServiceCover: boltPositions[${index2}] must contain finite numbers`);
-    }
-    if (Math.abs(x2) + args.holeRadius >= args.coverWidth / 2 || Math.abs(y2) + args.holeRadius >= args.coverDepth / 2) {
-      throw new Error(`boltedServiceCover: boltPositions[${index2}] is too close to the cover edge`);
-    }
-    const overlapsOpening = Math.abs(x2) - args.holeRadius <= args.openingWidth / 2 && Math.abs(y2) - args.holeRadius <= args.openingDepth / 2;
-    if (overlapsOpening) {
-      throw new Error(
-        `boltedServiceCover: boltPositions[${index2}] lands over the service opening; decrease boltInset, increase ledgeWidth, or provide a smaller opening`
-      );
-    }
-  });
-}
-function placeCutterAtPositions(cutter, positions, z2) {
-  return union(...positions.map(([x2, y2]) => cutter.translate(x2, y2, z2)));
-}
-function boltedServiceCover(options) {
-  const width = requirePositive$6(options.width, "width");
-  const depth = requirePositive$6(options.depth, "depth");
-  const coverThickness = requirePositive$6(options.coverThickness ?? 3, "coverThickness");
-  const parentThickness = requirePositive$6(options.parentThickness ?? 8, "parentThickness");
-  const ledgeWidth = requirePositive$6(options.ledgeWidth ?? 8, "ledgeWidth");
-  const gasketThickness = Math.max(0, options.gasketThickness ?? 0.8);
-  const gasketInset = Math.max(0, options.gasketInset ?? 2);
-  const screwSize = options.screwSize ?? "M4";
-  const segments = options.segments ?? 36;
-  const sizeData = METRIC_HOLE_TABLE[screwSize];
-  if (!sizeData) throw new Error(`boltedServiceCover: unsupported screwSize "${screwSize}"`);
-  const screwLength = requirePositive$6(options.screwLength ?? parentThickness + gasketThickness + coverThickness + 4, "screwLength");
-  const coverFit = options.coverFit ?? "normal";
-  const counterboreEnabled = options.counterbore ?? true;
-  const [insetX, insetY] = resolveBoltInset(options.boltInset, Math.max(ledgeWidth * 0.65, sizeData.head * 0.75));
-  if (insetX * 2 >= width || insetY * 2 >= depth) {
-    throw new Error("boltedServiceCover: boltInset leaves no room for a four-corner bolt pattern");
-  }
-  const boltPositions = options.boltPositions ?? [
-    [-width / 2 + insetX, -depth / 2 + insetY],
-    [width / 2 - insetX, -depth / 2 + insetY],
-    [-width / 2 + insetX, depth / 2 - insetY],
-    [width / 2 - insetX, depth / 2 - insetY]
-  ];
-  if (boltPositions.length === 0) throw new Error("boltedServiceCover: boltPositions must contain at least one point");
-  const parentWidth = width + ledgeWidth * 2;
-  const parentDepth = depth + ledgeWidth * 2;
-  const openingWidth = Math.max(1, width - ledgeWidth * 2);
-  const openingDepth = Math.max(1, depth - ledgeWidth * 2);
-  validateBoltPositionsForServiceCover({
-    positions: boltPositions,
-    coverWidth: width,
-    coverDepth: depth,
-    openingWidth,
-    openingDepth,
-    holeRadius: sizeData[coverFit] / 2
-  });
-  const coverHole = fastenerHole({
-    size: screwSize,
-    fit: coverFit,
-    depth: coverThickness + 0.6,
-    center: true,
-    segments,
-    ...counterboreEnabled ? { counterbore: { depth: Math.min(coverThickness * 0.6, Math.max(0.6, coverThickness - 0.4)) } } : {}
-  });
-  const parentTap = fastenerHole({ size: screwSize, fit: "tap", depth: parentThickness + 0.6, center: true, segments });
-  const parentThreadEnvelope = fastenerHole({
-    size: screwSize,
-    fit: "close",
-    depth: parentThickness + 0.6,
-    center: true,
-    segments
-  });
-  const openingCutter = box(openingWidth, openingDepth, parentThickness + 1).translate(0, 0, -0.5);
-  const parentTappedPattern = placeCutterAtPositions(parentTap, boltPositions, parentThickness / 2);
-  const parentThreadEnvelopePattern = placeCutterAtPositions(parentThreadEnvelope, boltPositions, parentThickness / 2);
-  const parent = box(parentWidth, parentDepth, parentThickness).subtract(openingCutter).subtract(parentThreadEnvelopePattern).color("#4b5563");
-  let coverBlank = box(width, depth, coverThickness);
-  if (options.pullTabs ?? true) {
-    const tabWidth = Math.min(width * 0.18, Math.max(sizeData.head * 1.6, 12));
-    const tabDepth = Math.max(4, coverThickness * 1.4);
-    const tabOverlap = Math.min(0.5, tabDepth * 0.25);
-    const tabY = -depth / 2 - tabDepth / 2 + tabOverlap;
-    const tabX = width * 0.23;
-    coverBlank = union(
-      coverBlank,
-      box(tabWidth, tabDepth, coverThickness).translate(-tabX, tabY, 0),
-      box(tabWidth, tabDepth, coverThickness).translate(tabX, tabY, 0)
-    );
-  }
-  const coverClearancePattern = placeCutterAtPositions(coverHole, boltPositions, coverThickness / 2);
-  const cover = coverBlank.subtract(coverClearancePattern).translate(0, 0, parentThickness + gasketThickness).color("#334155");
-  const gasket = gasketThickness > 0 ? box(Math.max(1, width - gasketInset * 2), Math.max(1, depth - gasketInset * 2), gasketThickness).subtract(placeCutterAtPositions(coverHole, boltPositions, gasketThickness / 2)).translate(0, 0, parentThickness).color("#111827") : null;
-  const hardware = fastenerSet(screwSize, screwLength, { washerUnderHead: false, washerUnderNut: false, fit: coverFit, segments });
-  const screwOriginZ = parentThickness + gasketThickness + coverThickness;
-  const screws = boltPositions.map(([x2, y2]) => hardware.bolt.translate(x2, y2, screwOriginZ).color("#94a3b8"));
-  const parts = [
-    { name: "service cover parent ledge with threaded hole envelopes", shape: parent },
-    ...gasket ? [{ name: "service cover gasket seated on ledge", shape: gasket }] : [],
-    { name: "bolted service cover plate with fused pull tabs", shape: cover },
-    ...screws.map((shape, index2) => ({ name: `installed ${screwSize} cover screw ${index2 + 1}`, shape }))
-  ];
-  return {
-    parts,
-    parent,
-    cover,
-    gasket,
-    screws,
-    boltPositions,
-    cutters: {
-      coverClearance: coverClearancePattern,
-      parentTapped: parentTappedPattern,
-      parentThreadEnvelope: parentThreadEnvelopePattern
-    },
-    dims: {
-      width,
-      depth,
-      coverThickness,
-      parentThickness,
-      ledgeWidth,
-      gasketThickness,
-      screwSize,
-      screwLength,
-      clearanceDia: sizeData[coverFit],
-      tapDia: sizeData.tap,
-      threadEnvelopeDia: sizeData.close
-    }
-  };
-}
-function datumEnclosureAssembly(options) {
-  const width = requirePositive$6(options.width, "width");
-  const depth = requirePositive$6(options.depth, "depth");
-  const height = requirePositive$6(options.height, "height");
-  const wallThickness = requirePositive$6(options.wallThickness ?? 2.4, "wallThickness");
-  const baseThickness = requirePositive$6(options.baseThickness ?? wallThickness, "baseThickness");
-  const coverThickness = requirePositive$6(options.coverThickness ?? 2.4, "coverThickness");
-  const ledgeWidth = requirePositive$6(options.ledgeWidth ?? Math.max(3.6, wallThickness * 1.35), "ledgeWidth");
-  const gasketThickness = requireNonNegative(options.gasketThickness ?? 0.8, "gasketThickness");
-  const faceClearance = requirePositive$6(options.faceClearance ?? 0.04, "faceClearance");
-  const screwSize = options.screwSize ?? "M3";
-  const coverFit = options.coverFit ?? "normal";
-  const segments = options.segments ?? 32;
-  const sizeData = METRIC_HOLE_TABLE[screwSize];
-  if (!sizeData) throw new Error(`datumEnclosureAssembly: unsupported screwSize "${screwSize}"`);
-  const innerWidth = width - wallThickness * 2;
-  const innerDepth = depth - wallThickness * 2;
-  if (innerWidth <= ledgeWidth * 2 + 8 || innerDepth <= ledgeWidth * 2 + 8) {
-    throw new Error("datumEnclosureAssembly: wallThickness and ledgeWidth leave too little internal opening");
-  }
-  if (height <= baseThickness + coverThickness + 4) {
-    throw new Error("datumEnclosureAssembly: height must leave room for internal ribs and standoffs");
-  }
-  const standoffDiameter = requirePositive$6(
-    options.standoffDiameter ?? Math.max(sizeData.head * 1.65, sizeData.close * 2.2),
-    "standoffDiameter"
-  );
-  const minInset = wallThickness + Math.max(ledgeWidth, standoffDiameter / 2 + 1.2);
-  const [insetX, insetY] = resolveBoltInset(options.screwInset, minInset);
-  if (insetX * 2 >= width || insetY * 2 >= depth) {
-    throw new Error("datumEnclosureAssembly: screwInset leaves no room for the standoff datum");
-  }
-  const screwPositions = options.screwPositions ?? [
-    [-width / 2 + insetX, -depth / 2 + insetY],
-    [width / 2 - insetX, -depth / 2 + insetY],
-    [-width / 2 + insetX, depth / 2 - insetY],
-    [width / 2 - insetX, depth / 2 - insetY]
-  ];
-  if (screwPositions.length === 0) throw new Error("datumEnclosureAssembly: screwPositions must contain at least one point");
-  for (const [index2, [x2, y2]] of screwPositions.entries()) {
-    if (!Number.isFinite(x2) || !Number.isFinite(y2)) {
-      throw new Error(`datumEnclosureAssembly: screwPositions[${index2}] must contain finite numbers`);
-    }
-    if (Math.abs(x2) + standoffDiameter / 2 > innerWidth / 2 || Math.abs(y2) + standoffDiameter / 2 > innerDepth / 2) {
-      throw new Error(`datumEnclosureAssembly: screwPositions[${index2}] does not fit inside the enclosure walls`);
-    }
-  }
-  const ribHeight = requirePositive$6(options.ribHeight ?? Math.min(height * 0.24, Math.max(2.4, baseThickness * 1.4)), "ribHeight");
-  const ribThickness = requirePositive$6(options.ribThickness ?? Math.max(1.2, wallThickness * 0.75), "ribThickness");
-  const portWidth = requirePositive$6(options.portWidth ?? Math.min(innerWidth * 0.28, Math.max(12, width * 0.16)), "portWidth");
-  const portHeight = requirePositive$6(options.portHeight ?? Math.min(height * 0.42, Math.max(5, height * 0.28)), "portHeight");
-  if (portWidth >= innerWidth - ledgeWidth * 2) {
-    throw new Error("datumEnclosureAssembly: portWidth must fit between internal ledges and standoffs");
-  }
-  if (portHeight >= height - baseThickness - 1) {
-    throw new Error("datumEnclosureAssembly: portHeight must leave material above and below the service port");
-  }
-  const screwLength = requirePositive$6(options.screwLength ?? coverThickness + gasketThickness + Math.max(6, height * 0.45), "screwLength");
-  const coverHole = fastenerHole({
-    size: screwSize,
-    fit: coverFit,
-    depth: coverThickness + 0.6,
-    center: true,
-    segments,
-    counterbore: { depth: Math.min(coverThickness * 0.6, Math.max(0.6, coverThickness - 0.35)) }
-  });
-  const standoffTap = fastenerHole({ size: screwSize, fit: "tap", depth: height + 0.8, center: true, segments });
-  const standoffThreadEnvelope = fastenerHole({ size: screwSize, fit: "close", depth: height + 0.8, center: true, segments });
-  const coverClearance = placeCutterAtPositions(coverHole, screwPositions, coverThickness / 2);
-  const standoffTappedPattern = placeCutterAtPositions(standoffTap, screwPositions, height / 2);
-  const standoffThreadEnvelopePattern = placeCutterAtPositions(standoffThreadEnvelope, screwPositions, height / 2);
-  const fuseOverlap = Math.min(0.06, Math.max(0.02, wallThickness * 0.02));
-  const ledgeThickness = Math.min(Math.max(1.1, coverThickness * 0.45), height * 0.2);
-  const sideX = width / 2 - wallThickness / 2;
-  const sideY = depth / 2 - wallThickness / 2;
-  const ledgeZ = height - ledgeThickness;
-  const baseSolids = [
-    box(width, depth, baseThickness),
-    box(wallThickness, depth, height).translate(sideX, 0, 0),
-    box(wallThickness, depth, height).translate(-sideX, 0, 0),
-    box(width, wallThickness, height).translate(0, sideY, 0),
-    box(width, wallThickness, height).translate(0, -sideY, 0),
-    box(ledgeWidth, innerDepth, ledgeThickness).translate(-width / 2 + wallThickness + ledgeWidth / 2, 0, ledgeZ),
-    box(ledgeWidth, innerDepth, ledgeThickness).translate(width / 2 - wallThickness - ledgeWidth / 2, 0, ledgeZ),
-    box(innerWidth, ledgeWidth, ledgeThickness).translate(0, -depth / 2 + wallThickness + ledgeWidth / 2, ledgeZ),
-    box(innerWidth, ledgeWidth, ledgeThickness).translate(0, depth / 2 - wallThickness - ledgeWidth / 2, ledgeZ),
-    box(Math.max(1, innerWidth - standoffDiameter * 1.8), ribThickness, ribHeight + fuseOverlap).translate(
-      0,
-      0,
-      baseThickness - fuseOverlap
-    ),
-    box(ribThickness, Math.max(1, innerDepth - standoffDiameter * 1.8), ribHeight + fuseOverlap).translate(
-      0,
-      0,
-      baseThickness - fuseOverlap
-    ),
-    ...screwPositions.map(
-      ([x2, y2]) => cylinder(height - baseThickness + fuseOverlap, standoffDiameter / 2, void 0, segments).translate(
-        x2,
-        y2,
-        baseThickness - fuseOverlap
-      )
-    )
-  ];
-  const servicePort = box(portWidth, wallThickness + 1, portHeight).translate(
-    0,
-    -depth / 2 + wallThickness / 2,
-    baseThickness + Math.max(0.8, (height - baseThickness - portHeight) * 0.35)
-  );
-  const base = union(...baseSolids).subtract(standoffThreadEnvelopePattern).subtract(servicePort).color("#475569");
-  const gasketFrameCutter = box(Math.max(1, width - ledgeWidth * 2), Math.max(1, depth - ledgeWidth * 2), gasketThickness + 0.6).translate(
-    0,
-    0,
-    -0.3
-  );
-  const gasket = gasketThickness > 0 ? box(width, depth, gasketThickness).subtract(gasketFrameCutter).subtract(placeCutterAtPositions(coverHole, screwPositions, gasketThickness / 2)).translate(0, 0, height + faceClearance).color("#111827") : null;
-  const coverZ = height + faceClearance + (gasket ? gasketThickness + faceClearance : 0);
-  const cover = box(width, depth, coverThickness).subtract(coverClearance).translate(0, 0, coverZ).color("#334155");
-  const hardware = fastenerSet(screwSize, screwLength, { washerUnderHead: false, washerUnderNut: false, fit: coverFit, segments });
-  const screwOriginZ = coverZ + coverThickness;
-  const screws = screwPositions.map(([x2, y2]) => hardware.bolt.translate(x2, y2, screwOriginZ).color("#94a3b8"));
-  const parts = [
-    { name: "datum enclosure base tray with walls ribs standoffs and service port", shape: base },
-    ...gasket ? [{ name: "datum enclosure gasket seated on continuous ledge", shape: gasket }] : [],
-    { name: "datum enclosure cover plate with matched screw pattern", shape: cover },
-    ...screws.map((shape, index2) => ({ name: `installed ${screwSize} enclosure screw ${index2 + 1}`, shape }))
-  ];
-  return {
-    parts,
-    base,
-    cover,
-    gasket,
-    screws,
-    screwPositions,
-    cutters: {
-      coverClearance,
-      standoffTapped: standoffTappedPattern,
-      standoffThreadEnvelope: standoffThreadEnvelopePattern,
-      servicePort
-    },
-    dims: {
-      width,
-      depth,
-      height,
-      innerWidth,
-      innerDepth,
-      wallThickness,
-      baseThickness,
-      coverThickness,
-      ledgeWidth,
-      gasketThickness,
-      faceClearance,
-      screwSize,
-      screwLength,
-      standoffDiameter,
-      ribHeight,
-      ribThickness,
-      portWidth,
-      portHeight,
-      clearanceDia: sizeData[coverFit],
-      tapDia: sizeData.tap,
-      threadEnvelopeDia: sizeData.close
-    }
-  };
-}
-function snapLatchCoverAssembly(options) {
-  const width = requirePositive$6(options.width, "width");
-  const depth = requirePositive$6(options.depth, "depth");
-  const coverThickness = requirePositive$6(options.coverThickness ?? 2.4, "coverThickness");
-  const parentThickness = requirePositive$6(options.parentThickness ?? 6, "parentThickness");
-  const ledgeWidth = requirePositive$6(options.ledgeWidth ?? 8, "ledgeWidth");
-  const runningClearance = requirePositive$6(options.runningClearance ?? 0.25, "runningClearance");
-  const faceClearance = requirePositive$6(options.faceClearance ?? 0.04, "faceClearance");
-  const latchWidth = requirePositive$6(options.latchWidth ?? Math.min(width * 0.22, Math.max(12, width * 0.16)), "latchWidth");
-  const latchThickness = requirePositive$6(options.latchThickness ?? 1.6, "latchThickness");
-  const hookThrow = requirePositive$6(options.hookThrow ?? 3.2, "hookThrow");
-  const hookThickness = requirePositive$6(options.hookThickness ?? 1.6, "hookThickness");
-  const openingWidth = width - ledgeWidth * 2;
-  const openingDepth = depth - ledgeWidth * 2;
-  if (openingWidth <= Math.max(8, latchWidth * 0.8) || openingDepth <= 8) {
-    throw new Error("snapLatchCoverAssembly: ledgeWidth leaves too little service opening under the cover");
-  }
-  if (latchWidth >= openingWidth) {
-    throw new Error("snapLatchCoverAssembly: latchWidth must fit along the receiver opening");
-  }
-  if (latchThickness + runningClearance * 2 >= ledgeWidth) {
-    throw new Error("snapLatchCoverAssembly: latchThickness and clearance must fit inside the receiver ledge");
-  }
-  if (hookThrow + latchThickness / 2 + runningClearance >= ledgeWidth * 1.5) {
-    throw new Error("snapLatchCoverAssembly: hookThrow is too large for the available underside catch land");
-  }
-  const parentWidth = width + ledgeWidth * 2;
-  const parentDepth = depth + ledgeWidth * 2;
-  const fuseOverlap = Math.min(0.04, faceClearance * 0.7);
-  const hookClearance = Math.min(0.08, runningClearance * 0.32);
-  const coverMinZ = parentThickness + faceClearance;
-  const stemMinZ = -hookClearance - hookThickness;
-  const stemHeight = coverMinZ + fuseOverlap - stemMinZ;
-  const slotY = openingDepth / 2 + ledgeWidth / 2;
-  const latchWindow = (sign2) => box(latchWidth + runningClearance * 2, latchThickness + runningClearance * 2, parentThickness + 0.8).translate(0, sign2 * slotY, -0.4);
-  const latchWindows = union(latchWindow(1), latchWindow(-1));
-  const serviceOpening = box(openingWidth, openingDepth, parentThickness + 1).translate(0, 0, -0.5);
-  const parent = box(parentWidth, parentDepth, parentThickness).subtract(serviceOpening).subtract(latchWindows).color("#475569");
-  const coverPlate = box(width, depth, coverThickness).translate(0, 0, coverMinZ);
-  const snapHook = (sign2) => {
-    const y2 = sign2 * slotY;
-    const stem = box(latchWidth, latchThickness, stemHeight).translate(0, y2, stemMinZ);
-    const barb = box(latchWidth, latchThickness + hookThrow, hookThickness).translate(0, y2 + sign2 * (hookThrow / 2), stemMinZ);
-    const rootRib = box(latchWidth, Math.max(latchThickness, hookThrow * 0.55), coverThickness * 0.65).translate(
-      0,
-      y2 - sign2 * (ledgeWidth * 0.18),
-      coverMinZ
-    );
-    return union(stem, barb, rootRib);
-  };
-  const cover = union(coverPlate, snapHook(1), snapHook(-1)).color("#111827");
-  const parts = [
-    { name: "snap cover receiver frame with latch windows and catch lands", shape: parent },
-    { name: "one-piece snap cover with fused hooks and underside barbs", shape: cover }
-  ];
-  return {
-    parts,
-    parent,
-    cover,
-    cutters: {
-      serviceOpening,
-      latchWindows
-    },
-    dims: {
-      width,
-      depth,
-      parentWidth,
-      parentDepth,
-      openingWidth,
-      openingDepth,
-      coverThickness,
-      parentThickness,
-      ledgeWidth,
-      latchWidth,
-      latchThickness,
-      hookThrow,
-      hookThickness,
-      runningClearance,
-      faceClearance
-    }
-  };
-}
-function pinnedLeverAssembly(options) {
-  const armLength = requirePositive$6(options.armLength, "armLength");
-  const armWidth = requirePositive$6(options.armWidth ?? 10, "armWidth");
-  const leverThickness = requirePositive$6(options.leverThickness ?? 5, "leverThickness");
-  const pinDiameter = requirePositive$6(options.pinDiameter ?? 5, "pinDiameter");
-  const pinClearance = requireNonNegative(options.pinClearance ?? 0.25, "pinClearance");
-  const boreDiameter = pinDiameter + pinClearance;
-  const hubRadius = requirePositive$6(options.hubRadius ?? Math.max(armWidth * 0.85, pinDiameter * 1.8), "hubRadius");
-  const supportThickness = requirePositive$6(options.supportThickness ?? Math.max(6, pinDiameter * 1.4), "supportThickness");
-  const supportWidth = requirePositive$6(options.supportWidth ?? hubRadius * 2 + 18, "supportWidth");
-  const supportDepth = requirePositive$6(options.supportDepth ?? Math.max(armWidth + 18, hubRadius * 2 + 10), "supportDepth");
-  const washerSize = options.washerSize ?? metricWasherSizeForPin(pinDiameter);
-  const washerDims = WASHER_TABLE[washerSize];
-  if (!washerDims) throw new Error(`pinnedLeverAssembly: unsupported washerSize "${washerSize}"`);
-  if (washerDims.id <= pinDiameter) {
-    throw new Error(`pinnedLeverAssembly: ${washerSize} washer inner diameter is too small for a ${pinDiameter} mm pin`);
-  }
-  if (hubRadius <= boreDiameter / 2 + Math.max(1, pinDiameter * 0.25)) {
-    throw new Error("pinnedLeverAssembly: hubRadius leaves too little material around the pivot bore");
-  }
-  if (supportWidth <= boreDiameter + 4 || supportDepth <= boreDiameter + 4) {
-    throw new Error("pinnedLeverAssembly: support dimensions leave too little material around the pivot bore");
-  }
-  const segments = options.segments ?? 40;
-  const gripLength = requirePositive$6(options.gripLength ?? Math.min(armLength * 0.32, Math.max(16, armWidth * 2.4)), "gripLength");
-  const gripWidth = requirePositive$6(options.gripWidth ?? armWidth * 1.55, "gripWidth");
-  if (gripLength >= armLength) throw new Error("pinnedLeverAssembly: gripLength must be shorter than armLength");
-  const armOverlap = Math.min(hubRadius * 0.65, armLength * 0.25);
-  const armStartX = hubRadius - armOverlap;
-  const armCenterX = armStartX + armLength / 2;
-  const gripCenterX = armStartX + armLength - gripLength / 2;
-  const runningClearance = 0.03;
-  const lowerWasherZ = supportThickness + runningClearance;
-  const leverZ = lowerWasherZ + washerDims.t + runningClearance;
-  const upperWasherZ = leverZ + leverThickness + runningClearance;
-  const stackHeight = upperWasherZ + washerDims.t;
-  const pinHeadThickness = Math.max(washerDims.t, pinDiameter * 0.35);
-  const pinHeadRadius = Math.max(washerDims.od * 0.42, pinDiameter * 0.8);
-  const supportBore = cylinder(supportThickness + 1, boreDiameter / 2, void 0, segments).translate(0, 0, -0.5);
-  let supportBlank = box(supportWidth, supportDepth, supportThickness);
-  if (options.stopBlock ?? true) {
-    const stopLength = Math.min(armLength * 0.22, Math.max(10, armWidth * 1.4));
-    const stopWidth = Math.max(4, pinDiameter * 0.7);
-    const stopHeight = supportThickness;
-    const stopX = hubRadius + stopLength / 2;
-    const stopY = armWidth / 2 + stopWidth / 2 + runningClearance;
-    supportBlank = union(supportBlank, box(stopLength, stopWidth, stopHeight).translate(stopX, stopY, 0));
-  }
-  const support = supportBlank.subtract(supportBore).color("#475569");
-  const hub = cylinder(leverThickness, hubRadius, void 0, segments);
-  const arm = box(armLength, armWidth, leverThickness).translate(armCenterX, 0, 0);
-  const grip = box(gripLength, gripWidth, leverThickness).translate(gripCenterX, 0, 0);
-  const leverSolids = [hub, arm, grip];
-  if (options.detentBoss ?? true) {
-    const bossRadius = Math.min(armWidth * 0.42, hubRadius * 0.42);
-    const bossX = hubRadius + Math.min(armLength * 0.22, armWidth * 2);
-    const bossY = -armWidth / 2 - bossRadius * 0.45;
-    leverSolids.push(cylinder(leverThickness, bossRadius, void 0, segments).translate(bossX, bossY, 0));
-  }
-  const leverBore = cylinder(leverThickness + 1, boreDiameter / 2, void 0, segments).translate(0, 0, -0.5);
-  const lever = union(...leverSolids).subtract(leverBore).translate(0, 0, leverZ).color("#7f1d1d");
-  const lowerWasher = washer(washerSize, { segments }).translate(0, 0, lowerWasherZ).color("#94a3b8");
-  const upperWasher = washer(washerSize, { segments }).translate(0, 0, upperWasherZ).color("#94a3b8");
-  const shaft = cylinder(stackHeight, pinDiameter / 2, void 0, segments);
-  const lowerRetainer = cylinder(pinHeadThickness, pinHeadRadius, void 0, segments).translate(
-    0,
-    0,
-    -pinHeadThickness - runningClearance
-  );
-  const upperHead = cylinder(pinHeadThickness, pinHeadRadius, void 0, segments).translate(0, 0, stackHeight + runningClearance);
-  const pin = union(shaft, lowerRetainer, upperHead).color("#cbd5e1");
-  const pivotBore = cylinder(stackHeight + 1, boreDiameter / 2, void 0, segments).translate(0, 0, -0.5);
-  const parts = [
-    { name: "pivot support block with bearing bore and low stop land", shape: support },
-    { name: "lower thrust washer under pinned lever", shape: lowerWasher },
-    { name: "fused pinned lever with hub arm grip and detent boss", shape: lever },
-    { name: "upper thrust washer over pinned lever", shape: upperWasher },
-    { name: "retained pivot pin through lever stack", shape: pin }
-  ];
-  return {
-    parts,
-    support,
-    lever,
-    pin,
-    washers: {
-      lower: lowerWasher,
-      upper: upperWasher
-    },
-    cutters: {
-      pivotBore
-    },
-    dims: {
-      armLength,
-      armWidth,
-      leverThickness,
-      hubRadius,
-      pinDiameter,
-      boreDiameter,
-      supportWidth,
-      supportDepth,
-      supportThickness,
-      washerSize,
-      washerThickness: washerDims.t,
-      stackHeight
-    }
-  };
-}
-function retainedShaftAssembly(options) {
-  const supportSpacing = requirePositive$6(options.supportSpacing, "supportSpacing");
-  const shaftDiameter = requirePositive$6(options.shaftDiameter ?? 8, "shaftDiameter");
-  const boreClearance = requireNonNegative(options.boreClearance ?? 0.35, "boreClearance");
-  const boreDiameter = shaftDiameter + boreClearance;
-  const supportThickness = requirePositive$6(options.supportThickness ?? Math.max(5, shaftDiameter * 0.75), "supportThickness");
-  const washerSize = options.washerSize ?? metricWasherSizeForPin(shaftDiameter);
-  const washerDims = WASHER_TABLE[washerSize];
-  if (!washerDims) throw new Error(`retainedShaftAssembly: unsupported washerSize "${washerSize}"`);
-  if (washerDims.id <= shaftDiameter) {
-    throw new Error(`retainedShaftAssembly: ${washerSize} washer inner diameter is too small for a ${shaftDiameter} mm shaft`);
-  }
-  const knobDiameter = requirePositive$6(options.knobDiameter ?? shaftDiameter * 3, "knobDiameter");
-  const knobThickness = requirePositive$6(options.knobThickness ?? Math.max(8, shaftDiameter), "knobThickness");
-  const retainerThickness = requirePositive$6(options.retainerThickness ?? Math.max(washerDims.t, shaftDiameter * 0.35), "retainerThickness");
-  const runningClearance = requireNonNegative(options.runningClearance ?? 0.05, "runningClearance");
-  const supportWidth = requirePositive$6(options.supportWidth ?? Math.max(28, knobDiameter * 1.25), "supportWidth");
-  const supportHeight = requirePositive$6(options.supportHeight ?? Math.max(34, knobDiameter * 1.45), "supportHeight");
-  const segments = options.segments ?? 40;
-  if (supportSpacing <= supportThickness) {
-    throw new Error("retainedShaftAssembly: supportSpacing must leave a gap between support cheeks");
-  }
-  if (supportWidth <= boreDiameter + 4 || supportHeight <= boreDiameter + 4) {
-    throw new Error("retainedShaftAssembly: support dimensions leave too little material around the shaft bore");
-  }
-  const leftSupportX = -supportSpacing / 2;
-  const rightSupportX = supportSpacing / 2;
-  const leftOuterFaceX = leftSupportX - supportThickness / 2;
-  const rightOuterFaceX = rightSupportX + supportThickness / 2;
-  const leftWasherX = leftOuterFaceX - runningClearance - washerDims.t / 2;
-  const rightWasherX = rightOuterFaceX + runningClearance + washerDims.t / 2;
-  const leftKnobX = leftOuterFaceX - runningClearance * 2 - washerDims.t - knobThickness / 2;
-  const rightKnobX = rightOuterFaceX + runningClearance * 2 + washerDims.t + knobThickness / 2;
-  const leftStackOuterX = leftKnobX - knobThickness / 2;
-  const rightStackOuterX = rightKnobX + knobThickness / 2;
-  const minimumShaftLength = rightStackOuterX - leftStackOuterX + retainerThickness * 2 + runningClearance * 2;
-  const shaftLength = requirePositive$6(options.shaftLength ?? minimumShaftLength, "shaftLength");
-  if (shaftLength < minimumShaftLength) {
-    throw new Error("retainedShaftAssembly: shaftLength is too short to retain both supports, washers, and knobs");
-  }
-  const supportBore = cylinderAlongX(supportThickness + 1, boreDiameter / 2, 0, segments);
-  const makeSupport = (x2) => box(supportThickness, supportWidth, supportHeight).translate(x2, 0, -supportHeight / 2).subtract(supportBore.translate(x2, 0, 0)).color("#334155");
-  const knobBore = cylinder(knobThickness + 1, boreDiameter / 2, void 0, segments).translate(0, 0, -0.5);
-  const makeKnob = (x2) => cylinder(knobThickness, knobDiameter / 2, void 0, 18).subtract(knobBore).pointAlong([1, 0, 0]).translate(x2 - knobThickness / 2, 0, 0).color("#111827");
-  const retainerRadius = Math.max(shaftDiameter * 0.85, knobDiameter * 0.36);
-  const shaftCore = cylinderAlongX(shaftLength, shaftDiameter / 2, 0, segments);
-  const leftRetainer = cylinderAlongX(retainerThickness, retainerRadius, -shaftLength / 2 + retainerThickness / 2, segments);
-  const rightRetainer = cylinderAlongX(retainerThickness, retainerRadius, shaftLength / 2 - retainerThickness / 2, segments);
-  const shaft = union(shaftCore, leftRetainer, rightRetainer).color("#cbd5e1");
-  const leftSupport = makeSupport(leftSupportX);
-  const rightSupport = makeSupport(rightSupportX);
-  const leftWasher = washerAlongX(washerSize, leftWasherX, segments).color("#94a3b8");
-  const rightWasher = washerAlongX(washerSize, rightWasherX, segments).color("#94a3b8");
-  const leftKnob = makeKnob(leftKnobX);
-  const rightKnob = makeKnob(rightKnobX);
-  const shaftBore = cylinderAlongX(supportThickness + knobThickness + 2, boreDiameter / 2, 0, segments);
-  const parts = [
-    { name: "left bored support cheek for retained shaft", shape: leftSupport },
-    { name: "right bored support cheek for retained shaft", shape: rightSupport },
-    { name: "retained through shaft with end heads", shape: shaft },
-    { name: `left ${washerSize} thrust washer on shaft`, shape: leftWasher },
-    { name: `right ${washerSize} thrust washer on shaft`, shape: rightWasher },
-    { name: "left retained hand knob with shaft bore", shape: leftKnob },
-    { name: "right retained hand knob with shaft bore", shape: rightKnob }
-  ];
-  return {
-    parts,
-    supports: {
-      left: leftSupport,
-      right: rightSupport
-    },
-    shaft,
-    washers: {
-      left: leftWasher,
-      right: rightWasher
-    },
-    knobs: {
-      left: leftKnob,
-      right: rightKnob
-    },
-    cutters: {
-      shaftBore
-    },
-    dims: {
-      supportSpacing,
-      supportThickness,
-      supportWidth,
-      supportHeight,
-      shaftDiameter,
-      shaftLength,
-      boreDiameter,
-      washerSize,
-      washerThickness: washerDims.t,
-      knobDiameter,
-      knobThickness,
-      retainerThickness,
-      runningClearance
-    }
-  };
-}
-function capturedLinearSlide(options) {
-  const length4 = requirePositive$6(options.length, "length");
-  const railWidth = requirePositive$6(options.railWidth ?? 38, "railWidth");
-  const baseThickness = requirePositive$6(options.baseThickness ?? 2.4, "baseThickness");
-  const wallThickness = requirePositive$6(options.wallThickness ?? 2, "wallThickness");
-  const wallHeight = requirePositive$6(options.wallHeight ?? 9, "wallHeight");
-  const lipWidth = requirePositive$6(options.lipWidth ?? 4, "lipWidth");
-  const lipThickness = requirePositive$6(options.lipThickness ?? 1.8, "lipThickness");
-  const runningClearance = requirePositive$6(options.runningClearance ?? 0.35, "runningClearance");
-  const endStopLength = requirePositive$6(options.endStopLength ?? 6, "endStopLength");
-  const carriageLength = requirePositive$6(options.carriageLength ?? length4 * 0.32, "carriageLength");
-  const innerWidth = railWidth - wallThickness * 2;
-  const throatWidth = innerWidth - lipWidth * 2;
-  if (innerWidth <= 0) throw new Error("capturedLinearSlide: wallThickness leaves no inner rail width");
-  if (throatWidth <= 0) throw new Error("capturedLinearSlide: lipWidth closes the rail throat");
-  const carriageWidth = requirePositive$6(options.carriageWidth ?? innerWidth - runningClearance * 2, "carriageWidth");
-  const carriageThickness = requirePositive$6(options.carriageThickness ?? 4, "carriageThickness");
-  if (carriageWidth >= innerWidth - runningClearance) {
-    throw new Error("capturedLinearSlide: carriageWidth leaves too little side clearance inside the rail");
-  }
-  if (carriageWidth <= throatWidth + runningClearance) {
-    throw new Error("capturedLinearSlide: carriageWidth must be wider than the lip throat so the rail actually captures it");
-  }
-  if (carriageThickness + runningClearance * 2 >= wallHeight) {
-    throw new Error("capturedLinearSlide: carriage is too tall to clear the return lips");
-  }
-  const maxTravel = length4 - endStopLength * 2 - carriageLength;
-  if (maxTravel <= 0) {
-    throw new Error("capturedLinearSlide: rail length, end stops, and carriage length leave no travel");
-  }
-  const travel = options.travel ?? maxTravel / 2;
-  if (!Number.isFinite(travel) || travel < 0 || travel > maxTravel) {
-    throw new Error(`capturedLinearSlide: travel must be between 0 and ${maxTravel}`);
-  }
-  const carriageCenterX = -maxTravel / 2 + travel;
-  const fuseOverlap = Math.min(0.04, runningClearance * 0.1);
-  const sideY = railWidth / 2 - wallThickness / 2;
-  const lipY = railWidth / 2 - wallThickness - lipWidth / 2 + fuseOverlap / 2;
-  const stopZ = baseThickness - fuseOverlap;
-  const rail2 = union(
-    box(length4, railWidth, baseThickness),
-    box(length4, wallThickness, wallHeight + fuseOverlap).translate(0, sideY, baseThickness - fuseOverlap),
-    box(length4, wallThickness, wallHeight + fuseOverlap).translate(0, -sideY, baseThickness - fuseOverlap),
-    box(length4, lipWidth, lipThickness + fuseOverlap).translate(0, lipY, baseThickness + wallHeight - fuseOverlap),
-    box(length4, lipWidth, lipThickness + fuseOverlap).translate(0, -lipY, baseThickness + wallHeight - fuseOverlap),
-    box(endStopLength, throatWidth, carriageThickness + fuseOverlap).translate(-length4 / 2 + endStopLength / 2, 0, stopZ),
-    box(endStopLength, throatWidth, carriageThickness + fuseOverlap).translate(length4 / 2 - endStopLength / 2, 0, stopZ)
-  ).color("#475569");
-  const carriage = union(
-    box(carriageLength, carriageWidth, carriageThickness),
-    box(carriageLength * 0.78, throatWidth - runningClearance * 2, Math.max(1, carriageThickness * 0.38)).translate(
-      0,
-      0,
-      carriageThickness
-    )
-  ).translate(carriageCenterX, 0, baseThickness + runningClearance).color("#111827");
-  const parts = [
-    { name: "captured linear rail with return lips and end stops", shape: rail2 },
-    { name: "sliding carriage captured under rail lips", shape: carriage }
-  ];
-  return {
-    parts,
-    rail: rail2,
-    carriage,
-    dims: {
-      length: length4,
-      railWidth,
-      innerWidth,
-      throatWidth,
-      baseThickness,
-      wallThickness,
-      wallHeight,
-      lipWidth,
-      lipThickness,
-      carriageLength,
-      carriageWidth,
-      carriageThickness,
-      endStopLength,
-      runningClearance,
-      maxTravel,
-      travel,
-      carriageCenterX
-    }
-  };
-}
-function capturedCartridgeGuideAssembly(options) {
-  const length4 = requirePositive$6(options.length, "length");
-  const guideWidth = requirePositive$6(options.guideWidth ?? 42, "guideWidth");
-  const baseThickness = requirePositive$6(options.baseThickness ?? 3, "baseThickness");
-  const wallThickness = requirePositive$6(options.wallThickness ?? 2.5, "wallThickness");
-  const wallHeight = requirePositive$6(options.wallHeight ?? 12, "wallHeight");
-  const lipWidth = requirePositive$6(options.lipWidth ?? 4, "lipWidth");
-  const lipThickness = requirePositive$6(options.lipThickness ?? 2, "lipThickness");
-  const rearStopLength = requirePositive$6(options.rearStopLength ?? 7, "rearStopLength");
-  const runningClearance = requirePositive$6(options.runningClearance ?? 0.35, "runningClearance");
-  const cartridgeLength = requirePositive$6(options.cartridgeLength ?? length4 * 0.58, "cartridgeLength");
-  const cartridgeHeight = requirePositive$6(options.cartridgeHeight ?? 10, "cartridgeHeight");
-  const flangeThickness = requirePositive$6(options.flangeThickness ?? 3, "flangeThickness");
-  const pullTabLength = requirePositive$6(options.pullTabLength ?? 10, "pullTabLength");
-  const innerWidth = guideWidth - wallThickness * 2;
-  const throatWidth = innerWidth - lipWidth * 2;
-  if (innerWidth <= 0) throw new Error("capturedCartridgeGuideAssembly: wallThickness leaves no inner guide width");
-  if (throatWidth <= 0) throw new Error("capturedCartridgeGuideAssembly: lipWidth closes the guide throat");
-  if (wallHeight <= lipThickness + flangeThickness + runningClearance * 2) {
-    throw new Error("capturedCartridgeGuideAssembly: wallHeight leaves too little vertical capture clearance");
-  }
-  const cartridgeWidth = requirePositive$6(options.cartridgeWidth ?? innerWidth - runningClearance * 2, "cartridgeWidth");
-  const cartridgeBodyWidth = throatWidth - runningClearance * 2;
-  if (cartridgeBodyWidth <= 0) {
-    throw new Error("capturedCartridgeGuideAssembly: throatWidth and runningClearance leave no cartridge body width");
-  }
-  if (cartridgeWidth >= innerWidth - runningClearance) {
-    throw new Error("capturedCartridgeGuideAssembly: cartridgeWidth leaves too little side clearance inside the guide");
-  }
-  if (cartridgeWidth <= throatWidth + runningClearance) {
-    throw new Error("capturedCartridgeGuideAssembly: cartridge flange must be wider than the guide throat so the cartridge is captured");
-  }
-  const maxInsertion = length4 - rearStopLength - cartridgeLength;
-  if (maxInsertion <= 0) {
-    throw new Error("capturedCartridgeGuideAssembly: length, rearStopLength, and cartridgeLength leave no insertion travel");
-  }
-  const insertion = options.insertion ?? maxInsertion * 0.4;
-  if (!Number.isFinite(insertion) || insertion < 0 || insertion > maxInsertion) {
-    throw new Error(`capturedCartridgeGuideAssembly: insertion must be between 0 and ${maxInsertion}`);
-  }
-  const cartridgeCenterX = -length4 / 2 + cartridgeLength / 2 + insertion;
-  const fuseOverlap = Math.min(0.04, runningClearance * 0.1);
-  const sideY = guideWidth / 2 - wallThickness / 2;
-  const lipY = guideWidth / 2 - wallThickness - lipWidth / 2 + fuseOverlap / 2;
-  const guide = union(
-    box(length4, guideWidth, baseThickness),
-    box(length4, wallThickness, wallHeight + fuseOverlap).translate(0, sideY, baseThickness - fuseOverlap),
-    box(length4, wallThickness, wallHeight + fuseOverlap).translate(0, -sideY, baseThickness - fuseOverlap),
-    box(length4, lipWidth, lipThickness + fuseOverlap).translate(0, lipY, baseThickness + wallHeight - fuseOverlap),
-    box(length4, lipWidth, lipThickness + fuseOverlap).translate(0, -lipY, baseThickness + wallHeight - fuseOverlap),
-    box(rearStopLength, throatWidth, Math.max(flangeThickness + runningClearance, 4)).translate(
-      length4 / 2 - rearStopLength / 2,
-      0,
-      baseThickness - fuseOverlap
-    )
-  ).color("#475569");
-  const flangeZ = baseThickness + runningClearance;
-  const bodyHeight = Math.max(1, cartridgeHeight - flangeThickness);
-  const bodyZ = flangeZ + flangeThickness;
-  const tabOverlap = Math.min(0.6, pullTabLength * 0.15);
-  const pullTabX = cartridgeCenterX - cartridgeLength / 2 - pullTabLength / 2 + tabOverlap;
-  const pullTabWidth = Math.max(cartridgeBodyWidth * 0.55, 12);
-  const cartridge = union(
-    box(cartridgeLength, cartridgeWidth, flangeThickness).translate(cartridgeCenterX, 0, flangeZ),
-    box(cartridgeLength * 0.88, cartridgeBodyWidth, bodyHeight).translate(cartridgeCenterX, 0, bodyZ),
-    box(pullTabLength, pullTabWidth, Math.max(flangeThickness, 3)).translate(pullTabX, 0, flangeZ)
-  ).color("#111827");
-  const parts = [
-    { name: "captured cartridge guide with return lips and rear stop", shape: guide },
-    { name: "removable cartridge with captured flange and pull tab", shape: cartridge }
-  ];
-  return {
-    parts,
-    guide,
-    cartridge,
-    dims: {
-      length: length4,
-      guideWidth,
-      innerWidth,
-      throatWidth,
-      baseThickness,
-      wallThickness,
-      wallHeight,
-      lipWidth,
-      lipThickness,
-      rearStopLength,
-      cartridgeLength,
-      cartridgeWidth,
-      cartridgeBodyWidth,
-      cartridgeHeight,
-      flangeThickness,
-      pullTabLength,
-      runningClearance,
-      maxInsertion,
-      insertion,
-      cartridgeCenterX
-    }
-  };
-}
-function livingHingeCoverAssembly(options) {
-  const width = requirePositive$6(options.width, "width");
-  const coverDepth = requirePositive$6(options.coverDepth ?? 42, "coverDepth");
-  const fixedLeafDepth = requirePositive$6(options.fixedLeafDepth ?? 18, "fixedLeafDepth");
-  const leafThickness = requirePositive$6(options.leafThickness ?? 2, "leafThickness");
-  const hingeWebWidth = requirePositive$6(options.hingeWebWidth ?? 3.2, "hingeWebWidth");
-  const hingeWebThickness = requirePositive$6(options.hingeWebThickness ?? 0.45, "hingeWebThickness");
-  const pullLipDepth = requirePositive$6(options.pullLipDepth ?? 5, "pullLipDepth");
-  const snapBarbWidth = requirePositive$6(options.snapBarbWidth ?? width * 0.35, "snapBarbWidth");
-  const snapBarbDepth = requirePositive$6(options.snapBarbDepth ?? 2.4, "snapBarbDepth");
-  const snapBarbHeight = requirePositive$6(options.snapBarbHeight ?? 1.4, "snapBarbHeight");
-  const catchLandDepth = requirePositive$6(options.catchLandDepth ?? 2.4, "catchLandDepth");
-  if (hingeWebThickness >= leafThickness * 0.55) {
-    throw new Error("livingHingeCoverAssembly: hingeWebThickness must be much thinner than the rigid leaves");
-  }
-  if (hingeWebWidth >= Math.min(coverDepth, fixedLeafDepth) * 0.45) {
-    throw new Error("livingHingeCoverAssembly: hingeWebWidth is too wide for the selected leaves");
-  }
-  if (snapBarbWidth >= width - 2) {
-    throw new Error("livingHingeCoverAssembly: snapBarbWidth must leave side material on the cover leaf");
-  }
-  const fuseOverlap = Math.min(0.04, hingeWebWidth * 0.02);
-  const fixedCenterY = -hingeWebWidth / 2 - fixedLeafDepth / 2 + fuseOverlap / 2;
-  const coverCenterY = hingeWebWidth / 2 + coverDepth / 2 - fuseOverlap / 2;
-  const fixedLeaf = box(width, fixedLeafDepth + fuseOverlap, leafThickness).translate(0, fixedCenterY, 0);
-  const movingLeaf = box(width, coverDepth + fuseOverlap, leafThickness).translate(0, coverCenterY, 0);
-  const hingeWeb = box(width, hingeWebWidth + fuseOverlap * 2, hingeWebThickness).translate(0, 0, 0);
-  const pullLip = box(width * 0.92, pullLipDepth, leafThickness).translate(
-    0,
-    coverCenterY + coverDepth / 2 + pullLipDepth / 2 - fuseOverlap,
-    0
-  );
-  const snapBarb = box(snapBarbWidth, snapBarbDepth, snapBarbHeight).translate(
-    0,
-    coverCenterY + coverDepth / 2 - snapBarbDepth / 2,
-    leafThickness
-  );
-  const catchLand = box(width * 0.55, catchLandDepth, Math.max(0.8, leafThickness * 0.45)).translate(
-    0,
-    fixedCenterY - fixedLeafDepth / 2 + catchLandDepth / 2,
-    leafThickness
-  );
-  const cover = union(fixedLeaf, movingLeaf, hingeWeb, pullLip, snapBarb, catchLand).color("#0f766e");
-  const overallDepth = fixedLeafDepth + hingeWebWidth + coverDepth + pullLipDepth;
-  const flexRatio = leafThickness / hingeWebThickness;
-  return {
-    parts: [{ name: "one-piece molded living hinge cover with snap barb", shape: cover }],
-    cover,
-    fixedLeaf,
-    movingLeaf,
-    hingeWeb,
-    snapBarb,
-    catchLand,
-    dims: {
-      width,
-      coverDepth,
-      fixedLeafDepth,
-      leafThickness,
-      hingeWebWidth,
-      hingeWebThickness,
-      pullLipDepth,
-      snapBarbWidth,
-      snapBarbDepth,
-      snapBarbHeight,
-      catchLandDepth,
-      flexRatio,
-      overallDepth
-    }
-  };
-}
-function knuckledHingeAssembly(options) {
-  const length4 = requirePositive$6(options.length, "length");
-  const leafLength = requirePositive$6(options.leafLength ?? 36, "leafLength");
-  const leafThickness = requirePositive$6(options.leafThickness ?? 1.6, "leafThickness");
-  const barrelOuterRadius = requirePositive$6(options.barrelOuterRadius ?? 3, "barrelOuterRadius");
-  const pinDiameter = requirePositive$6(options.pinDiameter ?? 2, "pinDiameter");
-  const pinClearance = requireNonNegative(options.pinClearance ?? 0.25, "pinClearance");
-  const boreDiameter = pinDiameter + pinClearance;
-  const knuckleGap = requireNonNegative(options.knuckleGap ?? 0.45, "knuckleGap");
-  const openAngleDeg = Number.isFinite(options.openAngleDeg ?? 35) ? options.openAngleDeg ?? 35 : 35;
-  const retainerThickness = requirePositive$6(options.retainerThickness ?? Math.max(leafThickness, pinDiameter * 0.7), "retainerThickness");
-  const segments = options.segments ?? 36;
-  const knuckleCount = options.knuckleCount ?? 5;
-  if (!Number.isInteger(knuckleCount) || knuckleCount < 3 || knuckleCount % 2 === 0) {
-    throw new Error("knuckledHingeAssembly: knuckleCount must be an odd integer >= 3");
-  }
-  if (barrelOuterRadius <= boreDiameter / 2 + Math.max(0.35, pinDiameter * 0.18)) {
-    throw new Error("knuckledHingeAssembly: barrelOuterRadius leaves too little wall around the pin bore");
-  }
-  const knuckleLength = (length4 - knuckleGap * (knuckleCount - 1)) / knuckleCount;
-  if (knuckleLength <= pinDiameter * 1.4) {
-    throw new Error("knuckledHingeAssembly: length, knuckleCount, and knuckleGap make knuckles too short");
-  }
-  const leafRootClearance = Math.max(0.12, Math.min(knuckleGap * 0.35, 0.35));
-  const barrelLeafOverlap = Math.min(barrelOuterRadius * 0.18, leafThickness * 0.35);
-  const bridgeDepth = leafRootClearance + barrelLeafOverlap + 0.2;
-  const fixedLeafPlate = box(length4, leafLength, leafThickness).translate(
-    0,
-    barrelOuterRadius + leafRootClearance + leafLength / 2,
-    -leafThickness / 2
-  );
-  const movingLeafPlate = box(length4, leafLength, leafThickness).translate(
-    0,
-    -barrelOuterRadius - leafRootClearance - leafLength / 2,
-    -leafThickness / 2
-  );
-  const fixedKnuckles = [];
-  const movingKnuckles = [];
-  const fixedBridges = [];
-  const movingBridges = [];
-  for (let index2 = 0; index2 < knuckleCount; index2 += 1) {
-    const xStart = -length4 / 2 + index2 * (knuckleLength + knuckleGap);
-    const xCenter = xStart + knuckleLength / 2;
-    const knuckle = tubeAlongX(knuckleLength, barrelOuterRadius, boreDiameter / 2, xCenter, segments);
-    if (index2 % 2 === 0) {
-      fixedKnuckles.push(knuckle);
-      fixedBridges.push(
-        box(knuckleLength, bridgeDepth, leafThickness).translate(
-          xCenter,
-          barrelOuterRadius - barrelLeafOverlap + bridgeDepth / 2,
-          -leafThickness / 2
-        )
-      );
-    } else {
-      movingKnuckles.push(knuckle);
-      movingBridges.push(
-        box(knuckleLength, bridgeDepth, leafThickness).translate(
-          xCenter,
-          -barrelOuterRadius + barrelLeafOverlap - bridgeDepth / 2,
-          -leafThickness / 2
-        )
-      );
-    }
-  }
-  const fixedLeaf = union(fixedLeafPlate, ...fixedKnuckles, ...fixedBridges).color("#475569");
-  const movingLeaf = union(movingLeafPlate, ...movingKnuckles, ...movingBridges).rotateX(openAngleDeg).color("#111827");
-  const pinCore = cylinderAlongX(length4 + retainerThickness * 2, pinDiameter / 2, 0, segments);
-  const retainerRadius = Math.max(barrelOuterRadius * 0.85, pinDiameter);
-  const leftHead = cylinderAlongX(retainerThickness, retainerRadius, -length4 / 2 - retainerThickness / 2, segments);
-  const rightHead = cylinderAlongX(retainerThickness, retainerRadius, length4 / 2 + retainerThickness / 2, segments);
-  const pin = union(pinCore, leftHead, rightHead).color("#cbd5e1");
-  const pinBore = cylinderAlongX(length4 + retainerThickness * 2, boreDiameter / 2, 0, segments);
-  const parts = [
-    { name: "fixed hinge leaf with alternating knuckles", shape: fixedLeaf },
-    { name: "moving hinge leaf with alternating knuckles", shape: movingLeaf },
-    { name: "retained hinge pin through knuckle stack", shape: pin }
-  ];
-  return {
-    parts,
-    fixedLeaf,
-    movingLeaf,
-    pin,
-    cutters: {
-      pinBore
-    },
-    dims: {
-      length: length4,
-      leafLength,
-      leafThickness,
-      barrelOuterRadius,
-      pinDiameter,
-      boreDiameter,
-      knuckleGap,
-      knuckleCount,
-      knuckleLength,
-      openAngleDeg,
-      retainerThickness
-    }
-  };
-}
-function clevisPinJointAssembly(options = {}) {
-  const pinDiameter = requirePositive$6(options.pinDiameter ?? 4, "pinDiameter");
-  const pinClearance = requireNonNegative(options.pinClearance ?? 0.3, "pinClearance");
-  const boreDiameter = pinDiameter + pinClearance;
-  const linkThickness = requirePositive$6(options.linkThickness ?? Math.max(5, pinDiameter * 1.5), "linkThickness");
-  const earThickness = requirePositive$6(options.earThickness ?? Math.max(3.5, pinDiameter), "earThickness");
-  const runningClearance = requireNonNegative(options.runningClearance ?? 0.25, "runningClearance");
-  const linkArmWidth = requirePositive$6(options.linkArmWidth ?? pinDiameter * 2.4, "linkArmWidth");
-  const eyeOuterRadius = requirePositive$6(options.eyeOuterRadius ?? Math.max(pinDiameter * 1.8, linkArmWidth / 2 + 1.4), "eyeOuterRadius");
-  const earLength = requirePositive$6(options.earLength ?? Math.max(eyeOuterRadius * 2.55, pinDiameter * 4.2), "earLength");
-  const earHeight = requirePositive$6(options.earHeight ?? Math.max(eyeOuterRadius * 2.25, pinDiameter * 4.4), "earHeight");
-  const linkArmLength = requirePositive$6(options.linkArmLength ?? 34, "linkArmLength");
-  const retainerThickness = requirePositive$6(options.retainerThickness ?? Math.max(1.2, pinDiameter * 0.35), "retainerThickness");
-  const segments = options.segments ?? 40;
-  if (eyeOuterRadius <= boreDiameter / 2 + Math.max(0.8, pinDiameter * 0.25)) {
-    throw new Error("clevisPinJointAssembly: eyeOuterRadius leaves too little material around the pin bore");
-  }
-  if (earHeight <= boreDiameter + Math.max(3, pinDiameter)) {
-    throw new Error("clevisPinJointAssembly: earHeight leaves too little material around the pin bore");
-  }
-  if (earLength / 2 <= eyeOuterRadius + runningClearance) {
-    throw new Error("clevisPinJointAssembly: earLength must extend behind the link eye for a rear clevis bridge");
-  }
-  const clevisGap = linkThickness + runningClearance * 2;
-  const earCenterY = clevisGap / 2 + earThickness / 2;
-  const totalStackY = clevisGap + earThickness * 2;
-  const pinLength = totalStackY + retainerThickness * 2 + runningClearance * 2;
-  const bridgeClearX = -eyeOuterRadius - runningClearance;
-  const bridgeLength = Math.max(pinDiameter * 2.2, 4);
-  const bridgeHeight = Math.min(earHeight * 0.48, Math.max(pinDiameter * 1.4, eyeOuterRadius * 0.75));
-  const bridgeCenterX = bridgeClearX - bridgeLength / 2;
-  const bridgeCenterZ = -earHeight / 2 + bridgeHeight / 2;
-  const pinBore = cylinderAlongY(totalStackY + 0.8, boreDiameter / 2, 0, segments);
-  const clevisBlank = union(
-    box(earLength, earThickness, earHeight).translate(0, earCenterY, -earHeight / 2),
-    box(earLength, earThickness, earHeight).translate(0, -earCenterY, -earHeight / 2),
-    box(bridgeLength, totalStackY, bridgeHeight).translate(bridgeCenterX, 0, bridgeCenterZ)
-  );
-  const clevis = clevisBlank.subtract(pinBore).color("#475569");
-  const eye = tubeAlongY(linkThickness, eyeOuterRadius, boreDiameter / 2, 0, segments);
-  const armOverlap = Math.min(eyeOuterRadius * 0.65, linkArmLength * 0.25);
-  const armCenterX = eyeOuterRadius - armOverlap + linkArmLength / 2;
-  const linkArm = box(linkArmLength, linkThickness, linkArmWidth).translate(armCenterX, 0, -linkArmWidth / 2);
-  const link = union(eye, linkArm).color("#111827");
-  const pinCore = cylinderAlongY(pinLength, pinDiameter / 2, 0, segments);
-  const headRadius = Math.max(pinDiameter * 0.9, boreDiameter / 2 + 0.8);
-  const headY = totalStackY / 2 + runningClearance + retainerThickness / 2;
-  const headA = cylinderAlongY(retainerThickness, headRadius, headY, segments);
-  const headB = cylinderAlongY(retainerThickness, headRadius, -headY, segments);
-  const pin = union(pinCore, headA, headB).color("#cbd5e1");
-  const cutter = cylinderAlongY(pinLength + 1, boreDiameter / 2, 0, segments);
-  const parts = [
-    { name: "bored clevis yoke with rear bridge", shape: clevis },
-    { name: "center link eye captured in clevis", shape: link },
-    { name: "retained clevis pin through link eye", shape: pin }
-  ];
-  return {
-    parts,
-    clevis,
-    link,
-    pin,
-    cutters: {
-      pinBore: cutter
-    },
-    dims: {
-      pinDiameter,
-      boreDiameter,
-      linkThickness,
-      earThickness,
-      runningClearance,
-      earLength,
-      earHeight,
-      linkArmLength,
-      linkArmWidth,
-      eyeOuterRadius,
-      retainerThickness,
-      pinLength,
-      clevisGap
-    }
-  };
-}
-function seatedBearingAssembly(options) {
-  const bearingOuterDiameter = requirePositive$6(options.bearingOuterDiameter, "bearingOuterDiameter");
-  const bearingInnerDiameter = requirePositive$6(options.bearingInnerDiameter, "bearingInnerDiameter");
-  const bearingWidth = requirePositive$6(options.bearingWidth, "bearingWidth");
-  const shaftDiameter = requirePositive$6(options.shaftDiameter ?? Math.max(1, bearingInnerDiameter - 0.4), "shaftDiameter");
-  const pocketClearance = requireNonNegative(options.pocketClearance ?? 0.2, "pocketClearance");
-  const shaftClearance = requireNonNegative(options.shaftClearance ?? 0.35, "shaftClearance");
-  const runningClearance = requireNonNegative(options.runningClearance ?? 0.05, "runningClearance");
-  const housingThickness = requirePositive$6(options.housingThickness ?? bearingWidth + 5, "housingThickness");
-  const bossHeight = requirePositive$6(options.bossHeight ?? Math.max(2, bearingWidth * 0.45), "bossHeight");
-  const bossOuterDiameter = requirePositive$6(
-    options.bossOuterDiameter ?? bearingOuterDiameter + Math.max(8, bearingOuterDiameter * 0.36),
-    "bossOuterDiameter"
-  );
-  const housingWidth = requirePositive$6(
-    options.housingWidth ?? Math.max(bossOuterDiameter + 12, bearingOuterDiameter * 2.1),
-    "housingWidth"
-  );
-  const housingDepth = requirePositive$6(
-    options.housingDepth ?? Math.max(bossOuterDiameter + 12, bearingOuterDiameter * 1.8),
-    "housingDepth"
-  );
-  const shaftOverhang = requirePositive$6(options.shaftOverhang ?? Math.max(8, bearingOuterDiameter * 0.45), "shaftOverhang");
-  const shoulderDiameter = requirePositive$6(
-    options.shoulderDiameter ?? Math.max(shaftDiameter * 1.65, bearingInnerDiameter + 2),
-    "shoulderDiameter"
-  );
-  const shoulderThickness = requirePositive$6(options.shoulderThickness ?? Math.max(1.5, shaftDiameter * 0.32), "shoulderThickness");
-  const segments = options.segments ?? 48;
-  if (bearingOuterDiameter <= bearingInnerDiameter + Math.max(1, bearingOuterDiameter * 0.08)) {
-    throw new Error("seatedBearingAssembly: bearingOuterDiameter leaves too little bearing wall around the bore");
-  }
-  if (shaftDiameter + shaftClearance >= bearingInnerDiameter) {
-    throw new Error("seatedBearingAssembly: shaftDiameter plus shaftClearance must fit inside the bearing bore");
-  }
-  if (shoulderDiameter >= bearingOuterDiameter - runningClearance * 2) {
-    throw new Error("seatedBearingAssembly: shoulderDiameter must stay smaller than the bearing outer race");
-  }
-  const pocketDiameter = bearingOuterDiameter + pocketClearance;
-  const shaftBoreDiameter = shaftDiameter + shaftClearance;
-  const totalHousingHeight = housingThickness + bossHeight;
-  const pocketDepth = bearingWidth + runningClearance * 2;
-  if (pocketDepth >= totalHousingHeight - runningClearance) {
-    throw new Error("seatedBearingAssembly: housingThickness and bossHeight must leave a shoulder below the bearing pocket");
-  }
-  if (bossOuterDiameter <= pocketDiameter + Math.max(2, bearingOuterDiameter * 0.12)) {
-    throw new Error("seatedBearingAssembly: bossOuterDiameter leaves too little wall around the bearing pocket");
-  }
-  if (housingWidth <= pocketDiameter + 6 || housingDepth <= pocketDiameter + 6) {
-    throw new Error("seatedBearingAssembly: housing dimensions leave too little material around the bearing pocket");
-  }
-  if (shoulderThickness * 2 + runningClearance * 2 >= shaftOverhang) {
-    throw new Error("seatedBearingAssembly: shaftOverhang must leave room for retaining collars outside the housing");
-  }
-  const pocketBottomZ = totalHousingHeight - pocketDepth;
-  const bearingZ = pocketBottomZ + runningClearance;
-  const lowerShoulderZ = -runningClearance - shoulderThickness;
-  const upperShoulderZ = totalHousingHeight + runningClearance;
-  const shaftLength = totalHousingHeight + shaftOverhang * 2;
-  const bossFuseOverlap = Math.min(0.08, Math.max(0.02, bossHeight * 0.03));
-  const bearingPocket = cylinder(pocketDepth + 0.4, pocketDiameter / 2, void 0, segments).translate(0, 0, pocketBottomZ - 0.2);
-  const shaftBore = cylinder(totalHousingHeight + 1, shaftBoreDiameter / 2, void 0, segments).translate(0, 0, -0.5);
-  const housingBase = box(housingWidth, housingDepth, housingThickness).subtract(bearingPocket).subtract(shaftBore);
-  const housingBoss = cylinder(bossHeight + bossFuseOverlap, bossOuterDiameter / 2, void 0, segments).translate(0, 0, housingThickness - bossFuseOverlap).subtract(bearingPocket);
-  const housing = union(housingBase, housingBoss).color("#475569");
-  const bearingRing = tubeAlongZ(bearingWidth, bearingOuterDiameter / 2, bearingInnerDiameter / 2, segments);
-  const shieldInset = Math.min(bearingWidth * 0.18, 0.7);
-  const shieldOuterRadius = bearingOuterDiameter / 2 - Math.max(0.45, (bearingOuterDiameter - bearingInnerDiameter) * 0.08);
-  const shieldInnerRadius = bearingInnerDiameter / 2 + Math.max(0.2, (bearingOuterDiameter - bearingInnerDiameter) * 0.035);
-  const bearingShield = shieldOuterRadius > shieldInnerRadius + 0.2 ? union(
-    tubeAlongZ(Math.min(0.35, bearingWidth * 0.08), shieldOuterRadius, shieldInnerRadius, segments).translate(0, 0, shieldInset),
-    tubeAlongZ(Math.min(0.35, bearingWidth * 0.08), shieldOuterRadius, shieldInnerRadius, segments).translate(
-      0,
-      0,
-      bearingWidth - shieldInset - Math.min(0.35, bearingWidth * 0.08)
-    )
-  ) : null;
-  const bearing = (bearingShield ? union(bearingRing, bearingShield) : bearingRing).translate(0, 0, bearingZ).color("#111827");
-  const shaftCore = cylinder(shaftLength, shaftDiameter / 2, void 0, segments).translate(0, 0, -shaftOverhang);
-  const lowerShoulder = cylinder(shoulderThickness, shoulderDiameter / 2, void 0, segments).translate(0, 0, lowerShoulderZ);
-  const upperShoulder = cylinder(shoulderThickness, shoulderDiameter / 2, void 0, segments).translate(0, 0, upperShoulderZ);
-  const shaft = union(shaftCore, lowerShoulder, upperShoulder).color("#cbd5e1");
-  const parts = [
-    { name: "bearing housing with counterbore pocket and shoulder", shape: housing },
-    { name: "purchased radial bearing seated in counterbore", shape: bearing },
-    { name: "shaft through bearing bore with retaining collars", shape: shaft }
-  ];
-  return {
-    parts,
-    housing,
-    bearing,
-    shaft,
-    cutters: {
-      bearingPocket,
-      shaftBore
-    },
-    dims: {
-      bearingOuterDiameter,
-      bearingInnerDiameter,
-      bearingWidth,
-      shaftDiameter,
-      housingWidth,
-      housingDepth,
-      housingThickness,
-      bossOuterDiameter,
-      bossHeight,
-      totalHousingHeight,
-      pocketDiameter,
-      pocketDepth,
-      shaftBoreDiameter,
-      runningClearance,
-      shaftLength,
-      shoulderDiameter,
-      shoulderThickness
-    }
-  };
-}
-function cableGlandAnchorAssembly(options) {
-  const cableDiameter = requirePositive$6(options.cableDiameter, "cableDiameter");
-  const panelThickness = requirePositive$6(options.panelThickness ?? 3, "panelThickness");
-  const panelWidth = requirePositive$6(options.panelWidth ?? Math.max(54, cableDiameter * 7), "panelWidth");
-  const panelHeight = requirePositive$6(options.panelHeight ?? Math.max(38, cableDiameter * 5), "panelHeight");
-  const runningClearance = requirePositive$6(options.runningClearance ?? 0.35, "runningClearance");
-  const panelHoleClearance = requirePositive$6(options.panelHoleClearance ?? 0.25, "panelHoleClearance");
-  const cableBoreDiameter = cableDiameter + runningClearance * 2;
-  const glandOuterDiameter = requirePositive$6(
-    options.glandOuterDiameter ?? cableDiameter + Math.max(6, cableDiameter * 0.9),
-    "glandOuterDiameter"
-  );
-  const nutOuterDiameter = requirePositive$6(
-    options.nutOuterDiameter ?? glandOuterDiameter + Math.max(6, cableDiameter * 0.8),
-    "nutOuterDiameter"
-  );
-  const nutThickness = requirePositive$6(options.nutThickness ?? Math.max(4, cableDiameter * 0.8), "nutThickness");
-  const flangeDiameter = requirePositive$6(options.flangeDiameter ?? glandOuterDiameter + Math.max(5, cableDiameter * 0.7), "flangeDiameter");
-  const flangeThickness = requirePositive$6(options.flangeThickness ?? Math.max(2, panelThickness * 0.45), "flangeThickness");
-  const minGlandLength = panelThickness + nutThickness + flangeThickness + runningClearance * 4;
-  const glandLength = requirePositive$6(options.glandLength ?? minGlandLength + Math.max(8, cableDiameter), "glandLength");
-  const cableLength = requirePositive$6(options.cableLength ?? glandLength + Math.max(36, cableDiameter * 5), "cableLength");
-  const segments = options.segments ?? 40;
-  if (glandOuterDiameter <= cableBoreDiameter + Math.max(1.2, cableDiameter * 0.18)) {
-    throw new Error("cableGlandAnchorAssembly: glandOuterDiameter leaves too little wall around the cable bore");
-  }
-  if (nutOuterDiameter <= glandOuterDiameter + Math.max(1.5, cableDiameter * 0.2)) {
-    throw new Error("cableGlandAnchorAssembly: nutOuterDiameter must leave material around the gland body");
-  }
-  if (flangeDiameter <= glandOuterDiameter + Math.max(1.2, cableDiameter * 0.16)) {
-    throw new Error("cableGlandAnchorAssembly: flangeDiameter must be larger than the gland body");
-  }
-  if (panelWidth <= flangeDiameter + 8 || panelHeight <= flangeDiameter + 8) {
-    throw new Error("cableGlandAnchorAssembly: panel dimensions leave too little material around the gland hole");
-  }
-  if (glandLength <= minGlandLength) {
-    throw new Error("cableGlandAnchorAssembly: glandLength must span the panel, flange, compression nut, and clearances");
-  }
-  if (cableLength <= glandLength + runningClearance * 2) {
-    throw new Error("cableGlandAnchorAssembly: cableLength must extend beyond the gland body");
-  }
-  const panelHoleDiameter = glandOuterDiameter + panelHoleClearance * 2;
-  const glandOuterRadius = glandOuterDiameter / 2;
-  const cableBoreRadius = cableBoreDiameter / 2;
-  const faceClearance = Math.min(0.05, runningClearance * 0.15);
-  const flangePocketDepth = Math.min(Math.max(0.35, panelThickness * 0.18), panelThickness * 0.4, flangeThickness * 0.55);
-  const panelHole = cylinderAlongX(panelThickness + 0.8, panelHoleDiameter / 2, 0, segments);
-  const flangeSeatPocket = cylinderAlongX(
-    flangePocketDepth + 0.2,
-    flangeDiameter / 2 + panelHoleClearance,
-    panelThickness / 2 - flangePocketDepth / 2,
-    segments
-  );
-  const cableBore = cylinderAlongX(glandLength + 0.8, cableBoreRadius, 0, segments);
-  const panel = box(panelThickness, panelWidth, panelHeight).translate(0, 0, -panelHeight / 2).subtract(panelHole).subtract(flangeSeatPocket).color("#475569");
-  const glandBody = tubeAlongX(glandLength, glandOuterRadius, cableBoreRadius, 0, segments);
-  const flangeCenterX = panelThickness / 2 - flangePocketDepth + faceClearance + flangeThickness / 2;
-  const flange = tubeAlongX(flangeThickness, flangeDiameter / 2, cableBoreRadius, flangeCenterX, segments);
-  const gland = union(glandBody, flange).color("#94a3b8");
-  const nutInnerRadius = glandOuterRadius + Math.min(0.12, runningClearance * 0.4);
-  const nutCenterX = -panelThickness / 2 - faceClearance - nutThickness / 2;
-  const compressionNut = tubeAlongX(nutThickness, nutOuterDiameter / 2, nutInnerRadius, nutCenterX, segments).color("#cbd5e1");
-  const cable = cylinderAlongX(cableLength, cableDiameter / 2, 0, segments).color("#111827");
-  const parts = [
-    { name: "panel with gland clearance hole", shape: panel },
-    { name: "hollow cable gland body with panel flange", shape: gland },
-    { name: "compression nut around gland body", shape: compressionNut },
-    { name: "routed cable through gland bore", shape: cable }
-  ];
-  return {
-    parts,
-    panel,
-    gland,
-    compressionNut,
-    cable,
-    cutters: {
-      panelHole,
-      flangeSeatPocket,
-      cableBore
-    },
-    dims: {
-      cableDiameter,
-      cableBoreDiameter,
-      panelThickness,
-      panelWidth,
-      panelHeight,
-      glandOuterDiameter,
-      glandLength,
-      nutOuterDiameter,
-      nutThickness,
-      flangeDiameter,
-      flangeThickness,
-      runningClearance,
-      faceClearance,
-      flangePocketDepth,
-      panelHoleDiameter,
-      cableLength
-    }
-  };
-}
-function hoseBarbPortAssembly(options) {
-  const hoseInnerDiameter = requirePositive$6(options.hoseInnerDiameter, "hoseInnerDiameter");
-  const runningClearance = requirePositive$6(options.runningClearance ?? 0.18, "runningClearance");
-  const faceClearance = requirePositive$6(options.faceClearance ?? 0.04, "faceClearance");
-  const barbRootDiameter = requirePositive$6(
-    options.barbRootDiameter ?? Math.max(1, hoseInnerDiameter - Math.max(0.25, hoseInnerDiameter * 0.06)),
-    "barbRootDiameter"
-  );
-  const barbPeakDiameter = requirePositive$6(
-    options.barbPeakDiameter ?? hoseInnerDiameter + Math.max(0.65, hoseInnerDiameter * 0.12),
-    "barbPeakDiameter"
-  );
-  const installedHoseBoreDiameter = barbPeakDiameter + runningClearance * 2;
-  const hoseOuterDiameter = requirePositive$6(
-    options.hoseOuterDiameter ?? Math.max(installedHoseBoreDiameter + 2.4, hoseInnerDiameter + Math.max(3, hoseInnerDiameter * 0.55)),
-    "hoseOuterDiameter"
-  );
-  const fluidBoreDiameter = requirePositive$6(options.fluidBoreDiameter ?? hoseInnerDiameter * 0.65, "fluidBoreDiameter");
-  const blockThickness = requirePositive$6(options.blockThickness ?? Math.max(7, hoseInnerDiameter * 1.2), "blockThickness");
-  const barbCount = options.barbCount ?? 3;
-  const barbLength = requirePositive$6(options.barbLength ?? Math.max(2.6, hoseInnerDiameter * 0.55), "barbLength");
-  const barbStackLength = barbCount * barbLength;
-  const shoulderDiameter = requirePositive$6(
-    options.shoulderDiameter ?? barbPeakDiameter + Math.max(4, hoseInnerDiameter * 0.65),
-    "shoulderDiameter"
-  );
-  const shoulderThickness = requirePositive$6(options.shoulderThickness ?? Math.max(2, hoseInnerDiameter * 0.35), "shoulderThickness");
-  const bossDiameter = requirePositive$6(options.bossDiameter ?? shoulderDiameter + Math.max(4, hoseInnerDiameter * 0.6), "bossDiameter");
-  const bossHeight = requirePositive$6(options.bossHeight ?? Math.max(2.4, hoseInnerDiameter * 0.45), "bossHeight");
-  const blockWidth = requirePositive$6(options.blockWidth ?? bossDiameter + Math.max(14, hoseInnerDiameter * 2.4), "blockWidth");
-  const blockHeight = requirePositive$6(options.blockHeight ?? bossDiameter + Math.max(12, hoseInnerDiameter * 2.1), "blockHeight");
-  const hoseLength = requirePositive$6(options.hoseLength ?? barbStackLength + Math.max(32, hoseInnerDiameter * 5), "hoseLength");
-  const clampWidth = requirePositive$6(options.clampWidth ?? Math.max(4, hoseOuterDiameter * 0.45), "clampWidth");
-  const clampThickness = requirePositive$6(options.clampThickness ?? 0.9, "clampThickness");
-  const segments = options.segments ?? 40;
-  if (!Number.isInteger(barbCount) || barbCount < 1 || barbCount > 8) {
-    throw new Error("hoseBarbPortAssembly: barbCount must be an integer from 1 to 8");
-  }
-  if (barbPeakDiameter <= hoseInnerDiameter) {
-    throw new Error("hoseBarbPortAssembly: barbPeakDiameter must exceed hoseInnerDiameter so the barb retains the hose");
-  }
-  if (barbRootDiameter >= barbPeakDiameter - Math.max(0.25, hoseInnerDiameter * 0.04)) {
-    throw new Error("hoseBarbPortAssembly: barbRootDiameter must leave a visible barb rise");
-  }
-  if (fluidBoreDiameter >= barbRootDiameter - Math.max(0.8, hoseInnerDiameter * 0.12)) {
-    throw new Error("hoseBarbPortAssembly: fluidBoreDiameter leaves too little wall in the barb fitting");
-  }
-  if (hoseOuterDiameter <= installedHoseBoreDiameter + Math.max(1.2, hoseInnerDiameter * 0.16)) {
-    throw new Error("hoseBarbPortAssembly: hoseOuterDiameter leaves too little hose wall around the installed barb envelope");
-  }
-  if (shoulderDiameter <= barbPeakDiameter + Math.max(1.5, hoseInnerDiameter * 0.2)) {
-    throw new Error("hoseBarbPortAssembly: shoulderDiameter must be larger than the barb peaks");
-  }
-  if (bossDiameter <= shoulderDiameter + Math.max(1.5, hoseInnerDiameter * 0.2)) {
-    throw new Error("hoseBarbPortAssembly: bossDiameter must leave material around the shoulder seat");
-  }
-  if (blockWidth <= bossDiameter + 8 || blockHeight <= bossDiameter + 8) {
-    throw new Error("hoseBarbPortAssembly: receiver block dimensions leave too little material around the port boss");
-  }
-  const portBoreDiameter = barbRootDiameter + runningClearance * 2;
-  const portBore = cylinderAlongX(blockThickness + bossHeight + 0.8, portBoreDiameter / 2, bossHeight / 2, segments);
-  const fuseOverlap = Math.min(0.04, faceClearance * 0.7);
-  const bossCenterX = blockThickness / 2 + bossHeight / 2 - fuseOverlap;
-  const receiver = union(
-    box(blockThickness, blockWidth, blockHeight).translate(0, 0, -blockHeight / 2),
-    cylinderAlongX(bossHeight + fuseOverlap, bossDiameter / 2, bossCenterX, segments)
-  ).subtract(portBore).color("#475569");
-  const bossFaceX = blockThickness / 2 + bossHeight;
-  const shoulderCenterX = bossFaceX + faceClearance + shoulderThickness / 2;
-  const barbStartX = shoulderCenterX + shoulderThickness / 2;
-  const fittingStartX = -blockThickness / 2 - runningClearance;
-  const fittingEndX = barbStartX + barbStackLength;
-  const fittingCore = tubeAlongX(
-    fittingEndX - fittingStartX,
-    barbRootDiameter / 2,
-    fluidBoreDiameter / 2,
-    (fittingStartX + fittingEndX) / 2,
-    segments
-  );
-  const shoulder = tubeAlongX(shoulderThickness, shoulderDiameter / 2, fluidBoreDiameter / 2, shoulderCenterX, segments);
-  const barbSolids = [];
-  const ridgeLength = Math.max(0.8, Math.min(barbLength * 0.45, hoseInnerDiameter * 0.28));
-  for (let index2 = 0; index2 < barbCount; index2 += 1) {
-    const startX = barbStartX + index2 * barbLength;
-    const ridgeCenterX = startX + barbLength - ridgeLength / 2;
-    barbSolids.push(tubeAlongX(ridgeLength, barbPeakDiameter / 2, fluidBoreDiameter / 2, ridgeCenterX, segments));
-  }
-  const fitting = union(fittingCore, shoulder, ...barbSolids).color("#94a3b8");
-  const hoseStartX = barbStartX + faceClearance;
-  const hoseCenterX = hoseStartX + hoseLength / 2;
-  const installedHoseBore = cylinderAlongX(hoseLength + 0.8, installedHoseBoreDiameter / 2, hoseCenterX, segments);
-  const hose = tubeAlongX(hoseLength, hoseOuterDiameter / 2, installedHoseBoreDiameter / 2, hoseCenterX, segments).color("#111827");
-  const clampCenterX = barbStartX + Math.min(barbStackLength * 0.55, Math.max(barbLength, clampWidth));
-  const clamp2 = tubeAlongX(
-    clampWidth,
-    hoseOuterDiameter / 2 + clampThickness,
-    hoseOuterDiameter / 2 + Math.min(0.08, runningClearance * 0.45),
-    clampCenterX,
-    segments
-  ).color("#cbd5e1");
-  const parts = [
-    { name: "bored pump or filter body with raised hose-port boss", shape: receiver },
-    { name: "hollow hose barb fitting with shoulder and retention ridges", shape: fitting },
-    { name: "installed flexible hose over barb tail", shape: hose },
-    { name: "clamp band over hose and barb ridges", shape: clamp2 }
-  ];
-  return {
-    parts,
-    receiver,
-    fitting,
-    hose,
-    clamp: clamp2,
-    cutters: {
-      portBore,
-      installedHoseBore
-    },
-    dims: {
-      hoseInnerDiameter,
-      hoseOuterDiameter,
-      installedHoseBoreDiameter,
-      blockThickness,
-      blockWidth,
-      blockHeight,
-      bossDiameter,
-      bossHeight,
-      fluidBoreDiameter,
-      barbRootDiameter,
-      barbPeakDiameter,
-      barbCount,
-      barbLength,
-      barbStackLength,
-      shoulderDiameter,
-      shoulderThickness,
-      hoseLength,
-      clampWidth,
-      clampThickness,
-      runningClearance,
-      faceClearance
-    }
-  };
-}
-function routedTubeClipAssembly(options) {
-  const tubeDiameter = requirePositive$6(options.tubeDiameter, "tubeDiameter");
-  const tubeLength = requirePositive$6(options.tubeLength ?? 120, "tubeLength");
-  const panelThickness = requirePositive$6(options.panelThickness ?? 3, "panelThickness");
-  const runningClearance = requirePositive$6(options.runningClearance ?? 0.35, "runningClearance");
-  const screwSize = options.screwSize ?? "M3";
-  const segments = options.segments ?? 32;
-  const sizeData = METRIC_HOLE_TABLE[screwSize];
-  if (!sizeData) throw new Error(`routedTubeClipAssembly: unsupported screwSize "${screwSize}"`);
-  const clipCount = options.clipCount ?? 3;
-  if (!Number.isInteger(clipCount) || clipCount < 1 || clipCount > 8) {
-    throw new Error("routedTubeClipAssembly: clipCount must be an integer from 1 to 8");
-  }
-  const screwDiameter = parseFloat(screwSize.replace("M", ""));
-  const screwHeadDiameter = sizeData.head;
-  const tubeBoreDiameter = tubeDiameter + runningClearance * 2;
-  const clipWallThickness = requirePositive$6(
-    options.clipWallThickness ?? Math.max(screwHeadDiameter + 1.2, tubeDiameter * 0.45, 5),
-    "clipWallThickness"
-  );
-  const clipWidth = requirePositive$6(options.clipWidth ?? Math.max(screwHeadDiameter + 3, tubeDiameter * 1.4, 10), "clipWidth");
-  const clipDepth = tubeBoreDiameter + clipWallThickness * 2;
-  const bottomWall = Math.max(1.2, clipWallThickness * 0.35);
-  const topWall = Math.max(2, clipWallThickness * 0.45);
-  const clipHeight = bottomWall + tubeBoreDiameter + topWall;
-  const tubeCenterZ = panelThickness + bottomWall + tubeBoreDiameter / 2;
-  const panelLength = requirePositive$6(options.panelLength ?? tubeLength + 24, "panelLength");
-  const panelWidth = requirePositive$6(options.panelWidth ?? clipDepth + Math.max(14, screwHeadDiameter * 2), "panelWidth");
-  if (tubeLength <= clipWidth + 8) {
-    throw new Error("routedTubeClipAssembly: tubeLength must leave visible tube beyond the clip body");
-  }
-  const defaultSpacing = clipCount === 1 ? 0 : Math.max(clipWidth + 8, (tubeLength - clipWidth * 2) / (clipCount - 1));
-  const clipSpacing = options.clipSpacing === void 0 ? defaultSpacing : requirePositive$6(options.clipSpacing, "clipSpacing");
-  const clipCenters = Array.from({ length: clipCount }, (_2, index2) => (index2 - (clipCount - 1) / 2) * clipSpacing);
-  const maxClipExtent = Math.max(...clipCenters.map((x2) => Math.abs(x2) + clipWidth / 2));
-  if (maxClipExtent > tubeLength / 2 - 2) {
-    throw new Error("routedTubeClipAssembly: clipSpacing places a clip beyond the routed tube length");
-  }
-  if (maxClipExtent > panelLength / 2 - 2) {
-    throw new Error("routedTubeClipAssembly: panelLength is too short for the clip pattern");
-  }
-  const boreRadius = tubeBoreDiameter / 2;
-  const screwY = boreRadius + clipWallThickness / 2;
-  if (screwY + screwHeadDiameter / 2 > clipDepth / 2 - 0.2) {
-    throw new Error("routedTubeClipAssembly: clipWallThickness leaves too little land for screw heads");
-  }
-  if (clipDepth > panelWidth - Math.max(4, screwHeadDiameter * 0.5)) {
-    throw new Error("routedTubeClipAssembly: panelWidth leaves too little material beside the clips");
-  }
-  const screwPositions = clipCenters.flatMap((x2) => [[x2, -screwY], [x2, screwY]]);
-  const screwClearanceDiameter = Math.max(sizeData.loose, screwDiameter + 0.8);
-  const panelThreadEnvelopeDiameter = screwClearanceDiameter;
-  const clipTopZ = panelThickness + clipHeight;
-  const clipTubeBores = union(
-    ...clipCenters.map((x2) => cylinderAlongX(clipWidth + 0.8, boreRadius, x2, segments).translate(0, 0, tubeCenterZ))
-  );
-  const clipScrewClearances = union(
-    ...screwPositions.map(
-      ([x2, y2]) => cylinder(clipHeight + 0.8, screwClearanceDiameter / 2, void 0, segments).translate(x2, y2, panelThickness - 0.4)
-    )
-  );
-  const panelThreadEnvelopes = union(
-    ...screwPositions.map(
-      ([x2, y2]) => cylinder(panelThickness + 0.8, panelThreadEnvelopeDiameter / 2, void 0, segments).translate(x2, y2, -0.4)
-    )
-  );
-  const panel = box(panelLength, panelWidth, panelThickness).subtract(panelThreadEnvelopes).color("#475569");
-  const tube2 = cylinderAlongX(tubeLength, tubeDiameter / 2, 0, segments).translate(0, 0, tubeCenterZ).color("#0f172a");
-  const clips = clipCenters.map((x2) => {
-    const body = box(clipWidth, clipDepth, clipHeight).translate(x2, 0, panelThickness);
-    const tubeBore = cylinderAlongX(clipWidth + 0.8, boreRadius, x2, segments).translate(0, 0, tubeCenterZ);
-    const screwHoles = union(
-      cylinder(clipHeight + 0.8, screwClearanceDiameter / 2, void 0, segments).translate(x2, -screwY, panelThickness - 0.4),
-      cylinder(clipHeight + 0.8, screwClearanceDiameter / 2, void 0, segments).translate(x2, screwY, panelThickness - 0.4)
-    );
-    return body.subtract(tubeBore).subtract(screwHoles).color("#94a3b8");
-  });
-  const screwLength = clipHeight + panelThickness * 0.65;
-  const screwHeadHeight = Math.max(1.2, screwDiameter * 0.55);
-  const screwBlank = union(
-    cylinder(screwLength, screwDiameter / 2, void 0, segments).translate(0, 0, clipTopZ - screwLength),
-    cylinder(screwHeadHeight, screwHeadDiameter / 2, void 0, segments).translate(0, 0, clipTopZ)
-  ).color("#cbd5e1");
-  const screws = screwPositions.map(([x2, y2]) => screwBlank.translate(x2, y2, 0));
-  const parts = [
-    { name: "panel with tube-clip screw receiving holes", shape: panel },
-    { name: "routed flexible tube through retained clip bores", shape: tube2 },
-    ...clips.map((shape, index2) => ({ name: `saddle tube clip ${index2 + 1} with through-bore`, shape })),
-    ...screws.map((shape, index2) => ({ name: `installed ${screwSize} tube clip screw ${index2 + 1}`, shape }))
-  ];
-  return {
-    parts,
-    panel,
-    tube: tube2,
-    clips,
-    screws,
-    clipCenters,
-    screwPositions,
-    cutters: {
-      clipTubeBores,
-      clipScrewClearances,
-      panelThreadEnvelopes
-    },
-    dims: {
-      tubeDiameter,
-      tubeLength,
-      tubeBoreDiameter,
-      panelLength,
-      panelWidth,
-      panelThickness,
-      clipCount,
-      clipWidth,
-      clipDepth,
-      clipHeight,
-      clipWallThickness,
-      tubeCenterZ,
-      screwSize,
-      screwDiameter,
-      screwHeadDiameter,
-      screwLength,
-      screwClearanceDiameter,
-      panelThreadEnvelopeDiameter,
-      runningClearance
-    }
-  };
-}
-function pcbTerminalBlockAssembly(options = {}) {
-  const terminalCount = options.terminalCount ?? 4;
-  if (!Number.isInteger(terminalCount) || terminalCount < 1 || terminalCount > 24) {
-    throw new Error("pcbTerminalBlockAssembly: terminalCount must be an integer from 1 to 24");
-  }
-  const terminalPitch = requirePositive$6(options.terminalPitch ?? 5.08, "terminalPitch");
-  const terminalBlockWidth = terminalPitch * terminalCount + 3;
-  const boardWidth = requirePositive$6(options.boardWidth ?? Math.max(50, terminalBlockWidth + 28), "boardWidth");
-  const boardDepth = requirePositive$6(options.boardDepth ?? 38, "boardDepth");
-  const boardThickness = requirePositive$6(options.boardThickness ?? 1.6, "boardThickness");
-  const backplateThickness = requirePositive$6(options.backplateThickness ?? 3, "backplateThickness");
-  const backplateMargin = requirePositive$6(options.backplateMargin ?? 5, "backplateMargin");
-  const standoffHeight = requirePositive$6(options.standoffHeight ?? 6, "standoffHeight");
-  const screwSize = options.screwSize ?? "M3";
-  const segments = options.segments ?? 28;
-  const sizeData = METRIC_HOLE_TABLE[screwSize];
-  if (!sizeData) throw new Error(`pcbTerminalBlockAssembly: unsupported screwSize "${screwSize}"`);
-  const screwDiameter = parseFloat(screwSize.replace("M", ""));
-  const screwHeadDiameter = sizeData.head;
-  const screwHeadHeight = Math.max(1.2, screwDiameter * 0.55);
-  const standoffDiameter = requirePositive$6(
-    options.standoffDiameter ?? Math.max(screwHeadDiameter * 1.45, sizeData.normal + 3),
-    "standoffDiameter"
-  );
-  const [mountInsetX, mountInsetY] = resolveBoltInset(
-    options.mountingInset,
-    Math.max(standoffDiameter / 2 + 1.2, screwHeadDiameter * 0.75)
-  );
-  if (mountInsetX * 2 >= boardWidth || mountInsetY * 2 >= boardDepth) {
-    throw new Error("pcbTerminalBlockAssembly: mountingInset leaves no room for the PCB mounting pattern");
-  }
-  const terminalBlockDepth = requirePositive$6(options.terminalBlockDepth ?? 10, "terminalBlockDepth");
-  const terminalBlockHeight = requirePositive$6(options.terminalBlockHeight ?? 9, "terminalBlockHeight");
-  const terminalEdgeInset = requirePositive$6(options.terminalEdgeInset ?? 5, "terminalEdgeInset");
-  const pinDiameter = requirePositive$6(options.pinDiameter ?? 0.9, "pinDiameter");
-  const pinClearance = requirePositive$6(options.pinClearance ?? 0.25, "pinClearance");
-  const pinTailLength = requireNonNegative(options.pinTailLength ?? 0, "pinTailLength");
-  const wirePortDiameter = requirePositive$6(options.wirePortDiameter ?? 2.6, "wirePortDiameter");
-  const pinHoleDiameter = pinDiameter + pinClearance;
-  const terminalCenterY = -boardDepth / 2 + terminalEdgeInset + terminalBlockDepth / 2;
-  const pinY = terminalCenterY + terminalBlockDepth * 0.24;
-  const firstPinX = -((terminalCount - 1) * terminalPitch) / 2;
-  const pinPositions = Array.from({ length: terminalCount }, (_2, index2) => [firstPinX + index2 * terminalPitch, pinY]);
-  const mountingPositions = [
-    [-boardWidth / 2 + mountInsetX, -boardDepth / 2 + mountInsetY],
-    [boardWidth / 2 - mountInsetX, -boardDepth / 2 + mountInsetY],
-    [-boardWidth / 2 + mountInsetX, boardDepth / 2 - mountInsetY],
-    [boardWidth / 2 - mountInsetX, boardDepth / 2 - mountInsetY]
-  ];
-  if (terminalBlockWidth >= boardWidth - mountInsetX * 2) {
-    throw new Error("pcbTerminalBlockAssembly: terminal block is too wide for the PCB mounting pattern");
-  }
-  if (terminalEdgeInset + terminalBlockDepth >= boardDepth - mountInsetY * 2) {
-    throw new Error("pcbTerminalBlockAssembly: terminal block depth collides with the rear mounting datum");
-  }
-  if (pinHoleDiameter >= terminalPitch * 0.55) {
-    throw new Error("pcbTerminalBlockAssembly: pinDiameter and pinClearance leave too little PCB web between terminal holes");
-  }
-  if (wirePortDiameter >= Math.min(terminalPitch * 0.72, terminalBlockHeight * 0.65)) {
-    throw new Error("pcbTerminalBlockAssembly: wirePortDiameter is too large for the terminal pitch or body height");
-  }
-  for (const [index2, [x2, y2]] of [...mountingPositions, ...pinPositions].entries()) {
-    if (!Number.isFinite(x2) || !Number.isFinite(y2)) {
-      throw new Error(`pcbTerminalBlockAssembly: generated datum position ${index2} is not finite`);
-    }
-  }
-  const backplateWidth = boardWidth + backplateMargin * 2;
-  const backplateDepth = boardDepth + backplateMargin * 2;
-  const boardBottomZ = backplateThickness + standoffHeight;
-  const boardTopZ = boardBottomZ + boardThickness;
-  const standoffOverlap = Math.min(0.08, standoffHeight * 0.03);
-  const standoffThreadEnvelopeDiameter = Math.max(sizeData.loose, screwDiameter + 1);
-  const standoffThreadEnvelope = cylinder(standoffHeight + 0.8, standoffThreadEnvelopeDiameter / 2, void 0, segments).translate(
-    0,
-    0,
-    backplateThickness - 0.4
-  );
-  const standoffThreadEnvelopes = union(...mountingPositions.map(([x2, y2]) => standoffThreadEnvelope.translate(x2, y2, 0)));
-  const standoff = cylinder(standoffHeight + standoffOverlap, standoffDiameter / 2, void 0, segments).translate(0, 0, backplateThickness - standoffOverlap).subtract(standoffThreadEnvelope);
-  const standoffs = union(...mountingPositions.map(([x2, y2]) => standoff.translate(x2, y2, 0)));
-  const backplate = union(box(backplateWidth, backplateDepth, backplateThickness), standoffs).color("#475569");
-  const boardMountingHoleDiameter = sizeData.normal;
-  const boardMountHole = cylinder(boardThickness + 0.8, boardMountingHoleDiameter / 2, void 0, segments).translate(
-    0,
-    0,
-    boardBottomZ - 0.4
-  );
-  const pcbMountingHoles = union(...mountingPositions.map(([x2, y2]) => boardMountHole.translate(x2, y2, 0)));
-  const pinHole = cylinder(boardThickness + 0.8, pinHoleDiameter / 2, void 0, segments).translate(0, 0, boardBottomZ - 0.4);
-  const pcbPinHoles = union(...pinPositions.map(([x2, y2]) => pinHole.translate(x2, y2, 0)));
-  const pcb = box(boardWidth, boardDepth, boardThickness).translate(0, 0, boardBottomZ).subtract(pcbMountingHoles).subtract(pcbPinHoles).color("#166534");
-  const terminalBodyBlank = box(terminalBlockWidth, terminalBlockDepth, terminalBlockHeight).translate(0, terminalCenterY, boardTopZ);
-  const wirePort = cylinderAlongY(terminalBlockDepth + 0.8, wirePortDiameter / 2, terminalCenterY, segments).translate(
-    0,
-    0,
-    boardTopZ + terminalBlockHeight * 0.42
-  );
-  const wirePorts = union(...pinPositions.map(([x2]) => wirePort.translate(x2, 0, 0)));
-  const clampScrewPockets = union(
-    ...pinPositions.map(
-      ([x2]) => cylinder(
-        Math.max(0.6, terminalBlockHeight * 0.22),
-        Math.min(terminalPitch * 0.22, wirePortDiameter * 0.42),
-        void 0,
-        segments
-      ).translate(x2, terminalCenterY + terminalBlockDepth * 0.12, boardTopZ + terminalBlockHeight * 0.76)
-    )
-  );
-  const pinLength = boardThickness + pinTailLength + Math.min(0.6, terminalBlockHeight * 0.08);
-  const pinStartZ = boardBottomZ - pinTailLength;
-  const pins = union(...pinPositions.map(([x2, y2]) => cylinder(pinLength, pinDiameter / 2, void 0, segments).translate(x2, y2, pinStartZ)));
-  const terminalBlock = union(terminalBodyBlank.subtract(wirePorts).subtract(clampScrewPockets), pins).color("#16a34a");
-  const screwShaftLength = boardThickness + standoffHeight * 0.85;
-  const mountingHardware = fastenerSet(screwSize, screwShaftLength, {
-    washerUnderHead: false,
-    washerUnderNut: false,
-    fit: "normal",
-    segments
-  });
-  const screws = mountingPositions.map(([x2, y2]) => mountingHardware.bolt.translate(x2, y2, boardTopZ).color("#cbd5e1"));
-  const parts = [
-    { name: "electronics backplate with fused PCB standoffs", shape: backplate },
-    { name: "PCB with mounting holes and terminal pin clearances", shape: pcb },
-    { name: "seated purchased terminal block with through-board pins", shape: terminalBlock },
-    ...screws.map((shape, index2) => ({ name: `installed ${screwSize} PCB mounting screw ${index2 + 1}`, shape }))
-  ];
-  return {
-    parts,
-    backplate,
-    pcb,
-    terminalBlock,
-    screws,
-    mountingPositions,
-    pinPositions,
-    cutters: {
-      pcbMountingHoles,
-      pcbPinHoles,
-      standoffThreadEnvelopes
-    },
-    dims: {
-      terminalCount,
-      terminalPitch,
-      boardWidth,
-      boardDepth,
-      boardThickness,
-      backplateWidth,
-      backplateDepth,
-      backplateThickness,
-      standoffHeight,
-      standoffDiameter,
-      screwSize,
-      screwDiameter,
-      screwHeadDiameter,
-      screwHeadHeight,
-      screwShaftLength,
-      boardMountingHoleDiameter,
-      standoffThreadEnvelopeDiameter,
-      terminalBlockWidth,
-      terminalBlockDepth,
-      terminalBlockHeight,
-      terminalEdgeInset,
-      pinDiameter,
-      pinClearance,
-      pinHoleDiameter,
-      pinTailLength,
-      wirePortDiameter
-    }
-  };
-}
-function thumbScrewClampAssembly(options = {}) {
-  const screwSize = options.screwSize ?? "M6";
-  const segments = options.segments ?? 36;
-  const sizeData = METRIC_HOLE_TABLE[screwSize];
-  if (!sizeData) throw new Error(`thumbScrewClampAssembly: unsupported screwSize "${screwSize}"`);
-  const screwDiameter = parseFloat(screwSize.replace("M", ""));
-  const runningClearance = requirePositive$6(options.runningClearance ?? 0.35, "runningClearance");
-  const faceClearance = requireNonNegative(options.faceClearance ?? 0, "faceClearance");
-  const threadEnvelopeDiameter = Math.max(sizeData.normal, screwDiameter + runningClearance * 2);
-  const pressurePadDiameter = requirePositive$6(options.pressurePadDiameter ?? Math.max(screwDiameter * 3.2, 18), "pressurePadDiameter");
-  const pressurePadThickness = requirePositive$6(options.pressurePadThickness ?? Math.max(screwDiameter * 0.72, 4), "pressurePadThickness");
-  const knobDiameter = requirePositive$6(options.knobDiameter ?? Math.max(screwDiameter * 4.2, 24), "knobDiameter");
-  const knobThickness = requirePositive$6(options.knobThickness ?? Math.max(screwDiameter * 0.9, 7), "knobThickness");
-  const workpieceThickness = requirePositive$6(options.workpieceThickness ?? 18, "workpieceThickness");
-  const workpieceDepth = requirePositive$6(options.workpieceDepth ?? Math.max(46, pressurePadDiameter * 1.5), "workpieceDepth");
-  const workpieceHeight = requirePositive$6(options.workpieceHeight ?? Math.max(pressurePadDiameter * 1.35, 24), "workpieceHeight");
-  const frameDepth = requirePositive$6(options.frameDepth ?? Math.max(workpieceDepth + 12, pressurePadDiameter + 16), "frameDepth");
-  const baseThickness = requirePositive$6(options.baseThickness ?? Math.max(screwDiameter, 6), "baseThickness");
-  const jawThickness = requirePositive$6(options.jawThickness ?? Math.max(screwDiameter * 1.35, 9), "jawThickness");
-  const supportThickness = requirePositive$6(options.supportThickness ?? Math.max(screwDiameter * 1.8, 12), "supportThickness");
-  const bossLength = requirePositive$6(options.bossLength ?? Math.max(screwDiameter * 1.1, 8), "bossLength");
-  const bossDiameter = requirePositive$6(options.bossDiameter ?? Math.max(threadEnvelopeDiameter + 5, screwDiameter * 2.5), "bossDiameter");
-  const exposedScrewLength = requirePositive$6(
-    options.exposedScrewLength ?? Math.max(pressurePadDiameter * 0.45, screwDiameter * 2.2),
-    "exposedScrewLength"
-  );
-  const screwCenterZ = baseThickness + Math.max(workpieceHeight * 0.52, pressurePadDiameter * 0.68);
-  const frameHeight = requirePositive$6(
-    options.frameHeight ?? screwCenterZ - baseThickness + pressurePadDiameter / 2 + Math.max(baseThickness, 7),
-    "frameHeight"
-  );
-  if (workpieceDepth > frameDepth - 6) {
-    throw new Error("thumbScrewClampAssembly: frameDepth must leave side material around the clamped workpiece");
-  }
-  if (pressurePadDiameter > frameDepth - 4) {
-    throw new Error("thumbScrewClampAssembly: pressurePadDiameter is too large for the frame depth");
-  }
-  if (bossDiameter > frameDepth - 4) {
-    throw new Error("thumbScrewClampAssembly: bossDiameter is too large for the frame depth");
-  }
-  if (screwCenterZ - pressurePadDiameter / 2 <= baseThickness + 0.5) {
-    throw new Error("thumbScrewClampAssembly: pressure pad collides with the base bridge");
-  }
-  if (baseThickness + frameHeight - screwCenterZ <= pressurePadDiameter / 2 + 2) {
-    throw new Error("thumbScrewClampAssembly: frameHeight leaves too little material above the screw axis");
-  }
-  if (threadEnvelopeDiameter + 4 > Math.min(frameDepth, frameHeight)) {
-    throw new Error("thumbScrewClampAssembly: threaded boss bore leaves too little surrounding frame material");
-  }
-  const workpieceLeftFaceX = -workpieceThickness / 2;
-  const workpieceRightFaceX = workpieceThickness / 2;
-  const anvilOverlap = Math.min(0.35, pressurePadThickness * 0.18);
-  const anvilPadCenterX = workpieceLeftFaceX - faceClearance - pressurePadThickness / 2;
-  const pressurePadCenterX = workpieceRightFaceX + faceClearance + pressurePadThickness / 2;
-  const fixedJawRightFaceX = anvilPadCenterX - pressurePadThickness / 2 + anvilOverlap;
-  const fixedJawCenterX = fixedJawRightFaceX - jawThickness / 2;
-  const pressurePadRightFaceX = pressurePadCenterX + pressurePadThickness / 2;
-  const supportInnerFaceX = pressurePadRightFaceX + exposedScrewLength;
-  const supportCenterX = supportInnerFaceX + supportThickness / 2;
-  const supportOuterFaceX = supportInnerFaceX + supportThickness;
-  const frameLeftFaceX = fixedJawCenterX - jawThickness / 2;
-  const frameRightFaceX = supportOuterFaceX;
-  const baseLength = frameRightFaceX - frameLeftFaceX;
-  if (baseLength <= 0 || !Number.isFinite(baseLength)) {
-    throw new Error("thumbScrewClampAssembly: generated clamp frame length is invalid");
-  }
-  const bossCenterX = supportInnerFaceX + (supportThickness + bossLength) / 2;
-  const threadedBossBore = cylinderAlongX(supportThickness + bossLength + 1, threadEnvelopeDiameter / 2, bossCenterX, segments).translate(
-    0,
-    0,
-    screwCenterZ
-  );
-  const frameOverlap = Math.min(0.12, baseThickness * 0.04);
-  const base = box(baseLength, frameDepth, baseThickness).translate((frameLeftFaceX + frameRightFaceX) / 2, 0, 0);
-  const fixedJaw = box(jawThickness, frameDepth, frameHeight + frameOverlap).translate(fixedJawCenterX, 0, baseThickness - frameOverlap);
-  const support = box(supportThickness, frameDepth, frameHeight + frameOverlap).translate(supportCenterX, 0, baseThickness - frameOverlap);
-  const boss2 = cylinderAlongX(supportThickness + bossLength, bossDiameter / 2, bossCenterX, segments).translate(0, 0, screwCenterZ);
-  const anvilPad = cylinderAlongX(pressurePadThickness, pressurePadDiameter / 2, anvilPadCenterX, segments).translate(0, 0, screwCenterZ);
-  const frame = union(base, fixedJaw, support, boss2, anvilPad).subtract(threadedBossBore).color("#475569");
-  const workpieceBottomZ = screwCenterZ - workpieceHeight / 2;
-  const workpiece = box(workpieceThickness, workpieceDepth, workpieceHeight).translate(0, 0, workpieceBottomZ).color("#a16207");
-  const pressurePad = cylinderAlongX(pressurePadThickness, pressurePadDiameter / 2, pressurePadCenterX, segments).translate(
-    0,
-    0,
-    screwCenterZ
-  );
-  const knobCenterX = supportOuterFaceX + bossLength + runningClearance + knobThickness / 2;
-  const knob = cylinderAlongX(knobThickness, knobDiameter / 2, knobCenterX, segments).translate(0, 0, screwCenterZ);
-  const shaftLeftX = pressurePadRightFaceX - Math.min(pressurePadThickness * 0.45, screwDiameter * 0.45);
-  const shaftRightX = knobCenterX + knobThickness / 2;
-  const shaftLength = shaftRightX - shaftLeftX;
-  if (shaftLength <= supportThickness + bossLength) {
-    throw new Error("thumbScrewClampAssembly: generated screw length is too short for the threaded support");
-  }
-  const shaft = cylinderAlongX(shaftLength, screwDiameter / 2, (shaftLeftX + shaftRightX) / 2, segments).translate(0, 0, screwCenterZ);
-  const clampScrew = union(shaft, pressurePad, knob).color("#cbd5e1");
-  const workpieceEnvelope = box(workpieceThickness, workpieceDepth, workpieceHeight).translate(0, 0, workpieceBottomZ);
-  return {
-    parts: [
-      { name: "thumb-screw clamp frame with fixed anvil and threaded boss", shape: frame },
-      { name: "representative clamped workpiece between pads", shape: workpiece },
-      { name: "installed thumb screw with captive pressure pad and hand knob", shape: clampScrew }
-    ],
-    frame,
-    workpiece,
-    clampScrew,
-    cutters: {
-      threadedBossBore,
-      workpieceEnvelope
-    },
-    dims: {
-      screwSize,
-      screwDiameter,
-      threadEnvelopeDiameter,
-      workpieceThickness,
-      workpieceDepth,
-      workpieceHeight,
-      frameDepth,
-      frameHeight,
-      baseThickness,
-      jawThickness,
-      supportThickness,
-      bossLength,
-      bossDiameter,
-      exposedScrewLength,
-      pressurePadDiameter,
-      pressurePadThickness,
-      knobDiameter,
-      knobThickness,
-      screwCenterZ,
-      fixedAnvilFaceX: workpieceLeftFaceX - faceClearance,
-      pressurePadFaceX: workpieceRightFaceX + faceClearance,
-      supportInnerFaceX,
-      runningClearance,
-      faceClearance
-    }
-  };
-}
 function fastenerSet(size, boltLength, options) {
   const sizeData = METRIC_HOLE_TABLE[size];
   if (!sizeData) throw new Error(`fastenerSet: unsupported size "${size}"`);
@@ -50459,22 +49681,6 @@ const partLibrary = {
   nut,
   washer,
   fastenerSet,
-  boltedServiceCover,
-  datumEnclosureAssembly,
-  snapLatchCoverAssembly,
-  pinnedLeverAssembly,
-  retainedShaftAssembly,
-  capturedLinearSlide,
-  capturedCartridgeGuideAssembly,
-  livingHingeCoverAssembly,
-  knuckledHingeAssembly,
-  clevisPinJointAssembly,
-  seatedBearingAssembly,
-  cableGlandAnchorAssembly,
-  hoseBarbPortAssembly,
-  routedTubeClipAssembly,
-  pcbTerminalBlockAssembly,
-  thumbScrewClampAssembly,
   pipeRoute,
   elbow,
   beltDrive,
@@ -306313,7 +305519,8 @@ function describeKinematicConvergenceError(kinematics) {
   const edgeResidual = edge ? Math.abs(edge.residual) : 0;
   const angleResidual = angle ? Math.abs(angle.residual) : 0;
   const worst = edgeResidual >= angleResidual && edge ? `edge "${edge.name}"` : angle ? `angle "${angle.name}"` : "constraint";
-  return `Assembly kinematic solve did not converge (max residual ${kinematics.maxResidual.toFixed(6)}, worst ${worst}). The requested control state is outside the mechanism's valid range; rejecting best-effort stretched geometry.`;
+  const diagnostic = kinematics.diagnostics.length > 0 ? ` Diagnostic: ${kinematics.diagnostics[0]}` : "";
+  return `Assembly kinematic solve did not converge (max residual ${kinematics.maxResidual.toFixed(6)}, worst ${worst}).${diagnostic} The requested control state is outside the selected mechanism mode or valid range; rejecting best-effort stretched geometry.`;
 }
 function mapScriptResultToScene(args) {
   var _a3;