forgecad 0.9.5 → 0.9.7

package/dist/assets/{evalWorker-c_SB9gg3.js → evalWorker-Ds5U4xtN.js}

@@ -721,7 +721,7 @@ function cloneSdfNode(node) {
   }
 }
 const SHEET_METAL_EDGES = ["top", "right", "bottom", "left"];
-const EPS$c = 1e-9;
+const EPS$d = 1e-9;
 function isFinitePositive$3(value) {
   return Number.isFinite(value) && value > 0;
 }
@@ -762,7 +762,7 @@ function edgeDisplayName(edge) {
   return `sheetMetal().flange("${edge}", ...)`;
 }
 function normalizeAngle(angleDeg) {
-  return Math.abs(angleDeg) <= EPS$c ? 0 : angleDeg;
+  return Math.abs(angleDeg) <= EPS$d ? 0 : angleDeg;
 }
 function validateSheetMetalModel(model) {
   if (!isFinitePositive$3(model.panel.width) || !isFinitePositive$3(model.panel.height)) {
@@ -774,7 +774,7 @@ function validateSheetMetalModel(model) {
   if (!isFiniteNonNegative(model.bendRadius)) {
     return "sheetMetal() requires a finite non-negative bendRadius.";
   }
-  if (model.bendRadius <= EPS$c) {
+  if (model.bendRadius <= EPS$d) {
     return "sheetMetal() v1 requires a positive bendRadius so the bend region stays explicit instead of collapsing into a sharp fold.";
   }
   if (model.bendAllowance.kind !== "k-factor") {
@@ -836,7 +836,7 @@ function deriveSheetMetalModel(model) {
     const trimEnd = flanges.has(adjacent.end) ? model.cornerRelief.size : 0;
     const fullLength = edge === "top" || edge === "bottom" ? model.panel.width : model.panel.height;
     const span = fullLength - trimStart - trimEnd;
-    if (!(span > EPS$c)) {
+    if (!(span > EPS$d)) {
       throw new Error(
         `${edgeDisplayName(edge)} loses all usable span after applying the defended rectangular corner relief size ${model.cornerRelief.size}.`
       );
@@ -894,7 +894,7 @@ function transformPlacement(origin, u2, v, normal) {
   };
 }
 function translatePlan(plan, x2, y2, z2) {
-  if (Math.abs(x2) <= EPS$c && Math.abs(y2) <= EPS$c && Math.abs(z2) <= EPS$c) return cloneShapeCompilePlan(plan);
+  if (Math.abs(x2) <= EPS$d && Math.abs(y2) <= EPS$d && Math.abs(z2) <= EPS$d) return cloneShapeCompilePlan(plan);
   return appendShapeCompileTransform(cloneShapeCompilePlan(plan), {
     kind: "translate",
     x: x2,
@@ -1338,7 +1338,7 @@ function cloneShapeWorkplanePlacement(placement) {
     placement: cloneSketchPlacementModel(placement.placement)
   };
 }
-const EPS$b = 1e-10;
+const EPS$c = 1e-10;
 function subVec3(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
@@ -1364,7 +1364,7 @@ function projectRadial(v, axis) {
 function signedAngleAroundAxis(from, to, axis) {
   const fromLen = lengthVec3$1(from);
   const toLen = lengthVec3$1(to);
-  if (fromLen < EPS$b || toLen < EPS$b) return 0;
+  if (fromLen < EPS$c || toLen < EPS$c) return 0;
   const fn = scaleVec3(from, 1 / fromLen);
   const tn = scaleVec3(to, 1 / toLen);
   const sin2 = dotVec3$4(axis, crossVec3$2(fn, tn));
@@ -1385,19 +1385,19 @@ function solveRotateAroundAngle(axis, pivot, movingPoint, targetPoint, options =
   const targetDecomp = projectRadial(target, unitAxis);
   const movingRadialLen = lengthVec3$1(movingDecomp.radial);
   const targetRadialLen = lengthVec3$1(targetDecomp.radial);
-  if (movingRadialLen < EPS$b) {
-    if (mode === "line" && targetRadialLen >= EPS$b) {
+  if (movingRadialLen < EPS$c) {
+    if (mode === "line" && targetRadialLen >= EPS$c) {
       throw new Error("rotateAroundTo(...): moving point lies on the rotation axis, so line alignment is impossible");
     }
     return 0;
   }
   if (mode === "plane") {
-    if (targetRadialLen < EPS$b) {
+    if (targetRadialLen < EPS$c) {
       throw new Error("rotateAroundTo(...): target point lies on the rotation axis, so the target plane is undefined");
     }
     return signedAngleAroundAxis(movingDecomp.radial, targetDecomp.radial, unitAxis);
   }
-  if (targetRadialLen < EPS$b) {
+  if (targetRadialLen < EPS$c) {
     throw new Error("rotateAroundTo(...): target line lies on the rotation axis, but the moving point does not");
   }
   const axialTol = 1e-8 * Math.max(1, Math.abs(movingDecomp.axial), Math.abs(targetDecomp.axial));
@@ -1437,7 +1437,7 @@ function multiplyMat4(a2, b) {
 }
 function normalizeVec3$5(v) {
   const len2 = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-  if (len2 < EPS$b) throw new Error("Axis must be non-zero");
+  if (len2 < EPS$c) throw new Error("Axis must be non-zero");
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function transformPoint$1(m2, p2, w2) {
@@ -1467,7 +1467,7 @@ function invertMat4(m2) {
   const b10 = a21 * a33 - a23 * a31;
   const b11 = a22 * a33 - a23 * a32;
   const det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
-  if (Math.abs(det) < EPS$b) throw new Error("Transform matrix is not invertible");
+  if (Math.abs(det) < EPS$c) throw new Error("Transform matrix is not invertible");
   const invDet = 1 / det;
   out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * invDet;
   out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * invDet;
@@ -3224,14 +3224,14 @@ function sweepPathToPolylineAdaptive(path2, baseSamples = 48) {
   pts.push(evalPathAt(path2, 1));
   return pts;
 }
-const EPS$a = 1e-8;
+const EPS$b = 1e-8;
 const SUPPORTED_VERTICAL_EDGE_NAMES = ["vert-bl", "vert-br", "vert-tr", "vert-tl"];
 function midpoint$4(start, end) {
   return [(start[0] + end[0]) * 0.5, (start[1] + end[1]) * 0.5, (start[2] + end[2]) * 0.5];
 }
 function normalize$7(v) {
   const len2 = Math.hypot(v[0], v[1], v[2]);
-  if (len2 <= EPS$a) throw new Error("Edge feature selection requires a non-zero direction vector");
+  if (len2 <= EPS$b) throw new Error("Edge feature selection requires a non-zero direction vector");
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function subtract(a2, b) {
@@ -3313,7 +3313,7 @@ function rigidTransformForEdgeStep(step) {
     case "mirror": {
       const [nx0, ny0, nz0] = [step.normalX, step.normalY, step.normalZ];
       const len2 = Math.hypot(nx0, ny0, nz0);
-      if (len2 <= EPS$a) return Transform.identity();
+      if (len2 <= EPS$b) return Transform.identity();
       const nx = nx0 / len2;
       const ny = ny0 / len2;
       const nz = nz0 / len2;
@@ -3624,7 +3624,7 @@ function isRectangleProfile(points) {
     return [next[0] - point2[0], next[1] - point2[1]];
   });
   const lengths2 = vectors.map(([x2, y2]) => Math.hypot(x2, y2));
-  if (lengths2.some((length4) => length4 <= EPS$a)) return false;
+  if (lengths2.some((length4) => length4 <= EPS$b)) return false;
   const dot01 = vectors[0][0] * vectors[1][0] + vectors[0][1] * vectors[1][1];
   const dot12 = vectors[1][0] * vectors[2][0] + vectors[1][1] * vectors[2][1];
   const dot23 = vectors[2][0] * vectors[3][0] + vectors[2][1] * vectors[3][1];
@@ -5691,13 +5691,13 @@ function parseMeshFile(data, format) {
       return parse3mf(data);
   }
 }
-const EPS$9 = 1e-8;
+const EPS$a = 1e-8;
 function length$3(v) {
   return Math.hypot(v[0], v[1], v[2]);
 }
 function normalize$6(v) {
   const len2 = length$3(v);
-  if (len2 < EPS$9) throw new Error("Plane normal must be non-zero");
+  if (len2 < EPS$a) throw new Error("Plane normal must be non-zero");
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function resolvePlaneOriginNormal(plane) {
@@ -5719,12 +5719,12 @@ function resolvePlaneOriginNormal(plane) {
 function rotationToPlaneSpace(normal) {
   const n = normalize$6(normal);
   const dot2 = n[2];
-  if (dot2 > 1 - EPS$9) {
+  if (dot2 > 1 - EPS$a) {
     return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
   }
   let axis;
   let angle;
-  if (dot2 < -1 + EPS$9) {
+  if (dot2 < -1 + EPS$a) {
     axis = [1, 0, 0];
     angle = Math.PI;
   } else {
@@ -8286,7 +8286,7 @@ function scale$6(v, s) {
 function sub$7(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
-function cross$7(a2, b) {
+function cross$8(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 makeEdge(name, start, end, faceName, curve) {
@@ -8322,7 +8322,7 @@ function buildSurfaceSheetTopology(boundaries, options = {}) {
   const center = options.center ?? average$1(corners);
   const uAxis = normalizeAxis$1(sub$7(midpoint$3(u1Start, u1End), midpoint$3(u0Start, u0End)));
   const vAxis = normalizeAxis$1(sub$7(midpoint$3(v1Start, v1End), midpoint$3(v0Start, v0End)));
-  const normal = normalizeAxis$1(options.normal ?? cross$7(uAxis, vAxis));
+  const normal = normalizeAxis$1(options.normal ?? cross$8(uAxis, vAxis));
   const faces = /* @__PURE__ */ new Map();
   faces.set(faceName, {
     name: faceName,
@@ -10224,6 +10224,7 @@ function buildSweepLevelSetInput(profilePolygons, pathInput, options) {
     edgeLength: options.edgeLength
   };
 }
+const EPS$9 = 1e-9;
 function resamplePolygon(poly, targetCount) {
   if (poly.length < 2) return poly;
   if (targetCount <= 0) return [];
@@ -10261,6 +10262,78 @@ function resamplePolygon(poly, targetCount) {
   }
   return out;
 }
+function resamplePolygonByAngle(poly, targetCount, center = polygonCentroid$2(poly)) {
+  if (poly.length < 3 || targetCount <= 0) return null;
+  if (!isConvexPolygon(poly)) return null;
+  const out = [];
+  for (let index2 = 0; index2 < targetCount; index2 += 1) {
+    const angle = index2 / targetCount * Math.PI * 2;
+    const point2 = rayPolygonIntersection(center, [Math.cos(angle), Math.sin(angle)], poly);
+    if (!point2) return null;
+    out.push(point2);
+  }
+  return out;
+}
+function rayPolygonIntersection(origin, direction2, poly) {
+  let bestT = Infinity;
+  let best = null;
+  for (let index2 = 0; index2 < poly.length; index2 += 1) {
+    const a2 = poly[index2];
+    const b = poly[(index2 + 1) % poly.length];
+    const edge = [b[0] - a2[0], b[1] - a2[1]];
+    const denom = cross$7(direction2, edge);
+    if (Math.abs(denom) < EPS$9) continue;
+    const delta = [a2[0] - origin[0], a2[1] - origin[1]];
+    const rayT = cross$7(delta, edge) / denom;
+    const edgeT = cross$7(delta, direction2) / denom;
+    if (rayT >= -EPS$9 && edgeT >= -EPS$9 && edgeT <= 1 + EPS$9 && rayT < bestT) {
+      bestT = rayT;
+      best = [origin[0] + direction2[0] * rayT, origin[1] + direction2[1] * rayT];
+    }
+  }
+  return best;
+}
+function polygonCentroid$2(poly) {
+  let area2 = 0;
+  let cx = 0;
+  let cy = 0;
+  for (let index2 = 0; index2 < poly.length; index2 += 1) {
+    const a2 = poly[index2];
+    const b = poly[(index2 + 1) % poly.length];
+    const crossValue = cross$7(a2, b);
+    area2 += crossValue;
+    cx += (a2[0] + b[0]) * crossValue;
+    cy += (a2[1] + b[1]) * crossValue;
+  }
+  if (Math.abs(area2) < EPS$9) return averagePoint(poly);
+  return [cx / (3 * area2), cy / (3 * area2)];
+}
+function averagePoint(poly) {
+  let x2 = 0;
+  let y2 = 0;
+  for (const point2 of poly) {
+    x2 += point2[0];
+    y2 += point2[1];
+  }
+  return [x2 / poly.length, y2 / poly.length];
+}
+function isConvexPolygon(poly) {
+  let sign2 = 0;
+  for (let index2 = 0; index2 < poly.length; index2 += 1) {
+    const a2 = poly[index2];
+    const b = poly[(index2 + 1) % poly.length];
+    const c2 = poly[(index2 + 2) % poly.length];
+    const turn = cross$7([b[0] - a2[0], b[1] - a2[1]], [c2[0] - b[0], c2[1] - b[1]]);
+    if (Math.abs(turn) < EPS$9) continue;
+    const currentSign = Math.sign(turn);
+    if (sign2 !== 0 && currentSign !== sign2) return false;
+    sign2 = currentSign;
+  }
+  return sign2 !== 0;
+}
+function cross$7(a2, b) {
+  return a2[0] * b[1] - a2[1] * b[0];
+}
 function loftStitched(profiles2, heights, wasm) {
   if (profiles2.length < 2) return null;
   const classified = profiles2.map((loops) => classifyLoops(loops));
@@ -10389,8 +10462,10 @@ function stitchSingleLoopLoft(loops, heights, wasm) {
     maxPoints = Math.max(maxPoints, loop.length);
   }
   const N = Math.max(maxPoints, 24);
+  const angularSamples = normalizedLoops.map((loop) => resamplePolygonByAngle(loop, N));
+  const useAngularSamples = angularSamples.every((samples) => samples != null);
   const resampled = normalizedLoops.map((loop, i) => {
-    const pts2d = resamplePolygon(loop, N);
+    const pts2d = useAngularSamples ? angularSamples[i] : resamplePolygon(loop, N);
     const z2 = heights[i];
     return pts2d.map(([x2, y2]) => [x2, y2, z2]);
   });
@@ -10451,7 +10526,7 @@ let _wasm$1 = null;
 async function initManifoldWasm() {
   if (_wasm$1) return _wasm$1;
   performance.mark("manifold:start");
-  const Module = (await import("./manifold-Cjk7WhRs.js")).default;
+  const Module = (await import("./manifold-sJ-axdXM.js")).default;
   performance.mark("manifold:imported");
   const wasm = await Module();
   wasm.setup();
@@ -10583,6 +10658,23 @@ let ManifoldShapeBackend = _ManifoldShapeBackend;
 function wrapManifoldShapeBackend(manifold) {
   return new ManifoldShapeBackend(manifold);
 }
+function reconstructBackendFromMesh(mesh) {
+  const wasm = getManifoldWasm();
+  const wasmMesh = new wasm.Mesh({
+    numProp: mesh.numProp,
+    triVerts: mesh.triVerts,
+    vertProperties: mesh.vertProperties,
+    mergeFromVert: mesh.mergeFromVert.length > 0 ? mesh.mergeFromVert : void 0,
+    mergeToVert: mesh.mergeToVert.length > 0 ? mesh.mergeToVert : void 0
+  });
+  let manifold;
+  try {
+    manifold = new wasm.Manifold(wasmMesh);
+  } catch {
+    manifold = wasm.Manifold.cube([0, 0, 0]);
+  }
+  return new ManifoldShapeBackend(manifold);
+}
 function requireManifoldShapeBackend(backend, apiName = "requireManifoldShapeBackend()") {
   if (isManifoldCapableBackend(backend)) {
     return backend.requireManifold(apiName);
@@ -47289,10 +47381,8 @@ class PathBuilder {
     if (radius <= 0) throw new Error("fillet: radius must be positive");
     const n = this.segs.length;
     if (n < 2) throw new Error("fillet: need at least 2 segments before a fillet");
-    const prev = this.segs[n - 2];
     const curr = this.segs[n - 1];
-    curr.kind === "line" || curr.kind === "move" ? prev.kind === "line" || prev.kind === "move" ? 0 : 0 : 0;
-    const { trimA, trimB, arcSeg } = this.computeFilletGeom(radius);
+    const { trimA, arcSeg } = this.computeFilletGeom(radius);
     if (!arcSeg) throw new Error("fillet: cannot fillet these segments (parallel or degenerate)");
     this.trimLastSegEnd(n - 2, trimA[0], trimA[1]);
     const trimmedSeg = { ...curr };
@@ -47364,7 +47454,6 @@ class PathBuilder {
   }
   getSegDirAt(seg, which) {
     if (seg.kind === "line" || seg.kind === "move") {
-      this.segs.length;
       const idx = this.segs.indexOf(seg);
       if (seg.kind === "line") {
         let sx, sy;
@@ -47606,6 +47695,41 @@ class PathBuilder {
     }
     return pts;
   }
+  /**
+   * Return the open path as a sampled 2D polyline.
+   *
+   * This is for construction geometry such as guide rails, measured centerlines,
+   * and curve-driven helpers where the authored path should stay open instead of
+   * becoming a filled sketch or stroked profile.
+   *
+   * **Example**
+   *
+   * ```ts
+   * const rail = path()
+   *   .moveTo(24, 0)
+   *   .bezierTo(32, 44, 28, 92, 18, 120)
+   *   .toPolyline();
+   * ```
+   *
+   * @returns A sampled open polyline.
+   * @category Path Builder
+   */
+  toPolyline() {
+    const moveCount = this.segs.filter((seg) => seg.kind === "move").length;
+    if (moveCount > 1) {
+      throw new Error("path().toPolyline() supports one continuous open path. Use separate path() builders for separate rails.");
+    }
+    const pts = [];
+    for (const point2 of this.tessellate()) {
+      if (!point2.every(Number.isFinite)) throw new Error("path().toPolyline() produced a non-finite point");
+      const previous = pts[pts.length - 1];
+      if (!previous || Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-9) {
+        pts.push(point2);
+      }
+    }
+    if (pts.length < 2) throw new Error("path().toPolyline() needs at least 2 points");
+    return pts;
+  }
   // ── Output ────────────────────────────────────────────────────────────────
   /**
    * Close the path and return a filled `Sketch`.
@@ -49463,7 +49587,7 @@ function spurGear(options) {
   });
   return attachGearMeta(shapeWithConnectors, meta2);
 }
-function requirePositive$7(scope, name, value) {
+function requirePositive$8(scope, name, value) {
   if (!isFinitePositive(value)) throw new Error(`${scope}: "${name}" must be > 0`);
 }
 function requireOptionalBore(scope, boreDiameter, maxDiameter) {
@@ -49485,8 +49609,8 @@ function cutBore$1(shape, boreDiameter) {
   return shape.subtract(cutter);
 }
 function gearBodyDisk(options) {
-  requirePositive$7("gearBodyDisk", "outerRadius", options.outerRadius);
-  requirePositive$7("gearBodyDisk", "faceWidth", options.faceWidth);
+  requirePositive$8("gearBodyDisk", "outerRadius", options.outerRadius);
+  requirePositive$8("gearBodyDisk", "faceWidth", options.faceWidth);
   const bore = requireOptionalBore("gearBodyDisk", options.boreDiameter, options.outerRadius * 2);
   const segments = resolveSegments(options.segments);
   const outer = circle2d(options.outerRadius, segments);
@@ -49494,14 +49618,14 @@ function gearBodyDisk(options) {
   return sketchExtrude(profile, options.faceWidth);
 }
 function gearBodyDiskWithHub(options) {
-  requirePositive$7("gearBodyDiskWithHub", "hubDiameter", options.hubDiameter);
+  requirePositive$8("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$7("gearBodyDiskWithHub", "hubFaceWidth", hubFaceWidth);
+  requirePositive$8("gearBodyDiskWithHub", "hubFaceWidth", hubFaceWidth);
   const hub = cylinder(hubFaceWidth, options.hubDiameter * 0.5, void 0, options.segments).translate(
     0,
     0,
@@ -49510,11 +49634,11 @@ function gearBodyDiskWithHub(options) {
   return cutBore$1(base.add(hub), bore);
 }
 function gearBodySpoked(options) {
-  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);
+  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);
   if (!Number.isInteger(options.spokeCount) || options.spokeCount < 2) {
     throw new Error('gearBodySpoked: "spokeCount" must be an integer >= 2');
   }
@@ -49537,12 +49661,12 @@ function gearBodySpoked(options) {
 }
 function gearBodyFromProfile(profile, options) {
   if (!(profile instanceof Sketch)) throw new Error('gearBodyFromProfile: "profile" must be a Sketch');
-  requirePositive$7("gearBodyFromProfile", "faceWidth", options.faceWidth);
+  requirePositive$8("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$6(scope, name, value) {
+function requirePositive$7(scope, name, value) {
   if (!isFinitePositive(value)) throw new Error(`${scope}: "${name}" must be > 0`);
 }
 function requireFiniteAngle(scope, name, value) {
@@ -49604,7 +49728,7 @@ function buildSpurTeethRegion(options, name, faceWidth) {
 }
 function buildSolidArcRegion(options, name, faceWidth) {
   const scope = "driveWheel.addSolidArcBetween";
-  requirePositive$6(scope, "outerRadius", options.outerRadius);
+  requirePositive$7(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"`);
@@ -49670,7 +49794,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$6("driveWheel", "faceWidth", options.faceWidth);
+    if (options.faceWidth !== void 0) requirePositive$7("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;
@@ -49705,7 +49829,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$6(scope, "outerRadius", options.outerRadius);
+    if (options.outerRadius !== void 0) requirePositive$7(scope, "outerRadius", options.outerRadius);
     this.regions.push({
       shape: shape.clone(),
       meta: {
@@ -49771,7 +49895,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$6(scope, "faceWidth", faceWidth);
+    requirePositive$7(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`);
     }
@@ -50924,6 +51048,1867 @@ 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}"`);
@@ -50984,6 +52969,22 @@ const partLibrary = {
   nut,
   washer,
   fastenerSet,
+  boltedServiceCover,
+  datumEnclosureAssembly,
+  snapLatchCoverAssembly,
+  pinnedLeverAssembly,
+  retainedShaftAssembly,
+  capturedLinearSlide,
+  capturedCartridgeGuideAssembly,
+  livingHingeCoverAssembly,
+  knuckledHingeAssembly,
+  clevisPinJointAssembly,
+  seatedBearingAssembly,
+  cableGlandAnchorAssembly,
+  hoseBarbPortAssembly,
+  routedTubeClipAssembly,
+  pcbTerminalBlockAssembly,
+  thumbScrewClampAssembly,
   pipeRoute,
   elbow,
   beltDrive,
@@ -52378,7 +54379,7 @@ function requireFinite$7(value, label) {
   }
   return value;
 }
-function requireVec3$2(value, label) {
+function requireVec3$3(value, label) {
   if (!Array.isArray(value) || value.length !== 3) {
     throw new Error(`${label} must be [x, y, z]`);
   }
@@ -52422,7 +54423,7 @@ function normalizeOptions(options) {
     out.size = requireFinite$7(options.size, "Viewport.label options.size");
     if (out.size <= 0) throw new Error("Viewport.label options.size must be positive");
   }
-  if (options.offset !== void 0) out.offset = requireVec3$2(options.offset, "Viewport.label options.offset");
+  if (options.offset !== void 0) out.offset = requireVec3$3(options.offset, "Viewport.label options.offset");
   if (options.anchor !== void 0) {
     if (!VALID_ANCHORS.has(options.anchor)) {
       throw new Error(`Viewport.label options.anchor must be one of: ${Array.from(VALID_ANCHORS).join(", ")}`);
@@ -52439,7 +54440,7 @@ function collectRenderLabel(text, at, options) {
   if (typeof text !== "string" || text.trim().length === 0) {
     throw new Error("Viewport.label text must be a non-empty string");
   }
-  const normalizedAt = requireVec3$2(at, "Viewport.label at");
+  const normalizedAt = requireVec3$3(at, "Viewport.label at");
   const normalizedOptions = normalizeOptions(options);
   _collected$4.push({
     id: `render-label-${_nextId++}`,
@@ -52634,7 +54635,7 @@ function requireFinite$6(value, label) {
   }
   return value;
 }
-function requireVec3$1(value, label) {
+function requireVec3$2(value, label) {
   if (!Array.isArray(value) || value.length !== 3) {
     throw new Error(`${label} must be [x, y, z]`);
   }
@@ -52662,9 +54663,9 @@ const VALID_ENVIRONMENT_PRESETS = /* @__PURE__ */ new Set([
 ]);
 function validateCamera(cam, label) {
   const out = {};
-  if (cam.position !== void 0) out.position = requireVec3$1(cam.position, `${label}.position`);
-  if (cam.target !== void 0) out.target = requireVec3$1(cam.target, `${label}.target`);
-  if (cam.up !== void 0) out.up = requireVec3$1(cam.up, `${label}.up`);
+  if (cam.position !== void 0) out.position = requireVec3$2(cam.position, `${label}.position`);
+  if (cam.target !== void 0) out.target = requireVec3$2(cam.target, `${label}.target`);
+  if (cam.up !== void 0) out.up = requireVec3$2(cam.up, `${label}.up`);
   if (cam.fov !== void 0) {
     out.fov = requireFinite$6(cam.fov, `${label}.fov`);
     if (out.fov <= 0 || out.fov >= 180) throw new Error(`${label}.fov must be between 0 and 180`);
@@ -52799,8 +54800,8 @@ function validateLight(light, label) {
   const out = { type: light.type };
   if (light.color !== void 0) out.color = requireColor(light.color, `${label}.color`);
   if (light.intensity !== void 0) out.intensity = requireFinite$6(light.intensity, `${label}.intensity`);
-  if (light.position !== void 0) out.position = requireVec3$1(light.position, `${label}.position`);
-  if (light.target !== void 0) out.target = requireVec3$1(light.target, `${label}.target`);
+  if (light.position !== void 0) out.position = requireVec3$2(light.position, `${label}.position`);
+  if (light.target !== void 0) out.target = requireVec3$2(light.target, `${label}.target`);
   if (light.groundColor !== void 0) out.groundColor = requireColor(light.groundColor, `${label}.groundColor`);
   if (light.skyColor !== void 0) out.skyColor = requireColor(light.skyColor, `${label}.skyColor`);
   if (light.angle !== void 0) out.angle = requireFinite$6(light.angle, `${label}.angle`);
@@ -54332,7 +56333,7 @@ function scale$1(v, s) {
 function dot$2(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
-function lerp$2(a2, b, t) {
+function lerp$4(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function frameMatrix$1(x2, y2, z2, p2) {
@@ -54343,7 +56344,7 @@ function axisVector(axis, sign2 = 1) {
   if (axis === "Y") return [0, sign2, 0];
   return [0, 0, sign2];
 }
-function axisPosition(axis, point2) {
+function axisPosition$1(axis, point2) {
   return point2[AXIS_INDEX[axis]];
 }
 function crossPointForStation(axis, point2) {
@@ -54351,7 +56352,7 @@ function crossPointForStation(axis, point2) {
   if (axis === "Y") return [point2[0], -point2[2]];
   return [point2[1], point2[2]];
 }
-function orientLoftToAxis(shape, axis) {
+function orientLoftToAxis$1(shape, axis) {
   if (axis === "Z") return shape;
   if (axis === "Y") return shape.rotateX(-90);
   return shape.transform([0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1]);
@@ -54408,9 +56409,9 @@ function interpolateQuery(a2, b, t) {
   }
   return {
     side: sideA,
-    u: lerp$2(a2.u ?? 0.5, b.u ?? 0.5, t),
-    v: lerp$2(a2.v ?? 0.5, b.v ?? 0.5, t),
-    offset: lerp$2(a2.offset ?? 0, b.offset ?? 0, t)
+    u: lerp$4(a2.u ?? 0.5, b.u ?? 0.5, t),
+    v: lerp$4(a2.v ?? 0.5, b.v ?? 0.5, t),
+    offset: lerp$4(a2.offset ?? 0, b.offset ?? 0, t)
   };
 }
 function resolvePathQueries(points) {
@@ -54477,8 +56478,8 @@ class ProductSkin {
     this.stations = stations;
     this.rails = rails;
     for (const [name2, query] of Object.entries(refs)) this.refQueries.set(name2, cloneQuery(query));
-    this.axisMin = Math.min(...stations.map((station) => axisPosition(axis, station.center)));
-    this.axisMax = Math.max(...stations.map((station) => axisPosition(axis, station.center)));
+    this.axisMin = Math.min(...stations.map((station) => axisPosition$1(axis, station.center)));
+    this.axisMax = Math.max(...stations.map((station) => axisPosition$1(axis, station.center)));
     this.diagnosticsValue = {
       ...diagnostics,
       stationNames: stations.map((station) => station.name),
@@ -54535,24 +56536,24 @@ class ProductSkin {
   }
   /** Interpolate center, width, and depth at a normalized v or absolute axis value. */
   stationAt(vOrAxis) {
-    const axisValue = vOrAxis >= 0 && vOrAxis <= 1 ? lerp$2(this.axisMin, this.axisMax, vOrAxis) : clamp$5(vOrAxis, this.axisMin, this.axisMax);
+    const axisValue = vOrAxis >= 0 && vOrAxis <= 1 ? lerp$4(this.axisMin, this.axisMax, vOrAxis) : clamp$5(vOrAxis, this.axisMin, this.axisMax);
     const sorted = this.stations;
     for (let index2 = 0; index2 < sorted.length - 1; index2 += 1) {
       const a2 = sorted[index2];
       const b = sorted[index2 + 1];
-      const aAxis = axisPosition(this.axis, a2.center);
-      const bAxis = axisPosition(this.axis, b.center);
+      const aAxis = axisPosition$1(this.axis, a2.center);
+      const bAxis = axisPosition$1(this.axis, b.center);
       if (axisValue < aAxis - EPS$5 || axisValue > bAxis + EPS$5) continue;
       const span = Math.max(EPS$5, bAxis - aAxis);
       const t = clamp$5((axisValue - aAxis) / span, 0, 1);
       return {
         axisValue,
-        center: [lerp$2(a2.center[0], b.center[0], t), lerp$2(a2.center[1], b.center[1], t), lerp$2(a2.center[2], b.center[2], t)],
-        width: lerp$2(a2.profile.width, b.profile.width, t),
-        depth: lerp$2(a2.profile.depth, b.profile.depth, t),
+        center: [lerp$4(a2.center[0], b.center[0], t), lerp$4(a2.center[1], b.center[1], t), lerp$4(a2.center[2], b.center[2], t)],
+        width: lerp$4(a2.profile.width, b.profile.width, t),
+        depth: lerp$4(a2.profile.depth, b.profile.depth, t),
         dWidth: (b.profile.width - a2.profile.width) / span,
         dDepth: (b.profile.depth - a2.profile.depth) / span,
-        exponent: lerp$2(profileExponent(a2), profileExponent(b), t),
+        exponent: lerp$4(profileExponent(a2), profileExponent(b), t),
         kind: a2.profile.kind === b.profile.kind ? a2.profile.kind : "custom"
       };
     }
@@ -54674,7 +56675,7 @@ class ProductSkinBuilder {
   }
   /** Set named cross-section stations for the product skin. */
   stations(stations) {
-    this.stationsValue = stations.map(toStationSpec).sort((a2, b) => axisPosition(this.axisValue, a2.center) - axisPosition(this.axisValue, b.center));
+    this.stationsValue = stations.map(toStationSpec).sort((a2, b) => axisPosition$1(this.axisValue, a2.center) - axisPosition$1(this.axisValue, b.center));
     return this;
   }
   /** Attach named guide rails for product-skin construction and downstream surface references. */
@@ -54724,9 +56725,9 @@ class ProductSkinBuilder {
       const [x2, y2] = crossPointForStation(this.axisValue, station.center);
       return station.profile.sketch.translate(x2, y2);
     });
-    const heights = this.stationsValue.map((station) => axisPosition(this.axisValue, station.center));
+    const heights = this.stationsValue.map((station) => axisPosition$1(this.axisValue, station.center));
     let shape = loft(localProfiles, heights, { edgeLength: this.edgeLengthValue });
-    shape = orientLoftToAxis(shape, this.axisValue);
+    shape = orientLoftToAxis$1(shape, this.axisValue);
     if (this.colorValue) shape = shape.color(this.colorValue);
     shape = applyMaterial(shape, this.materialValue).as(this.name);
     const warnings = [];
@@ -55385,7 +57386,7 @@ function requirePositive$3(value, label) {
 function clamp$4(value, min2, max2) {
   return Math.max(min2, Math.min(max2, value));
 }
-function lerp$1(a2, b, t) {
+function lerp$3(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function add(a2, b) {
@@ -55435,19 +57436,19 @@ function transformLocal(point2, tangentAcross, normal, tangentAlong, x2, y2, z2
 function interpolateCylinder(a2, b, t, mode) {
   let delta = b.angle - a2.angle;
   if (mode === "shortest" && Math.abs(delta) > 180) delta -= Math.sign(delta) * 360;
-  return { kind: "cylinder", angle: a2.angle + delta * t, z: lerp$1(a2.z, b.z, t), offset: lerp$1(a2.offset ?? 0, b.offset ?? 0, t) };
+  return { kind: "cylinder", angle: a2.angle + delta * t, z: lerp$3(a2.z, b.z, t), offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t) };
 }
 function interpolatePlane(a2, b, t) {
-  return { kind: "plane", x: lerp$1(a2.x, b.x, t), y: lerp$1(a2.y, b.y, t), offset: lerp$1(a2.offset ?? 0, b.offset ?? 0, t) };
+  return { kind: "plane", x: lerp$3(a2.x, b.x, t), y: lerp$3(a2.y, b.y, t), offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t) };
 }
 function interpolateProductSkin(a2, b, t) {
   if ((a2.side ?? b.side) !== (b.side ?? a2.side)) throw new Error("SurfacePath on ProductSkin currently supports one side per path; split side transitions into separate members.");
   return {
     kind: "productSkin",
     side: a2.side ?? b.side,
-    u: lerp$1(a2.u ?? 0.5, b.u ?? 0.5, t),
-    v: lerp$1(a2.v ?? 0.5, b.v ?? 0.5, t),
-    offset: lerp$1(a2.offset ?? 0, b.offset ?? 0, t)
+    u: lerp$3(a2.u ?? 0.5, b.u ?? 0.5, t),
+    v: lerp$3(a2.v ?? 0.5, b.v ?? 0.5, t),
+    offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t)
   };
 }
 class SurfacePath {
@@ -55770,11 +57771,11 @@ function coordinateOnSide(coordinate, side, label) {
   return { ...coordinate, kind: "productSkin", side };
 }
 class ProductSkinCarrier {
-  constructor(skin, name = skin.name, sideValue, offsetValue = 0) {
+  constructor(skin, name = skin.name, sideValue2, offsetValue = 0) {
     __publicField(this, "kind", "productSkin");
     this.skin = skin;
     this.name = name;
-    this.sideValue = sideValue;
+    this.sideValue = sideValue2;
     this.offsetValue = offsetValue;
   }
   surface(side) {
@@ -56545,7 +58546,7 @@ function counterboresForPlate(spec2, width, height, thickness, diagnostics) {
 function minWidthAcrossAlongRange(widthAtT, length4, minAlong, maxAlong) {
   let minWidth = Number.POSITIVE_INFINITY;
   for (let index2 = 0; index2 <= 8; index2 += 1) {
-    const along = lerp$1(minAlong, maxAlong, index2 / 8);
+    const along = lerp$3(minAlong, maxAlong, index2 / 8);
     const t = Math.max(0, Math.min(1, (along + length4 / 2) / Math.max(length4, 1e-8)));
     minWidth = Math.min(minWidth, widthAtT(t));
   }
@@ -56845,7 +58846,7 @@ function pathParameterAtDistance(samples, distance2) {
     const segmentLength = Math.hypot(b.point[0] - a2.point[0], b.point[1] - a2.point[1], b.point[2] - a2.point[2]);
     if (traveled + segmentLength >= distance2) {
       const localT = segmentLength <= 1e-8 ? 0 : (distance2 - traveled) / segmentLength;
-      return lerp$1(a2.t, b.t, localT);
+      return lerp$3(a2.t, b.t, localT);
     }
     traveled += segmentLength;
   }
@@ -56898,7 +58899,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex <= acrossSegments; acrossIndex += 1) {
-      const across = lerp$1(-width / 2, width / 2, acrossIndex / acrossSegments);
+      const across = lerp$3(-width / 2, width / 2, acrossIndex / acrossSegments);
       mesh.vertices.push(pointAtProfile([across, along], false));
     }
   }
@@ -56908,7 +58909,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex <= acrossSegments; acrossIndex += 1) {
-      const across = lerp$1(-width / 2, width / 2, acrossIndex / acrossSegments);
+      const across = lerp$3(-width / 2, width / 2, acrossIndex / acrossSegments);
       mesh.vertices.push(pointAtProfile([across, along], true));
     }
   }
@@ -56920,7 +58921,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex < acrossSegments; acrossIndex += 1) {
-      const across = lerp$1(-width / 2, width / 2, (acrossIndex + 0.5) / acrossSegments);
+      const across = lerp$3(-width / 2, width / 2, (acrossIndex + 0.5) / acrossSegments);
       filled[alongIndex][acrossIndex] = !holes.some((hole2) => pointInProfileLoop([across, along], hole2));
     }
   }
@@ -59002,7 +61003,7 @@ const Constraint = {
     return builder.constrain({ type: "length", line: resolveLineId(builder, line2), value });
   }
 };
-function requireVec3(v, label) {
+function requireVec3$1(v, label) {
   if (!Array.isArray(v) || v.length !== 3 || !Number.isFinite(v[0]) || !Number.isFinite(v[1]) || !Number.isFinite(v[2])) {
     throw new Error(`${label} must be a [number, number, number] with finite values, got ${JSON.stringify(v)}`);
   }
@@ -59015,24 +61016,24 @@ function requireFiniteNumber(n, label) {
   return n;
 }
 function distance$1(a2, b) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   return Math.hypot(b[0] - a2[0], b[1] - a2[1], b[2] - a2[2]);
 }
 function midpoint$1(a2, b) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   return [(a2[0] + b[0]) / 2, (a2[1] + b[1]) / 2, (a2[2] + b[2]) / 2];
 }
-function lerp(a2, b, t) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+function lerp$2(a2, b, t) {
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   requireFiniteNumber(t, "t");
   return [a2[0] + (b[0] - a2[0]) * t, a2[1] + (b[1] - a2[1]) * t, a2[2] + (b[2] - a2[2]) * t];
 }
 function direction(a2, b) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   const dx = b[0] - a2[0];
   const dy = b[1] - a2[1];
   const dz = b[2] - a2[2];
@@ -59043,8 +61044,8 @@ function direction(a2, b) {
   return [dx / len2, dy / len2, dz / len2];
 }
 function offset(point2, dir, amount) {
-  requireVec3(point2, "point");
-  requireVec3(dir, "dir");
+  requireVec3$1(point2, "point");
+  requireVec3$1(dir, "dir");
   requireFiniteNumber(amount, "amount");
   return [point2[0] + dir[0] * amount, point2[1] + dir[1] * amount, point2[2] + dir[2] * amount];
 }
@@ -59054,7 +61055,7 @@ const Points = {
   /** Center point between two 3D points. */
   midpoint: midpoint$1,
   /** Linearly interpolate between two 3D points. t=0 returns a, t=1 returns b. */
-  lerp,
+  lerp: lerp$2,
   /** Unit direction vector from a to b. Throws if a and b are the same point. */
   direction,
   /** Move a point along a direction vector by a given amount. */
@@ -64186,9 +66187,84 @@ class ConstraintSketch extends Sketch {
    * Select the single arrangement region that contains the given seed point.
    * Throws if no region contains the seed.
    */
-  detectArrangementRegion(seed) {
+  detectArrangementRegion(_seed) {
     throw new Error("Not implemented");
   }
+  /**
+   * Return the solved constrained path as a sampled 2D polyline.
+   *
+   * Use this when a construction rail was authored with `constrainedSketch()`
+   * and should feed another operation such as `Loft.pathOnXz(...)`.
+   * The sketch must contain exactly one profile path.
+   *
+   * @param samples - Samples per curved segment. Default 32.
+   * @returns The solved path as an open polyline.
+   */
+  toPolyline(samples = 32) {
+    if (!Number.isFinite(samples) || samples < 2) throw new Error("ConstraintSketch.toPolyline() samples must be at least 2");
+    const profileLoops = this.definition.loops.filter((loop) => loop.type === "profile");
+    if (profileLoops.length !== 1) {
+      throw new Error("ConstraintSketch.toPolyline() requires exactly one profile path");
+    }
+    const sampleCount = Math.max(2, Math.round(samples));
+    const pointMap = new Map(this.definition.points.map((point2) => [point2.id, point2]));
+    const lineMap = new Map(this.definition.lines.map((line2) => [line2.id, line2]));
+    const arcMap = new Map(this.definition.arcs.map((arc) => [arc.id, arc]));
+    const bezierMap = new Map(this.definition.beziers.map((bezier) => [bezier.id, bezier]));
+    const points = [];
+    const appendStart = (point2, label) => {
+      const previous = points[points.length - 1];
+      if (!previous) {
+        points.push(point2);
+        return;
+      }
+      if (Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-6) {
+        throw new Error(`ConstraintSketch.toPolyline() profile path is not continuous at ${label}`);
+      }
+    };
+    const appendPoint = (point2) => {
+      const previous = points[points.length - 1];
+      if (!previous || Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-9) points.push(point2);
+    };
+    const requirePoint = (id, label) => {
+      const point2 = pointMap.get(id);
+      if (!point2) throw new Error(`ConstraintSketch.toPolyline() missing ${label}`);
+      return [point2.x, point2.y];
+    };
+    for (const segment of profileLoops[0].segments) {
+      if (segment.kind === "line") {
+        const line2 = lineMap.get(segment.line);
+        if (!line2) throw new Error(`ConstraintSketch.toPolyline() missing line "${segment.line}"`);
+        appendStart(requirePoint(line2.a, `line "${segment.line}" start point`), `line "${segment.line}"`);
+        appendPoint(requirePoint(line2.b, `line "${segment.line}" end point`));
+      } else if (segment.kind === "arc") {
+        const arc = arcMap.get(segment.arc);
+        if (!arc) throw new Error(`ConstraintSketch.toPolyline() missing arc "${segment.arc}"`);
+        const center = requirePoint(arc.center, `arc "${segment.arc}" center point`);
+        const start = requirePoint(arc.start, `arc "${segment.arc}" start point`);
+        const end = requirePoint(arc.end, `arc "${segment.arc}" end point`);
+        appendStart(start, `arc "${segment.arc}"`);
+        const startAngle = Math.atan2(start[1] - center[1], start[0] - center[0]);
+        const endAngle = Math.atan2(end[1] - center[1], end[0] - center[0]);
+        for (const point2 of tessellateArc(center[0], center[1], arc.radius, startAngle, endAngle, arc.clockwise, sampleCount)) {
+          appendPoint(point2);
+        }
+      } else {
+        const bezier = bezierMap.get(segment.bezier);
+        if (!bezier) throw new Error(`ConstraintSketch.toPolyline() missing bezier "${segment.bezier}"`);
+        const p0 = requirePoint(bezier.p0, `bezier "${segment.bezier}" start point`);
+        const p1 = requirePoint(bezier.p1, `bezier "${segment.bezier}" first control point`);
+        const p2 = requirePoint(bezier.p2, `bezier "${segment.bezier}" second control point`);
+        const p3 = requirePoint(bezier.p3, `bezier "${segment.bezier}" end point`);
+        appendStart(p0, `bezier "${segment.bezier}"`);
+        for (const point2 of tessellateBezier(p0[0], p0[1], p1[0], p1[1], p2[0], p2[1], p3[0], p3[1], sampleCount)) {
+          appendPoint(point2);
+        }
+      }
+    }
+    if (points.length < 2) throw new Error("ConstraintSketch.toPolyline() needs at least 2 points");
+    return points;
+  }
   /**
    * Re-solve the sketch after changing the value of one existing constraint.
    *
@@ -79473,6 +81549,295 @@ function polygonVertices(sides, radius, options) {
     centerY: options == null ? void 0 : options.centerY
   });
 }
+const LOFT_GUIDE_EPS = 1e-8;
+function orientLoftToAxis(shape, axis) {
+  if (axis === "Z") return shape;
+  if (axis === "Y") return shape.rotateX(-90);
+  return shape.transform([0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1]);
+}
+function buildRailEvaluators(rails, axis, start, end, railSamples) {
+  const seen = /* @__PURE__ */ new Set();
+  return rails.map((rail2) => {
+    if (seen.has(rail2.side)) throw new Error(`Loft.withGuideRails() received more than one ${rail2.side} rail`);
+    seen.add(rail2.side);
+    const sampled = sampleRailPath(rail2.path, railSamples);
+    if (sampled.length < 2) throw new Error("Loft guide rails require at least two points");
+    const points = sampled.map((point2) => ({ position: axisPosition(axis, point2), cross: crossPointForAxis(axis, point2) }));
+    const ordered = points[points.length - 1].position >= points[0].position ? points : [...points].reverse();
+    validateRailCoverage(ordered, start, end);
+    return { side: rail2.side, points: ordered };
+  });
+}
+function railCrossAt(rail2, position) {
+  const points = rail2.points;
+  if (position <= points[0].position + LOFT_GUIDE_EPS) return points[0].cross;
+  const last = points[points.length - 1];
+  if (position >= last.position - LOFT_GUIDE_EPS) return last.cross;
+  for (let index2 = 0; index2 < points.length - 1; index2 += 1) {
+    const a2 = points[index2];
+    const b = points[index2 + 1];
+    if (position >= a2.position - LOFT_GUIDE_EPS && position <= b.position + LOFT_GUIDE_EPS) {
+      const t = (position - a2.position) / (b.position - a2.position);
+      return [lerp$1(a2.cross[0], b.cross[0], t), lerp$1(a2.cross[1], b.cross[1], t)];
+    }
+  }
+  throw new Error("Loft guide rail does not cover requested station position");
+}
+function validateRailCoverage(points, start, end) {
+  for (let index2 = 1; index2 < points.length; index2 += 1) {
+    if (points[index2].position - points[index2 - 1].position < LOFT_GUIDE_EPS) {
+      throw new Error("Loft guide rails must be monotone along the loft axis");
+    }
+  }
+  if (points[0].position - start > LOFT_GUIDE_EPS || end - points[points.length - 1].position > LOFT_GUIDE_EPS) {
+    throw new Error("Loft guide rails must cover the full station range");
+  }
+}
+function sampleRailPath(path2, samples) {
+  if (Array.isArray(path2)) return path2.map((point2, index2) => requireVec3(point2, `Loft guide rail point ${index2}`));
+  if (path2 instanceof Curve3D || path2 instanceof HermiteCurve3D || path2 instanceof QuinticHermiteCurve3D || path2 instanceof NurbsCurve3D) {
+    return path2.sample(Math.max(2, Math.round(samples))).map((point2, index2) => requireVec3(point2, `Loft guide rail sample ${index2}`));
+  }
+  throw new Error("Loft guide rail path must be a Vec3[] or ForgeCAD 3D curve");
+}
+function requireVec3(point2, label) {
+  if (!Array.isArray(point2) || point2.length !== 3 || !point2.every(Number.isFinite)) {
+    throw new Error(`${label} must be a finite [x, y, z] point`);
+  }
+  return [point2[0], point2[1], point2[2]];
+}
+function axisPosition(axis, point2) {
+  if (axis === "X") return point2[0];
+  if (axis === "Y") return point2[1];
+  return point2[2];
+}
+function crossPointForAxis(axis, point2) {
+  if (axis === "X") return [point2[1], point2[2]];
+  if (axis === "Y") return [point2[0], -point2[2]];
+  return [point2[0], point2[1]];
+}
+function lerp$1(a2, b, t) {
+  return a2 + (b - a2) * t;
+}
+function loftWithGuideRails(stations, rails, options = {}) {
+  if (stations.length < 2) throw new Error("Loft.withGuideRails() requires at least two stations");
+  if (rails.length === 0) throw new Error("Loft.withGuideRails() requires at least one guide rail");
+  const sortedStations = sortedValidStations(stations);
+  const axis = options.axis ?? "Z";
+  const start = sortedStations[0].position;
+  const end = sortedStations[sortedStations.length - 1].position;
+  const railEvaluators = buildRailEvaluators(rails, axis, start, end, options.railSamples ?? 64);
+  const positions = generatedPositions(sortedStations, options.samples);
+  const profiles2 = positions.map((position) => {
+    const source = profileForPosition(sortedStations, position);
+    const bounds = boundsForPosition(sortedStations, position);
+    return fitProfileToBounds(source, applyRailsToBounds(bounds, railEvaluators, position));
+  });
+  const shape = loft(profiles2, positions, {
+    edgeLength: options.edgeLength,
+    boundsPadding: options.boundsPadding
+  });
+  return orientLoftToAxis(shape, axis);
+}
+function sortedValidStations(stations) {
+  const sorted = [...stations].sort((a2, b) => a2.position - b.position);
+  for (let index2 = 0; index2 < sorted.length; index2 += 1) {
+    if (!Number.isFinite(sorted[index2].position)) throw new Error("Loft.withGuideRails station position must be finite");
+    if (!(sorted[index2].profile instanceof Sketch)) throw new Error("Loft.withGuideRails() stations must use Sketch profiles");
+    if (index2 > 0 && sorted[index2].position - sorted[index2 - 1].position < LOFT_GUIDE_EPS) {
+      throw new Error("Loft.withGuideRails() requires unique, strictly increasing station positions");
+    }
+  }
+  return sorted;
+}
+function generatedPositions(stations, samples) {
+  const count = Math.max(2, Math.round(samples ?? Math.max(9, (stations.length - 1) * 8 + 1)));
+  const start = stations[0].position;
+  const end = stations[stations.length - 1].position;
+  const values = /* @__PURE__ */ new Set();
+  const positions = [];
+  const addPosition = (position) => {
+    const key = position.toFixed(9);
+    if (!values.has(key)) {
+      values.add(key);
+      positions.push(position);
+    }
+  };
+  for (let index2 = 0; index2 < count; index2 += 1) addPosition(start + (end - start) * index2 / (count - 1));
+  for (const station of stations) addPosition(station.position);
+  return positions.sort((a2, b) => a2 - b);
+}
+function profileForPosition(stations, position) {
+  for (let index2 = 0; index2 < stations.length - 1; index2 += 1) {
+    if (position <= stations[index2 + 1].position + LOFT_GUIDE_EPS) return stations[index2].profile;
+  }
+  return stations[stations.length - 1].profile;
+}
+function boundsForPosition(stations, position) {
+  if (position <= stations[0].position + LOFT_GUIDE_EPS) return sketchBounds(stations[0].profile);
+  const last = stations[stations.length - 1];
+  if (position >= last.position - LOFT_GUIDE_EPS) return sketchBounds(last.profile);
+  for (let index2 = 0; index2 < stations.length - 1; index2 += 1) {
+    const a2 = stations[index2];
+    const b = stations[index2 + 1];
+    if (position >= a2.position - LOFT_GUIDE_EPS && position <= b.position + LOFT_GUIDE_EPS) {
+      return lerpBounds(sketchBounds(a2.profile), sketchBounds(b.profile), (position - a2.position) / (b.position - a2.position));
+    }
+  }
+  return sketchBounds(last.profile);
+}
+function applyRailsToBounds(bounds, rails, position) {
+  const centerRail = rails.find((rail2) => rail2.side === "center");
+  const center = centerRail ? railCrossAt(centerRail, position) : void 0;
+  const next = { ...bounds };
+  applyAxisRail(next, "X", sideValue(rails, "left", position, 0), sideValue(rails, "right", position, 0), center == null ? void 0 : center[0]);
+  applyAxisRail(next, "Y", sideValue(rails, "back", position, 1), sideValue(rails, "front", position, 1), center == null ? void 0 : center[1]);
+  if (next.maxX - next.minX < LOFT_GUIDE_EPS || next.maxY - next.minY < LOFT_GUIDE_EPS) {
+    throw new Error("Loft.withGuideRails() guide rails produced a non-positive section size");
+  }
+  return next;
+}
+function sideValue(rails, side, position, crossIndex) {
+  const rail2 = rails.find((entry) => entry.side === side);
+  return rail2 ? railCrossAt(rail2, position)[crossIndex] : void 0;
+}
+function applyAxisRail(bounds, axis, minRail, maxRail, center) {
+  const minKey = axis === "X" ? "minX" : "minY";
+  const maxKey = axis === "X" ? "maxX" : "maxY";
+  const width = bounds[maxKey] - bounds[minKey];
+  if (minRail != null && maxRail != null) {
+    if (maxRail - minRail < LOFT_GUIDE_EPS) throw new Error("Loft.withGuideRails() opposite guide rails crossed");
+    if (center != null && Math.abs((minRail + maxRail) / 2 - center) > 1e-5) {
+      throw new Error("Loft.withGuideRails() center rail conflicts with opposite side rails");
+    }
+    bounds[minKey] = minRail;
+    bounds[maxKey] = maxRail;
+  } else if (maxRail != null) {
+    bounds[maxKey] = maxRail;
+    bounds[minKey] = center != null ? 2 * center - maxRail : maxRail - width;
+  } else if (minRail != null) {
+    bounds[minKey] = minRail;
+    bounds[maxKey] = center != null ? 2 * center - minRail : minRail + width;
+  } else if (center != null) {
+    bounds[minKey] = center - width / 2;
+    bounds[maxKey] = center + width / 2;
+  }
+}
+function fitProfileToBounds(profile, target) {
+  const source = sketchBounds(profile);
+  const sourceWidth = source.maxX - source.minX;
+  const sourceDepth = source.maxY - source.minY;
+  if (sourceWidth < LOFT_GUIDE_EPS || sourceDepth < LOFT_GUIDE_EPS) {
+    throw new Error("Loft.withGuideRails() station profiles must have positive bounds");
+  }
+  const sourceCenter = [(source.minX + source.maxX) / 2, (source.minY + source.maxY) / 2];
+  const targetCenter = [(target.minX + target.maxX) / 2, (target.minY + target.maxY) / 2];
+  return profile.scaleAround(sourceCenter, [(target.maxX - target.minX) / sourceWidth, (target.maxY - target.minY) / sourceDepth]).translate(targetCenter[0] - sourceCenter[0], targetCenter[1] - sourceCenter[1]);
+}
+function sketchBounds(profile) {
+  const bounds = profile.bounds();
+  return { minX: bounds.min[0], maxX: bounds.max[0], minY: bounds.min[1], maxY: bounds.max[1] };
+}
+function lerpBounds(a2, b, t) {
+  return {
+    minX: lerp(a2.minX, b.minX, t),
+    maxX: lerp(a2.maxX, b.maxX, t),
+    minY: lerp(a2.minY, b.minY, t),
+    maxY: lerp(a2.maxY, b.maxY, t)
+  };
+}
+function lerp(a2, b, t) {
+  return a2 + (b - a2) * t;
+}
+function mapLoftPath2D(path2, label, mapper) {
+  const points = sampleLoftPath2D(path2, label);
+  return points.map((point2, index2) => {
+    if (!Array.isArray(point2) || point2.length !== 2 || !point2.every(Number.isFinite)) {
+      throw new Error(`${label} point ${index2} must be a finite [x, y] point`);
+    }
+    return mapper([point2[0], point2[1]]);
+  });
+}
+function sampleLoftPath2D(path2, label) {
+  if (Array.isArray(path2)) {
+    if (path2.length < 2) throw new Error(`${label} requires at least two [x, y] points`);
+    return path2;
+  }
+  if (!path2 || typeof path2 !== "object" || typeof path2.toPolyline !== "function") {
+    throw new Error(`${label} requires a 2D path, solved constrained path, or [x, y] point array`);
+  }
+  const points = path2.toPolyline();
+  if (!Array.isArray(points) || points.length < 2) throw new Error(`${label} path must produce at least two [x, y] points`);
+  return points;
+}
+const Loft = {
+  /** Create a loft station from a 2D profile and an axis position. */
+  station(profile, position) {
+    if (!Number.isFinite(position)) throw new Error("Loft.station position must be finite");
+    return { profile, position };
+  },
+  /** Create a guide rail that constrains the section-local negative-X side. */
+  leftRail(path2) {
+    return { side: "left", path: path2 };
+  },
+  /** Create a guide rail that constrains the section-local positive-X side. */
+  rightRail(path2) {
+    return { side: "right", path: path2 };
+  },
+  /** Create a guide rail that constrains the section-local positive-Y side. */
+  frontRail(path2) {
+    return { side: "front", path: path2 };
+  },
+  /** Create a guide rail that constrains the section-local negative-Y side. */
+  backRail(path2) {
+    return { side: "back", path: path2 };
+  },
+  /** Create a guide rail that moves section centers along the loft. */
+  centerRail(path2) {
+    return { side: "center", path: path2 };
+  },
+  /**
+   * Place a 2D guide path onto the XZ plane.
+   *
+   * The path's first coordinate becomes X and its second coordinate becomes Z.
+   * Use this for left/right silhouette rails authored with `path()` or `constrainedSketch()`.
+   */
+  pathOnXz(path2, y2 = 0) {
+    if (!Number.isFinite(y2)) throw new Error("Loft.pathOnXz y must be finite");
+    return mapLoftPath2D(path2, "Loft.pathOnXz", ([x2, z2]) => [x2, y2, z2]);
+  },
+  /**
+   * Place a 2D guide path onto the YZ plane.
+   *
+   * The path's first coordinate becomes Y and its second coordinate becomes Z.
+   * Use this for front/back crown rails authored with `path()` or `constrainedSketch()`.
+   */
+  pathOnYz(path2, x2 = 0) {
+    if (!Number.isFinite(x2)) throw new Error("Loft.pathOnYz x must be finite");
+    return mapLoftPath2D(path2, "Loft.pathOnYz", ([y2, z2]) => [x2, y2, z2]);
+  },
+  /**
+   * Place a 2D guide path onto the XY plane.
+   *
+   * The path's first coordinate becomes X and its second coordinate becomes Y.
+   * Use this when lofting along X or Y and a rail lives in a horizontal sketch plane.
+   */
+  pathOnXy(path2, z2 = 0) {
+    if (!Number.isFinite(z2)) throw new Error("Loft.pathOnXy z must be finite");
+    return mapLoftPath2D(path2, "Loft.pathOnXy", ([x2, y2]) => [x2, y2, z2]);
+  },
+  /**
+   * Loft through profile stations while forcing generated sections to follow guide rails.
+   *
+   * Stations define the cross-section family. Guide rails define the side or center
+   * paths the loft must pass through. With opposite side rails, the section is scaled
+   * to touch both rails. With one side rail, the section keeps its interpolated size
+   * unless a center rail is also present.
+   */
+  withGuideRails(stations, rails, options = {}) {
+    return loftWithGuideRails(stations, rails, options);
+  }
+};
 let collectedHighlights = [];
 function resetHighlights() {
   collectedHighlights = [];
@@ -84149,10 +86514,14 @@ function spec(name, checkFn) {
   };
 }
 let _collected = [];
+let _collisionAllowances = [];
+let _physicalComponentExpectations = [];
 let _counter = 0;
 let _activeGroup = null;
 function resetVerifications() {
   _collected = [];
+  _collisionAllowances = [];
+  _physicalComponentExpectations = [];
   _counter = 0;
 }
 function getCollectedVerifications() {
@@ -84186,15 +86555,35 @@ function push(result) {
 function roundNum(n, digits = 4) {
   return Number.isFinite(n) ? n.toFixed(digits).replace(/\.?0+$/, "") : String(n);
 }
+function meshDerivedManifoldBackend(shape) {
+  const mesh = getShapeRuntimeBackend(shape).getMesh();
+  return reconstructBackendFromMesh({
+    numProp: mesh.numProp,
+    triVerts: mesh.triVerts,
+    vertProperties: mesh.vertProperties,
+    mergeFromVert: mesh.mergeFromVert ?? new Uint32Array(),
+    mergeToVert: mesh.mergeToVert ?? new Uint32Array()
+  });
+}
+function backendForMinGap(shape) {
+  const backend = getShapeRuntimeBackend(shape);
+  if (isManifoldCapableBackend(backend)) return { backend, method: "exact", dispose: false };
+  return { backend: meshDerivedManifoldBackend(shape), method: "mesh-derived", dispose: true };
+}
 function computeMinGap(a2, b, searchLength) {
-  const backendA = getShapeRuntimeBackend(a2);
-  const backendB = getShapeRuntimeBackend(b);
-  if (!isManifoldCapableBackend(backendA)) {
-    throw new Error("notColliding/minClearance require Manifold-backed shapes");
+  const backendA = backendForMinGap(a2);
+  const backendB = backendForMinGap(b);
+  try {
+    const manifoldA = requireManifoldShapeBackend(backendA.backend, "verification.minGap");
+    const manifoldB = requireManifoldShapeBackend(backendB.backend, "verification.minGap");
+    return {
+      gap: manifoldA.minGap(manifoldB, searchLength),
+      method: backendA.method === "exact" && backendB.method === "exact" ? "exact" : "mesh-derived"
+    };
+  } finally {
+    if (backendA.dispose) disposeShapeBackend(backendA.backend);
+    if (backendB.dispose) disposeShapeBackend(backendB.backend);
   }
-  const manifoldA = backendA.requireManifold("verification.minGap");
-  const manifoldB = requireManifoldShapeBackend(backendB, "verification.minGap");
-  return manifoldA.minGap(manifoldB, searchLength);
 }
 function vec3Dot(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
@@ -84329,8 +86718,143 @@ const verify = {
         actual: `${roundNum(d2, 3)} mm`
       });
     } catch (e) {
-      push({ id: nextId(), label, status: "fail", message: `Error: ${e instanceof Error ? e.message : String(e)}`, line: line2 });
+      push({
+        id: nextId(),
+        label,
+        kind: "interface",
+        status: "fail",
+        message: `Error: ${e instanceof Error ? e.message : String(e)}`,
+        line: line2
+      });
+    }
+  },
+  /**
+   * Check the distance between two named connectors on a shape or group.
+   *
+   * Use this when connectors + `matchTo()` define a static assembly interface.
+   * It proves the mate at runtime, unlike a plain source-level connector
+   * declaration. The common case is `expected = 0`, meaning the two connector
+   * origins should coincide after placement.
+   *
+   * **Example**
+   *
+   * ```ts
+   * verify.connectorDistance("leg is seated", bench, "Rail.leg_0", "Leg0.head", 0, 0.01);
+   * ```
+   */
+  connectorDistance(label, target, connectorA, connectorB, expected = 0, tolerance = 0.01) {
+    const line2 = captureSourceLine();
+    try {
+      const actual = target.connectorDistance(connectorA, connectorB);
+      const diff = Math.abs(actual - expected);
+      const passed = diff <= Math.abs(tolerance);
+      push({
+        id: nextId(),
+        label,
+        kind: "interface",
+        status: passed ? "pass" : "fail",
+        message: passed ? `Connector distance ${roundNum(actual, 4)} mm ≈ ${roundNum(expected, 4)} mm` : `Connector distance ${roundNum(actual, 4)} mm is outside ${roundNum(expected, 4)} ± ${roundNum(tolerance, 4)} mm`,
+        line: passed ? void 0 : line2,
+        expected: `${roundNum(expected, 4)} ± ${roundNum(tolerance, 4)} mm`,
+        actual: `${roundNum(actual, 4)} mm`
+      });
+    } catch (e) {
+      push({
+        id: nextId(),
+        label,
+        kind: "interface",
+        status: "fail",
+        message: `Error: ${e instanceof Error ? e.message : String(e)}`,
+        line: line2
+      });
+    }
+  },
+  /**
+   * Declare the expected physical connectivity component count for the returned visible model.
+   *
+   * **Details**
+   *
+   * Use this for generated mechanical models that should have a clear component graph:
+   * one connected fixture, a purchased part plus a removable cartridge, a root assembly plus
+   * named intentional ghosts, and so on. `forgecad inspect mechanical-integrity` resolves the returned
+   * visible objects with the same physical-connectivity analysis used in the quality gate and
+   * fails if the actual component count differs.
+   *
+   * This catches the common generated-CAD failure where a script returns a visually plausible
+   * artifact but the handle, screw, washer, cover, or terminal block is actually a separate island.
+   *
+   * **Example**
+   *
+   * ```ts
+   * verify.physicalComponentCount("vise is one connected installed assembly", 1);
+   * ```
+   */
+  physicalComponentCount(label, expected) {
+    const line2 = captureSourceLine();
+    const id = nextId();
+    if (!Number.isInteger(expected) || expected < 0) {
+      push({
+        id,
+        label,
+        kind: "interface",
+        status: "fail",
+        message: "Expected physical component count must be a non-negative integer",
+        line: line2
+      });
+      return;
     }
+    _physicalComponentExpectations.push({ id, label, expected, line: line2 });
+    push({
+      id,
+      label,
+      kind: "interface",
+      status: "pass",
+      message: `Expected ${expected} physical component(s); checked by mechanical-integrity connectivity`
+    });
+  },
+  /**
+   * Declare that two visible objects intentionally overlap because the overlap is real manufacturing intent.
+   *
+   * **Details**
+   *
+   * Use this only for overlaps that a mechanical reviewer would accept as actual matter sharing volume:
+   * welded/fused regions, overmolded inserts, potted electronics, cast-in hardware, or deliberately
+   * bonded laminations. This is not a shortcut for screws without holes, shafts without bores, covers
+   * without pockets, or parts placed with collision as a positioning hack.
+   *
+   * `forgecad inspect mechanical-integrity --collisions` only honors this declaration when both shapes are
+   * returned as visible objects and the exact collision report finds that same object pair. Unused or
+   * non-visible declarations fail the quality gate so annotations cannot hide unrelated collisions.
+   *
+   * **Example**
+   *
+   * ```ts
+   * verify.intentionalOverlap("rubber grip is overmolded on handle", rubberGrip, handleCore, "overmolded insert");
+   * ```
+   */
+  intentionalOverlap(label, a2, b, reason) {
+    const line2 = captureSourceLine();
+    const id = nextId();
+    const trimmedReason = String(reason ?? "").trim();
+    if (trimmedReason.length === 0) {
+      push({
+        id,
+        label,
+        kind: "interface",
+        status: "fail",
+        message: "Intentional overlap requires a manufacturing reason",
+        line: line2
+      });
+      return;
+    }
+    _collisionAllowances.push({ id, label, reason: trimmedReason, a: a2, b, line: line2 });
+    push({
+      id,
+      label,
+      kind: "interface",
+      status: "pass",
+      message: `Intentional overlap declared: ${trimmedReason}`
+    });
   },
   /**
    * Check that two shapes do not collide (minGap > 0).
@@ -84340,19 +86864,28 @@ const verify = {
   notColliding(label, a2, b, searchLength = 1) {
     const line2 = captureSourceLine();
     try {
-      const gap = computeMinGap(a2, b, searchLength);
+      const { gap, method } = computeMinGap(a2, b, searchLength);
+      const methodLabel = method === "exact" ? "exact min gap" : "mesh-derived min gap";
       const passed = gap > 0;
       push({
         id: nextId(),
         label,
+        kind: "interface",
         status: passed ? "pass" : "fail",
-        message: passed ? `No collision (min gap ${roundNum(gap, 3)} mm)` : `Shapes are colliding (min gap ${roundNum(gap, 3)} mm ≤ 0)`,
+        message: passed ? `No collision (${methodLabel} ${roundNum(gap, 3)} mm)` : `Shapes are colliding (${methodLabel} ${roundNum(gap, 3)} mm ≤ 0)`,
         line: passed ? void 0 : line2,
         expected: "> 0 mm",
         actual: `${roundNum(gap, 3)} mm`
       });
     } catch (e) {
-      push({ id: nextId(), label, status: "fail", message: `Error: ${e instanceof Error ? e.message : String(e)}`, line: line2 });
+      push({
+        id: nextId(),
+        label,
+        kind: "interface",
+        status: "fail",
+        message: `Error: ${e instanceof Error ? e.message : String(e)}`,
+        line: line2
+      });
     }
   },
   /**
@@ -84361,13 +86894,15 @@ const verify = {
   minClearance(label, a2, b, minGap, searchLength = 10) {
     const line2 = captureSourceLine();
     try {
-      const gap = computeMinGap(a2, b, searchLength);
+      const { gap, method } = computeMinGap(a2, b, searchLength);
+      const methodLabel = method === "exact" ? "exact gap" : "mesh-derived gap";
       const passed = gap >= minGap;
       push({
         id: nextId(),
         label,
+        kind: "interface",
         status: passed ? "pass" : "fail",
-        message: passed ? `Gap ${roundNum(gap, 3)} mm ≥ ${roundNum(minGap, 3)} mm` : `Gap ${roundNum(gap, 3)} mm < required ${roundNum(minGap, 3)} mm`,
+        message: passed ? `${methodLabel} ${roundNum(gap, 3)} mm ≥ ${roundNum(minGap, 3)} mm` : `${methodLabel} ${roundNum(gap, 3)} mm < required ${roundNum(minGap, 3)} mm`,
         line: passed ? void 0 : line2,
         expected: `≥ ${roundNum(minGap, 3)} mm`,
         actual: `${roundNum(gap, 3)} mm`
@@ -84376,6 +86911,90 @@ const verify = {
       push({ id: nextId(), label, status: "fail", message: `Error: ${e instanceof Error ? e.message : String(e)}`, line: line2 });
     }
   },
+  /**
+   * Check that the clearance gap between two shapes is inside an allowed range.
+   *
+   * **Details**
+   *
+   * Use this for seated and retained interfaces where a part must be close
+   * enough to be mechanically accountable, but must not collide beyond the
+   * allowed minimum. It catches both failure modes that make generated CAD look
+   * fake: parts floating away from their receiver, and parts intersecting their
+   * receiver because the pocket, bore, or running clearance was not modeled.
+   *
+   * For contact, use a narrow range such as `[-0.01, 0.05]` to tolerate tiny
+   * numerical noise. For a running fit, use the intended clearance band.
+   *
+   * Manifold-backed shapes use exact min-gap distance. Other backends use a
+   * mesh-derived min-gap check and say so in the verification message; keep
+   * `forgecad inspect mechanical-integrity --collisions` in the acceptance gate for
+   * positive-volume interference.
+   *
+   * **Example**
+   *
+   * ```ts
+   * verify.clearanceBetween("cover is seated on gasket", cover, gasket, -0.01, 0.05);
+   * verify.clearanceBetween("carriage runs inside rail", carriage, rail, 0.2, 0.5);
+   * ```
+   */
+  clearanceBetween(label, a2, b, minGap, maxGap, searchLength) {
+    const line2 = captureSourceLine();
+    try {
+      if (!Number.isFinite(minGap) || !Number.isFinite(maxGap)) {
+        push({
+          id: nextId(),
+          label,
+          kind: "interface",
+          status: "fail",
+          message: "Clearance range must use finite numbers",
+          line: line2
+        });
+        return;
+      }
+      if (maxGap < minGap) {
+        push({
+          id: nextId(),
+          label,
+          kind: "interface",
+          status: "fail",
+          message: `Clearance max ${roundNum(maxGap, 3)} mm is smaller than min ${roundNum(minGap, 3)} mm`,
+          line: line2
+        });
+        return;
+      }
+      const search = searchLength ?? Math.max(10, Math.abs(maxGap) * 2 + 1);
+      const { gap, method } = computeMinGap(a2, b, search);
+      const methodLabel = method === "exact" ? "exact gap" : "mesh-derived gap";
+      const passed = gap >= minGap && gap <= maxGap;
+      let message;
+      if (passed) {
+        message = `${methodLabel} ${roundNum(gap, 3)} mm in [${roundNum(minGap, 3)}, ${roundNum(maxGap, 3)}] mm`;
+      } else if (gap < minGap) {
+        message = `${methodLabel} ${roundNum(gap, 3)} mm < allowed minimum ${roundNum(minGap, 3)} mm`;
+      } else {
+        message = `${methodLabel} ${roundNum(gap, 3)} mm > allowed maximum ${roundNum(maxGap, 3)} mm`;
+      }
+      push({
+        id: nextId(),
+        label,
+        kind: "interface",
+        status: passed ? "pass" : "fail",
+        message,
+        line: passed ? void 0 : line2,
+        expected: `[${roundNum(minGap, 3)}, ${roundNum(maxGap, 3)}] mm`,
+        actual: `${roundNum(gap, 3)} mm`
+      });
+    } catch (e) {
+      push({
+        id: nextId(),
+        label,
+        kind: "interface",
+        status: "fail",
+        message: `Error: ${e instanceof Error ? e.message : String(e)}`,
+        line: line2
+      });
+    }
+  },
   /**
    * Check that two face normals are parallel (within toleranceDeg degrees).
    */
@@ -296941,6 +299560,7 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       nurbsSurface,
       spline2d,
       spline3d,
+      Loft,
       loft,
       loftAlongSpine,
       sweep,