forgecad 0.9.6 → 0.9.7

package/dist/assets/{distance-BEC2RjJi.js → sectionPlaneMath-BdTjyVfs.js}

@@ -8367,7 +8367,7 @@ function sub$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$1(name, start, end, faceName, curve) {
+function makeEdge(name, start, end, faceName, curve) {
   return {
     name,
     start,
@@ -8411,10 +8411,10 @@ function buildSurfaceSheetTopology(boundaries, options = {}) {
     surface: options.surface
   });
   const edges = /* @__PURE__ */ new Map();
-  edges.set("u0", makeEdge$1("u0", u0Start, u0End, faceName, (_a3 = options.edgeCurves) == null ? void 0 : _a3.u0));
-  edges.set("u1", makeEdge$1("u1", u1Start, u1End, faceName, (_b3 = options.edgeCurves) == null ? void 0 : _b3.u1));
-  edges.set("v0", makeEdge$1("v0", v0Start, v0End, faceName, (_c2 = options.edgeCurves) == null ? void 0 : _c2.v0));
-  edges.set("v1", makeEdge$1("v1", v1Start, v1End, faceName, (_d2 = options.edgeCurves) == null ? void 0 : _d2.v1));
+  edges.set("u0", makeEdge("u0", u0Start, u0End, faceName, (_a3 = options.edgeCurves) == null ? void 0 : _a3.u0));
+  edges.set("u1", makeEdge("u1", u1Start, u1End, faceName, (_b3 = options.edgeCurves) == null ? void 0 : _b3.u1));
+  edges.set("v0", makeEdge("v0", v0Start, v0End, faceName, (_c2 = options.edgeCurves) == null ? void 0 : _c2.v0));
+  edges.set("v1", makeEdge("v1", v1Start, v1End, faceName, (_d2 = options.edgeCurves) == null ? void 0 : _d2.v1));
   return { faces, edges };
 }
 function attachSurfaceSheetTopology(shape, boundaries, options = {}) {
@@ -10605,7 +10605,7 @@ async function initManifoldWasm() {
   if (_wasm$1) return _wasm$1;
   performance.mark("manifold:start");
   const Module = (await __vitePreload(async () => {
-    const { default: __vite_default__ } = await import("./manifold-DzZ4VRPs.js");
+    const { default: __vite_default__ } = await import("./manifold-DjYsd7A_.js");
     return { default: __vite_default__ };
   }, true ? [] : void 0)).default;
   performance.mark("manifold:imported");
@@ -22489,7 +22489,7 @@ function marchingTetrahedra(sdfFn, bounds, edgeLength2) {
   };
 }
 const EPS$8 = 1e-9;
-function finitePositive$1(value) {
+function finitePositive(value) {
   return Number.isFinite(value) && value > EPS$8;
 }
 function clampNonNegative(value) {
@@ -22508,7 +22508,7 @@ function distancePreservingMatrixScale(matrix) {
   const sx = length4(col0);
   const sy = length4(col1);
   const sz = length4(col2);
-  if (!finitePositive$1(sx) || !finitePositive$1(sy) || !finitePositive$1(sz)) return null;
+  if (!finitePositive(sx) || !finitePositive(sy) || !finitePositive(sz)) return null;
   if (Math.abs(sx - sy) > EPS$8 || Math.abs(sx - sz) > EPS$8) return null;
   if (Math.abs(dot2(col0, col1)) > EPS$8 || Math.abs(dot2(col0, col2)) > EPS$8 || Math.abs(dot2(col1, col2)) > EPS$8) return null;
   return sx;
@@ -22525,7 +22525,7 @@ function transformStepDistanceScale(step) {
       const sx = Math.abs(step.x);
       const sy = Math.abs(step.y);
       const sz = Math.abs(step.z);
-      if (!finitePositive$1(sx) || !finitePositive$1(sy) || !finitePositive$1(sz)) return null;
+      if (!finitePositive(sx) || !finitePositive(sy) || !finitePositive(sz)) return null;
       return Math.abs(sx - sy) <= EPS$8 && Math.abs(sx - sz) <= EPS$8 ? sx : null;
     }
   }
@@ -22565,7 +22565,7 @@ function translatedPlan(base, z2) {
   };
 }
 function offsetCylinderDimensions(plan, thickness) {
-  if (!finitePositive$1(plan.height)) return null;
+  if (!finitePositive(plan.height)) return null;
   const radiusTop = plan.radiusTop ?? plan.radius;
   const slope = (radiusTop - plan.radius) / plan.height;
   const normalScale = Math.hypot(1, slope);
@@ -22574,7 +22574,7 @@ function offsetCylinderDimensions(plan, thickness) {
   const height = zMax - zMin;
   const radiusBottom = plan.radius + thickness * (normalScale - slope);
   const offsetRadiusTop = radiusTop + thickness * (normalScale + slope);
-  if (!finitePositive$1(height) || radiusBottom < -EPS$8 || offsetRadiusTop < -EPS$8) return null;
+  if (!finitePositive(height) || radiusBottom < -EPS$8 || offsetRadiusTop < -EPS$8) return null;
   return {
     zMin,
     height,
@@ -22632,7 +22632,7 @@ function rectangleCandidatePointsFromProfile(plan) {
     case "rect": {
       const width = Math.abs(plan.width);
       const height = Math.abs(plan.height);
-      if (!finitePositive$1(width) || !finitePositive$1(height)) return null;
+      if (!finitePositive(width) || !finitePositive(height)) return null;
       const halfWidth = width / 2;
       const halfHeight = height / 2;
       const points = [
@@ -22666,7 +22666,7 @@ function rectangleFootprintFromProfile(plan) {
   const [xMin, xMax] = xs;
   const [zMin, zMax] = zs;
   if (xMin == null || xMax == null || zMin == null || zMax == null) return null;
-  if (xMin < -EPS$8 || !finitePositive$1(xMax) || !finitePositive$1(zMax - zMin)) return null;
+  if (xMin < -EPS$8 || !finitePositive(xMax) || !finitePositive(zMax - zMin)) return null;
   const hasCorner = (x2, z2) => points.some(([px2, pz2]) => sameScalar$1(px2, x2) && sameScalar$1(pz2, z2));
   if (!hasCorner(xMin, zMin) || !hasCorner(xMax, zMin) || !hasCorner(xMax, zMax) || !hasCorner(xMin, zMax)) return null;
   return {
@@ -22679,7 +22679,7 @@ function rectangleFootprintFromProfile(plan) {
 function circleFootprintFromProfile(plan) {
   if (plan.kind !== "circle") return null;
   const radius = Math.abs(plan.radius);
-  if (!finitePositive$1(radius)) return null;
+  if (!finitePositive(radius)) return null;
   const center = transformProfilePointThrough$1([0, 0], plan.transforms);
   const xPoint = transformProfilePointThrough$1([1, 0], plan.transforms);
   const yPoint = transformProfilePointThrough$1([0, 1], plan.transforms);
@@ -22688,7 +22688,7 @@ function circleFootprintFromProfile(plan) {
   const xScale = Math.hypot(xAxis[0], xAxis[1]);
   const yScale = Math.hypot(yAxis[0], yAxis[1]);
   const dot2 = xAxis[0] * yAxis[0] + xAxis[1] * yAxis[1];
-  if (!finitePositive$1(xScale) || !finitePositive$1(yScale)) return null;
+  if (!finitePositive(xScale) || !finitePositive(yScale)) return null;
   if (Math.abs(xScale - yScale) > EPS$8 || Math.abs(dot2) > EPS$8 * xScale * yScale) return null;
   return {
     center,
@@ -22701,7 +22701,7 @@ function fullCircleRevolveTorusPlan(plan, minorRadiusOffset = 0) {
   const circle2 = circleFootprintFromProfile(plan.profile);
   if (!circle2 || circle2.center[0] <= EPS$8) return null;
   const minorRadius = circle2.radius + minorRadiusOffset;
-  if (!finitePositive$1(minorRadius) || minorRadius >= circle2.center[0] - EPS$8) return null;
+  if (!finitePositive(minorRadius) || minorRadius >= circle2.center[0] - EPS$8) return null;
   return translatedPlan(
     {
       kind: "torus",
@@ -22748,7 +22748,7 @@ function offsetFullRectRevolvePlan(plan, thickness) {
   const innerRadius = rectangle.innerRadius - thickness;
   const outerRadius = rectangle.outerRadius + thickness;
   const height = rectangle.zMax - rectangle.zMin + 2 * thickness;
-  if (innerRadius < -EPS$8 || !finitePositive$1(outerRadius) || !finitePositive$1(height) || outerRadius <= innerRadius + EPS$8) return null;
+  if (innerRadius < -EPS$8 || !finitePositive(outerRadius) || !finitePositive(height) || outerRadius <= innerRadius + EPS$8) return null;
   const zCenter = (rectangle.zMin + rectangle.zMax) / 2;
   if (innerRadius <= EPS$8) {
     return translatedPlan(
@@ -22789,11 +22789,11 @@ function offsetSolidAnalyticPrimitivePlan(base, thickness) {
       };
     }
     case "box": {
-      if (!finitePositive$1(base.z)) return null;
+      if (!finitePositive(base.z)) return null;
       const x2 = Math.abs(base.x) + 2 * thickness;
       const y2 = Math.abs(base.y) + 2 * thickness;
       const z2 = base.z + 2 * thickness;
-      if (!finitePositive$1(x2) || !finitePositive$1(y2) || !finitePositive$1(z2)) return null;
+      if (!finitePositive(x2) || !finitePositive(y2) || !finitePositive(z2)) return null;
       return translatedPlan(
         {
           kind: "box",
@@ -22820,7 +22820,7 @@ function offsetSolidAnalyticPrimitivePlan(base, thickness) {
     }
     case "sphere": {
       const radius = base.radius + thickness;
-      if (!finitePositive$1(radius)) return null;
+      if (!finitePositive(radius)) return null;
       return {
         kind: "sphere",
         radius,
@@ -22829,7 +22829,7 @@ function offsetSolidAnalyticPrimitivePlan(base, thickness) {
     }
     case "torus": {
       const minorRadius = base.minorRadius + thickness;
-      if (!finitePositive$1(minorRadius) || minorRadius >= base.majorRadius - EPS$8) return null;
+      if (!finitePositive(minorRadius) || minorRadius >= base.majorRadius - EPS$8) return null;
       return {
         kind: "torus",
         majorRadius: base.majorRadius,
@@ -23569,18 +23569,18 @@ function faceAxes(face) {
   }
   return {};
 }
-function edgeKey$1(start, end) {
+function edgeKey(start, end) {
   const encode2 = (p2) => p2.map((value) => value.toFixed(9)).join(",");
   const a2 = encode2(start);
   const b = encode2(end);
   return a2 < b ? `${a2}|${b}` : `${b}|${a2}`;
 }
 function faceEdgeIndex(face, start, end) {
-  const target = edgeKey$1(start, end);
+  const target = edgeKey(start, end);
   for (let i = 0; i < face.vertices.length; i++) {
     const faceStart = face.vertices[i];
     const faceEnd = face.vertices[(i + 1) % face.vertices.length];
-    if (faceStart && faceEnd && edgeKey$1(faceStart, faceEnd) === target) return i;
+    if (faceStart && faceEnd && edgeKey(faceStart, faceEnd) === target) return i;
   }
   return null;
 }
@@ -23781,7 +23781,7 @@ function topologyPayloadToTopology(payload) {
     const start = explicitVertices[explicitEdge.vertices[0]];
     const end = explicitVertices[explicitEdge.vertices[1]];
     if (!isVec3$2(start) || !isVec3$2(end)) continue;
-    const key = edgeKey$1(start, end);
+    const key = edgeKey(start, end);
     if (seenEdges.has(key)) continue;
     seenEdges.set(key, edges.size);
     const display = explicitEdgeDisplayName(payload, explicitEdge, explicitEdgeIndex, start, end);
@@ -23801,7 +23801,7 @@ function topologyPayloadToTopology(payload) {
         const start = face.vertices[i];
         const end = face.vertices[(i + 1) % face.vertices.length];
         if (!start || !end) continue;
-        const key = edgeKey$1(start, end);
+        const key = edgeKey(start, end);
         if (seenEdges.has(key)) continue;
         seenEdges.set(key, edges.size);
         edges.set(`${face.id}:edge-${i}`, {
@@ -35897,7 +35897,7 @@ function edgesBetweenFaces(shape, faceA, faceBs) {
   });
   return coalesceEdges(result);
 }
-const EPSILON$3 = 1e-8;
+const EPSILON$2 = 1e-8;
 function rayTriangle(ox, oy, oz, dx, dy, dz, ax, ay, az, bx, by, bz, cx, cy, cz) {
   const e1x = bx - ax, e1y = by - ay, e1z = bz - az;
   const e2x = cx - ax, e2y = cy - ay, e2z = cz - az;
@@ -35905,7 +35905,7 @@ function rayTriangle(ox, oy, oz, dx, dy, dz, ax, ay, az, bx, by, bz, cx, cy, cz)
   const py2 = dz * e2x - dx * e2z;
   const pz2 = dx * e2y - dy * e2x;
   const det = e1x * px2 + e1y * py2 + e1z * pz2;
-  if (det > -EPSILON$3 && det < EPSILON$3) return null;
+  if (det > -EPSILON$2 && det < EPSILON$2) return null;
   const invDet = 1 / det;
   const tx = ox - ax, ty = oy - ay, tz = oz - az;
   const u2 = (tx * px2 + ty * py2 + tz * pz2) * invDet;
@@ -35944,7 +35944,7 @@ function rayMeshIntersect(mesh, origin, direction2) {
   hits.sort((a2, b) => a2.distance - b.distance);
   const deduped = [];
   for (const hit of hits) {
-    if (deduped.length === 0 || Math.abs(hit.distance - deduped[deduped.length - 1].distance) > EPSILON$3 * 100) {
+    if (deduped.length === 0 || Math.abs(hit.distance - deduped[deduped.length - 1].distance) > EPSILON$2 * 100) {
       deduped.push(hit);
     }
   }
@@ -49280,7 +49280,7 @@ function beltDrive(options) {
   };
 }
 const GEAR_META_KEY = Symbol.for("forgecad.library.gearMeta");
-const EPSILON$2 = 1e-9;
+const EPSILON$1 = 1e-9;
 function clamp01$1(value) {
   return Math.max(-1, Math.min(1, value));
 }
@@ -49399,11 +49399,11 @@ function buildSpurGearMeta(options) {
   const pitchRadius = options.module * options.teeth * 0.5;
   const baseRadius = pitchRadius * Math.cos(options.pressureAngleRad);
   const outerRadius = pitchRadius + options.addendum;
-  const rootRadius = Math.max(EPSILON$2, pitchRadius - options.dedendum);
-  if (!(rootRadius < outerRadius - EPSILON$2)) {
+  const rootRadius = Math.max(EPSILON$1, pitchRadius - options.dedendum);
+  if (!(rootRadius < outerRadius - EPSILON$1)) {
     throw new Error("spurGear: invalid radii (root radius must be smaller than outer radius)");
   }
-  if (options.boreDiameter > 0 && options.boreDiameter * 0.5 >= rootRadius - EPSILON$2) {
+  if (options.boreDiameter > 0 && options.boreDiameter * 0.5 >= rootRadius - EPSILON$1) {
     throw new Error("spurGear: bore is too large for the computed root radius");
   }
   return {
@@ -49426,7 +49426,7 @@ function buildSpurGearMeta(options) {
 function createSpurToothSketch(meta2, segmentsPerTooth) {
   const circularPitch = Math.PI * meta2.module;
   const thicknessAtPitch = circularPitch * 0.5 - meta2.backlash;
-  if (thicknessAtPitch <= EPSILON$2) {
+  if (thicknessAtPitch <= EPSILON$1) {
     throw new Error("spurGear: backlash leaves no tooth thickness at pitch circle");
   }
   const halfThicknessAtPitch = thicknessAtPitch / (2 * meta2.pitchRadius);
@@ -49435,7 +49435,7 @@ function createSpurToothSketch(meta2, segmentsPerTooth) {
   const arcSteps = Math.max(3, Math.ceil(segmentsPerTooth * 0.6));
   const radialGap = flankStartRadius - meta2.rootRadius;
   const filletRadius = Math.min(0.38 * meta2.module, radialGap * 0.9);
-  const hasFillets = filletRadius > EPSILON$2;
+  const hasFillets = filletRadius > EPSILON$1;
   const leftFlank = [];
   const rightFlank = [];
   for (let i = 0; i <= flankSteps; i++) {
@@ -49499,7 +49499,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) {
@@ -49521,8 +49521,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);
@@ -49530,14 +49530,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,
@@ -49546,11 +49546,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');
   }
@@ -49573,12 +49573,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) {
@@ -49640,7 +49640,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"`);
@@ -49663,7 +49663,7 @@ function normalizedSweep(scope, fromAngleDeg, toAngleDeg) {
   if (!Number.isFinite(toAngleDeg)) throw new Error(`${scope}: "toAngleDeg" must be finite`);
   let sweep2 = toAngleDeg - fromAngleDeg;
   while (sweep2 <= 0) sweep2 += 360;
-  if (sweep2 > 360 + EPSILON$2) throw new Error(`${scope}: angular sweep must be <= 360 degrees`);
+  if (sweep2 > 360 + EPSILON$1) throw new Error(`${scope}: angular sweep must be <= 360 degrees`);
   return Math.min(360, sweep2);
 }
 function buildSpurToothRegionProfile(meta2, firstTooth, toothCount, segmentsPerTooth) {
@@ -49678,7 +49678,7 @@ function buildSolidArcProfile(options, sweepDeg) {
   const innerRadius = options.innerRadius ?? 0;
   const segments = options.segments ?? Math.max(16, Math.ceil(sweepDeg / 6));
   if (!Number.isInteger(segments) || segments < 4) throw new Error('driveWheel.addSolidArcBetween: "segments" must be an integer >= 4');
-  if (Math.abs(sweepDeg - 360) < EPSILON$2) {
+  if (Math.abs(sweepDeg - 360) < EPSILON$1) {
     const outer = circle2d(options.outerRadius, segments);
     return innerRadius > 0 ? difference2d(outer, circle2d(innerRadius, segments)) : outer;
   }
@@ -49706,7 +49706,7 @@ class DriveWheelBuilder {
     __publicField(this, "boreDiameter");
     __publicField(this, "regions", []);
     if (options.body !== void 0 && !(options.body instanceof Shape$1)) 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;
@@ -49741,7 +49741,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: {
@@ -49762,7 +49762,7 @@ class DriveWheelBuilder {
     }
     const faceWidth = this.resolveBuildFaceWidth();
     const firstGearRegion = (_a3 = this.regions.find((region) => region.gearMeta)) == null ? void 0 : _a3.gearMeta;
-    if (firstGearRegion && this.boreDiameter * 0.5 >= firstGearRegion.rootRadius - EPSILON$2) {
+    if (firstGearRegion && this.boreDiameter * 0.5 >= firstGearRegion.rootRadius - EPSILON$1) {
       throw new Error("driveWheel: bore is too large for the first spur-tooth region");
     }
     const body = ((_b3 = this.body) == null ? void 0 : _b3.clone()) ?? gearBodyDisk({ outerRadius: (firstGearRegion == null ? void 0 : firstGearRegion.rootRadius) ?? this.defaultBodyRadius(), faceWidth });
@@ -49807,8 +49807,8 @@ 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);
-    if (this.faceWidth !== void 0 && localFaceWidth !== void 0 && Math.abs(this.faceWidth - localFaceWidth) > EPSILON$2) {
+    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`);
     }
     return faceWidth;
@@ -50031,7 +50031,7 @@ function normalizeRingGearOptions(options) {
   const rimWidth = options.rimWidth ?? module * 2;
   if (!isFinitePositive(rimWidth)) throw new Error('ringGear: "rimWidth" must be > 0');
   const outerRadius = options.outerDiameter != null ? options.outerDiameter * 0.5 : rootRadius + rimWidth;
-  if (!(outerRadius > rootRadius + EPSILON$2)) {
+  if (!(outerRadius > rootRadius + EPSILON$1)) {
     throw new Error("ringGear: outer diameter/rim width leaves no ring body");
   }
   return {
@@ -50083,8 +50083,8 @@ function ringGear(options) {
   const baseRadius = pitchRadius * Math.cos(normalized.pressureAngleRad);
   const tipRadius = pitchRadius - normalized.addendum;
   const rootRadius = pitchRadius + normalized.dedendum;
-  if (!(tipRadius > EPSILON$2)) throw new Error("ringGear: addendum is too large for the tooth count/module");
-  if (!(tipRadius < rootRadius - EPSILON$2)) throw new Error("ringGear: invalid tip/root radius relationship");
+  if (!(tipRadius > EPSILON$1)) throw new Error("ringGear: addendum is too large for the tooth count/module");
+  if (!(tipRadius < rootRadius - EPSILON$1)) throw new Error("ringGear: invalid tip/root radius relationship");
   const meta2 = {
     kind: "ring",
     module: normalized.module,
@@ -50158,13 +50158,13 @@ function rackGear(options) {
   const baseHeight = options.baseHeight ?? module * 1.6;
   if (!isFinitePositive(baseHeight)) throw new Error('rackGear: "baseHeight" must be > 0');
   const thicknessAtPitch = pitch * 0.5 - backlash;
-  if (thicknessAtPitch <= EPSILON$2) throw new Error("rackGear: backlash leaves no tooth thickness");
+  if (thicknessAtPitch <= EPSILON$1) throw new Error("rackGear: backlash leaves no tooth thickness");
   const halfPitchThickness = thicknessAtPitch * 0.5;
   const dxTip = addendum * Math.tan(pressureAngleRad);
   const dxRoot = dedendum * Math.tan(pressureAngleRad);
   const halfTip = halfPitchThickness - dxTip;
   const halfRoot = halfPitchThickness + dxRoot;
-  if (halfTip <= EPSILON$2) {
+  if (halfTip <= EPSILON$1) {
     throw new Error("rackGear: tooth tip collapsed (increase module or lower pressure angle/addendum)");
   }
   const toothSketch = polygon([
@@ -50230,7 +50230,7 @@ function computeBevelPitchAngleDeg(teeth, mateTeeth, shaftAngleDeg) {
   const numerator = teeth * Math.sin(shaftAngleRad);
   const denominator = mateTeeth + teeth * Math.cos(shaftAngleRad);
   const angle = Math.atan2(numerator, denominator);
-  if (!(angle > EPSILON$2 && angle < shaftAngleRad - EPSILON$2)) {
+  if (!(angle > EPSILON$1 && angle < shaftAngleRad - EPSILON$1)) {
     throw new Error("bevelGear: could not derive a valid pitch angle from teeth/shaft angle");
   }
   return angle * 180 / Math.PI;
@@ -50265,7 +50265,7 @@ function normalizeBevelGearOptions(options) {
   }
   const pitchAngleRad = pitchAngleDeg * Math.PI / 180;
   const pitchRadius = spur.module * spur.teeth * 0.5;
-  const coneDistance = pitchRadius / Math.max(EPSILON$2, Math.sin(pitchAngleRad));
+  const coneDistance = pitchRadius / Math.max(EPSILON$1, Math.sin(pitchAngleRad));
   if (!isFinitePositive(coneDistance)) {
     throw new Error("bevelGear: invalid cone distance");
   }
@@ -50274,7 +50274,7 @@ function normalizeBevelGearOptions(options) {
     throw new Error("bevelGear: faceWidth is too large for the selected pitch angle");
   }
   const topScale = smallPitchRadius / pitchRadius;
-  if (!(topScale > EPSILON$2 && topScale <= 1)) {
+  if (!(topScale > EPSILON$1 && topScale <= 1)) {
     throw new Error("bevelGear: computed top scale is invalid");
   }
   return {
@@ -50390,7 +50390,7 @@ function gearPair(options) {
   const alpha = pinion.meta.pressureAngleRad;
   const nominalCenterDistance = pinion.meta.pitchRadius + gear.meta.pitchRadius;
   const requestedBacklash = options.backlash ?? Math.max(pinion.meta.backlash, gear.meta.backlash, 0);
-  const autoCenterDistance = nominalCenterDistance + requestedBacklash / (2 * Math.max(EPSILON$2, Math.tan(alpha)));
+  const autoCenterDistance = nominalCenterDistance + requestedBacklash / (2 * Math.max(EPSILON$1, Math.tan(alpha)));
   const centerDistance = options.centerDistance ?? autoCenterDistance;
   if (!Number.isFinite(centerDistance) || centerDistance <= 0) {
     throw new Error("gearPair: centerDistance must be > 0");
@@ -50419,11 +50419,11 @@ function gearPair(options) {
       message: `Center distance ${centerDistance.toFixed(4)} exceeds addendum reach ${addendumReach.toFixed(4)} (no mesh contact)`
     });
   }
-  const cosWorking = clamp01$1(baseSum / Math.max(centerDistance, EPSILON$2));
+  const cosWorking = clamp01$1(baseSum / Math.max(centerDistance, EPSILON$1));
   const alphaWorking = Math.acos(cosWorking);
   const basePitch = Math.PI * module * Math.cos(alpha);
   const pathLength = Math.sqrt(Math.max(0, pinion.meta.outerRadius ** 2 - pinion.meta.baseRadius ** 2)) + Math.sqrt(Math.max(0, gear.meta.outerRadius ** 2 - gear.meta.baseRadius ** 2)) - centerDistance * Math.sin(alphaWorking);
-  const contactRatio = pathLength / Math.max(EPSILON$2, basePitch);
+  const contactRatio = pathLength / Math.max(EPSILON$1, basePitch);
   if (contactRatio < 1) {
     diagnostics.push({
       level: "error",
@@ -50554,8 +50554,8 @@ function bevelGearPair(options) {
       message: `Gear pitch angle (${gearMetaPitch.toFixed(2)}deg) differs from tooth-derived ${gearPitchAngleDeg.toFixed(2)}deg`
     });
   }
-  const coneDistancePinion = pinion.meta.coneDistance ?? pinion.meta.pitchRadius / Math.max(EPSILON$2, Math.sin(pinionPitchAngleRad));
-  const coneDistanceGear = gear.meta.coneDistance ?? gear.meta.pitchRadius / Math.max(EPSILON$2, Math.sin(gearPitchAngleRad));
+  const coneDistancePinion = pinion.meta.coneDistance ?? pinion.meta.pitchRadius / Math.max(EPSILON$1, Math.sin(pinionPitchAngleRad));
+  const coneDistanceGear = gear.meta.coneDistance ?? gear.meta.pitchRadius / Math.max(EPSILON$1, Math.sin(gearPitchAngleRad));
   const coneDistance = (coneDistancePinion + coneDistanceGear) * 0.5;
   if (Math.abs(coneDistancePinion - coneDistanceGear) > pinion.meta.module * 0.5) {
     diagnostics.push({
@@ -50564,8 +50564,8 @@ function bevelGearPair(options) {
       message: `Pitch-cone distances differ: pinion=${coneDistancePinion.toFixed(3)}, gear=${coneDistanceGear.toFixed(3)}`
     });
   }
-  const pinionToApex = pinion.meta.pitchRadius / Math.max(EPSILON$2, Math.tan(pinionPitchAngleRad)) - pinion.meta.faceWidth * 0.5;
-  const gearToApex = gear.meta.pitchRadius / Math.max(EPSILON$2, Math.tan(gearPitchAngleRad)) - gear.meta.faceWidth * 0.5;
+  const pinionToApex = pinion.meta.pitchRadius / Math.max(EPSILON$1, Math.tan(pinionPitchAngleRad)) - pinion.meta.faceWidth * 0.5;
+  const gearToApex = gear.meta.pitchRadius / Math.max(EPSILON$1, Math.tan(gearPitchAngleRad)) - gear.meta.faceWidth * 0.5;
   if (pinionToApex <= 0 || gearToApex <= 0) {
     diagnostics.push({
       level: "warn",
@@ -50960,6 +50960,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 cover2 = 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: cover2 },
+    ...screws.map((shape, index2) => ({ name: `installed ${screwSize} cover screw ${index2 + 1}`, shape }))
+  ];
+  return {
+    parts,
+    parent,
+    cover: cover2,
+    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 cover2 = 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: cover2 },
+    ...screws.map((shape, index2) => ({ name: `installed ${screwSize} enclosure screw ${index2 + 1}`, shape }))
+  ];
+  return {
+    parts,
+    base,
+    cover: cover2,
+    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 cover2 = 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: cover2 }
+  ];
+  return {
+    parts,
+    parent,
+    cover: cover2,
+    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 cover2 = 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: cover2 }],
+    cover: cover2,
+    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}"`);
@@ -51020,6 +52881,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,
@@ -51360,11 +53237,11 @@ function inverseLerp(x2, y2, value) {
     return 0;
   }
 }
-function lerp$6(x2, y2, t) {
+function lerp$5(x2, y2, t) {
   return (1 - t) * x2 + t * y2;
 }
 function damp(x2, y2, lambda, dt) {
-  return lerp$6(x2, y2, 1 - Math.exp(-lambda * dt));
+  return lerp$5(x2, y2, 1 - Math.exp(-lambda * dt));
 }
 function pingpong(x2, length4 = 1) {
   return length4 - Math.abs(euclideanModulo(x2, length4 * 2) - length4);
@@ -51557,7 +53434,7 @@ const MathUtils = {
    * @param {number} t - The interpolation factor in the closed interval `[0, 1]`.
    * @return {number} The interpolated value.
    */
-  lerp: lerp$6,
+  lerp: lerp$5,
   /**
    * Smoothly interpolate a number from `x` to `y` in  a spring-like manner using a delta
    * time to maintain frame rate independent movement. For details, see
@@ -60511,9 +62388,9 @@ class Color {
   lerpHSL(color, alpha) {
     this.getHSL(_hslA);
     color.getHSL(_hslB);
-    const h = lerp$6(_hslA.h, _hslB.h, alpha);
-    const s = lerp$6(_hslA.s, _hslB.s, alpha);
-    const l = lerp$6(_hslA.l, _hslB.l, alpha);
+    const h = lerp$5(_hslA.h, _hslB.h, alpha);
+    const s = lerp$5(_hslA.s, _hslB.s, alpha);
+    const l = lerp$5(_hslA.l, _hslB.l, alpha);
     this.setHSL(h, s, l);
     return this;
   }
@@ -94689,7 +96566,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$5(a2, b, t) {
+function lerp$4(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function frameMatrix$1(x2, y2, z2, p2) {
@@ -94765,9 +96642,9 @@ function interpolateQuery(a2, b, t) {
   }
   return {
     side: sideA,
-    u: lerp$5(a2.u ?? 0.5, b.u ?? 0.5, t),
-    v: lerp$5(a2.v ?? 0.5, b.v ?? 0.5, t),
-    offset: lerp$5(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) {
@@ -94892,7 +96769,7 @@ class ProductSkin {
   }
   /** Interpolate center, width, and depth at a normalized v or absolute axis value. */
   stationAt(vOrAxis) {
-    const axisValue = vOrAxis >= 0 && vOrAxis <= 1 ? lerp$5(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];
@@ -94904,12 +96781,12 @@ class ProductSkin {
       const t = clamp$5((axisValue - aAxis) / span, 0, 1);
       return {
         axisValue,
-        center: [lerp$5(a2.center[0], b.center[0], t), lerp$5(a2.center[1], b.center[1], t), lerp$5(a2.center[2], b.center[2], t)],
-        width: lerp$5(a2.profile.width, b.profile.width, t),
-        depth: lerp$5(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$5(profileExponent(a2), profileExponent(b), t),
+        exponent: lerp$4(profileExponent(a2), profileExponent(b), t),
         kind: a2.profile.kind === b.profile.kind ? a2.profile.kind : "custom"
       };
     }
@@ -95742,7 +97619,7 @@ function requirePositive$3(value, label) {
 function clamp$4(value, min2, max2) {
   return Math.max(min2, Math.min(max2, value));
 }
-function lerp$4(a2, b, t) {
+function lerp$3(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function add(a2, b) {
@@ -95792,19 +97669,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$4(a2.z, b.z, t), offset: lerp$4(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$4(a2.x, b.x, t), y: lerp$4(a2.y, b.y, t), offset: lerp$4(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$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)
+    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 {
@@ -96902,7 +98779,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$4(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));
   }
@@ -97202,7 +99079,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$4(a2.t, b.t, localT);
+      return lerp$3(a2.t, b.t, localT);
     }
     traveled += segmentLength;
   }
@@ -97255,7 +99132,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$4(-width / 2, width / 2, acrossIndex / acrossSegments);
+      const across = lerp$3(-width / 2, width / 2, acrossIndex / acrossSegments);
       mesh.vertices.push(pointAtProfile([across, along], false));
     }
   }
@@ -97265,7 +99142,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$4(-width / 2, width / 2, acrossIndex / acrossSegments);
+      const across = lerp$3(-width / 2, width / 2, acrossIndex / acrossSegments);
       mesh.vertices.push(pointAtProfile([across, along], true));
     }
   }
@@ -97277,7 +99154,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$4(-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));
     }
   }
@@ -99477,7 +101354,7 @@ function midpoint$1(a2, b) {
   requireVec3$1(b, "b");
   return [(a2[0] + b[0]) / 2, (a2[1] + b[1]) / 2, (a2[2] + b[2]) / 2];
 }
-function lerp$3(a2, b, t) {
+function lerp$2(a2, b, t) {
   requireVec3$1(a2, "a");
   requireVec3$1(b, "b");
   requireFiniteNumber(t, "t");
@@ -99507,7 +101384,7 @@ const Points2 = {
   /** 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$3,
+  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. */
@@ -107406,7 +109283,7 @@ function chamferTrackedEdge(shape, edge, size, quadrant = [-1, -1]) {
   );
   return buildEdgeFeatureResult(target, plan, "chamfer");
 }
-const EPSILON$1 = 1e-8;
+const EPSILON = 1e-8;
 function toTuple(point2) {
   return Array.isArray(point2) ? [point2[0], point2[1]] : [point2.x, point2.y];
 }
@@ -107417,7 +109294,7 @@ function distance(a2, b) {
 }
 function normalize(vx, vy) {
   const len2 = Math.hypot(vx, vy);
-  if (len2 <= EPSILON$1) throw new Error("filletCorners requires non-degenerate edges");
+  if (len2 <= EPSILON) throw new Error("filletCorners requires non-degenerate edges");
   return [vx / len2, vy / len2];
 }
 function clamp$3(value, min2, max2) {
@@ -107454,19 +109331,19 @@ function buildCornerGeometry(points, spec2, winding) {
   const [inDirX, inDirY] = normalize(current[0] - prev[0], current[1] - prev[1]);
   const [outDirX, outDirY] = normalize(next[0] - current[0], next[1] - current[1]);
   const turn = inDirX * outDirY - inDirY * outDirX;
-  const isConvex = turn * winding > EPSILON$1;
-  const isConcave = turn * winding < -EPSILON$1;
+  const isConvex = turn * winding > EPSILON;
+  const isConcave = turn * winding < -EPSILON;
   if (!isConvex && !isConcave) {
     throw new Error(`filletCorners corner ${spec2.index} is collinear; cannot fillet a straight edge`);
   }
   const toPrev = [-inDirX, -inDirY];
   const toNext = [outDirX, outDirY];
   const interiorAngle = Math.acos(clamp$3(toPrev[0] * toNext[0] + toPrev[1] * toNext[1], -1, 1));
-  if (interiorAngle <= EPSILON$1 || interiorAngle >= Math.PI - EPSILON$1) {
+  if (interiorAngle <= EPSILON || interiorAngle >= Math.PI - EPSILON) {
     throw new Error(`filletCorners corner ${spec2.index} has an unsupported angle`);
   }
   const tangentDistance = spec2.radius / Math.tan(interiorAngle / 2);
-  if (tangentDistance >= inLength - EPSILON$1 || tangentDistance >= outLength - EPSILON$1) {
+  if (tangentDistance >= inLength - EPSILON || tangentDistance >= outLength - EPSILON) {
     const maxRadius = Math.min(inLength, outLength) * Math.tan(interiorAngle / 2);
     throw new Error(`filletCorners radius ${spec2.radius} is too large for corner ${spec2.index}; max is ${maxRadius.toFixed(3)}`);
   }
@@ -107496,7 +109373,7 @@ function filletCorners(points, corners) {
   if (corners.length === 0) return polygon(points);
   const tuples = points.map(toTuple);
   const area2 = signedArea$3(tuples);
-  if (Math.abs(area2) <= EPSILON$1) throw new Error("filletCorners requires a non-degenerate polygon");
+  if (Math.abs(area2) <= EPSILON) throw new Error("filletCorners requires a non-degenerate polygon");
   const winding = Math.sign(area2);
   const geometryByIndex = /* @__PURE__ */ new Map();
   for (const spec2 of corners) {
@@ -107510,7 +109387,7 @@ function filletCorners(points, corners) {
     const edgeLength2 = distance(tuples[i], tuples[nextIndex]);
     const exitDistance = ((_a3 = geometryByIndex.get(i)) == null ? void 0 : _a3.tangentDistance) ?? 0;
     const entryDistance = ((_b3 = geometryByIndex.get(nextIndex)) == null ? void 0 : _b3.tangentDistance) ?? 0;
-    if (exitDistance + entryDistance >= edgeLength2 - EPSILON$1) {
+    if (exitDistance + entryDistance >= edgeLength2 - EPSILON) {
       throw new Error(`filletCorners adjacent fillets overlap on edge ${i} -> ${nextIndex}; reduce one of the radii`);
     }
   }
@@ -120043,7 +121920,7 @@ function railCrossAt(rail2, position) {
     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$2(a2.cross[0], b.cross[0], t), lerp$2(a2.cross[1], b.cross[1], t)];
+      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");
@@ -120081,7 +121958,7 @@ function crossPointForAxis(axis, point2) {
   if (axis === "Y") return [point2[0], -point2[2]];
   return [point2[0], point2[1]];
 }
-function lerp$2(a2, b, t) {
+function lerp$1(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function loftWithGuideRails(stations, rails, options = {}) {
@@ -120205,13 +122082,13 @@ function sketchBounds(profile) {
 }
 function lerpBounds(a2, b, t) {
   return {
-    minX: lerp$1(a2.minX, b.minX, t),
-    maxX: lerp$1(a2.maxX, b.maxX, t),
-    minY: lerp$1(a2.minY, b.minY, t),
-    maxY: lerp$1(a2.maxY, b.maxY, t)
+    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$1(a2, b, t) {
+function lerp(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function mapLoftPath2D(path2, label, mapper) {
@@ -120975,7 +122852,7 @@ function resolveCornerYSelection(edges, options = {}) {
   for (const candidate of candidates) {
     const selectedEndpoints = [];
     let totalGap = 0;
-    let maxGap2 = 0;
+    let maxGap = 0;
     for (const edge of edges) {
       const start = edgeEndpoint(edge, "start");
       const end = edgeEndpoint(edge, "end");
@@ -120985,10 +122862,10 @@ function resolveCornerYSelection(edges, options = {}) {
       const gap = Math.min(startGap, endGap);
       selectedEndpoints.push(selected);
       totalGap += gap;
-      maxGap2 = Math.max(maxGap2, gap);
+      maxGap = Math.max(maxGap, gap);
     }
-    if (maxGap2 <= cornerTolerance && (!best || totalGap < best.totalGap)) {
-      best = { totalGap, maxGap: maxGap2, selectedEndpoints };
+    if (maxGap <= cornerTolerance && (!best || totalGap < best.totalGap)) {
+      best = { totalGap, maxGap, selectedEndpoints };
     }
   }
   if (!best) {
@@ -125424,10 +127301,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() {
@@ -125461,15 +127342,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];
@@ -125604,9 +127505,144 @@ 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).
    *
@@ -125615,19 +127651,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
+      });
     }
   },
   /**
@@ -125636,13 +127681,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`
@@ -125651,6 +127698,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).
    */
@@ -339418,10 +341549,149 @@ function runScript(code, fileName = "main.forge.js", allFiles = {}, options = {}
     }
   }
 }
+const DEFAULT_LEAF_SIZE = 8;
+function cloneVec3$1(value) {
+  return [value[0], value[1], value[2]];
+}
+function emptyBounds() {
+  return {
+    min: [Infinity, Infinity, Infinity],
+    max: [-Infinity, -Infinity, -Infinity]
+  };
+}
+function expandBounds(bounds, entry) {
+  for (let axis = 0; axis < 3; axis += 1) {
+    bounds.min[axis] = Math.min(bounds.min[axis], entry.min[axis]);
+    bounds.max[axis] = Math.max(bounds.max[axis], entry.max[axis]);
+  }
+}
+function boundsFor(entries, indexes) {
+  const bounds = emptyBounds();
+  for (const index2 of indexes) expandBounds(bounds, entries[index2]);
+  return bounds;
+}
+function longestAxis(bounds) {
+  const sizes = [bounds.max[0] - bounds.min[0], bounds.max[1] - bounds.min[1], bounds.max[2] - bounds.min[2]];
+  if (sizes[1] > sizes[0] && sizes[1] >= sizes[2]) return 1;
+  if (sizes[2] > sizes[0] && sizes[2] > sizes[1]) return 2;
+  return 0;
+}
+function centerOnAxis(entry, axis) {
+  return (entry.min[axis] + entry.max[axis]) * 0.5;
+}
+function nodeVolume(node) {
+  return Math.max(0, node.max[0] - node.min[0]) * Math.max(0, node.max[1] - node.min[1]) * Math.max(0, node.max[2] - node.min[2]);
+}
+function aabbOverlaps(a2, b, padding = 0) {
+  if (padding <= 0) {
+    return [0, 1, 2].every((axis) => a2.min[axis] < b.max[axis] && a2.max[axis] > b.min[axis]);
+  }
+  return [0, 1, 2].every((axis) => a2.min[axis] <= b.max[axis] + padding && a2.max[axis] + padding >= b.min[axis]);
+}
+function aabbGaps(a2, b) {
+  return [
+    Math.max(0, b.min[0] - a2.max[0], a2.min[0] - b.max[0]),
+    Math.max(0, b.min[1] - a2.max[1], a2.min[1] - b.max[1]),
+    Math.max(0, b.min[2] - a2.max[2], a2.min[2] - b.max[2])
+  ];
+}
+function aabbInteriorOverlaps(a2, b) {
+  return [0, 1, 2].every((axis) => Math.min(a2.max[axis], b.max[axis]) - Math.max(a2.min[axis], b.min[axis]) > 0);
+}
+function aabbOverlapVolume(a2, b) {
+  let volume = 1;
+  for (const axis of [0, 1, 2]) {
+    const overlap = Math.min(a2.max[axis], b.max[axis]) - Math.max(a2.min[axis], b.min[axis]);
+    if (overlap <= 0) return 0;
+    volume *= overlap;
+  }
+  return volume;
+}
+class AabbSpatialIndex {
+  constructor(entries, leafSize = DEFAULT_LEAF_SIZE) {
+    __publicField(this, "root");
+    __publicField(this, "nodeCount");
+    this.entries = entries;
+    this.leafSize = leafSize;
+    let nodeCount = 0;
+    const build = (indexes) => {
+      nodeCount += 1;
+      const bounds = boundsFor(entries, indexes);
+      if (indexes.length <= this.leafSize) {
+        return { min: cloneVec3$1(bounds.min), max: cloneVec3$1(bounds.max), left: null, right: null, indexes };
+      }
+      const axis = longestAxis(bounds);
+      indexes.sort((a2, b) => centerOnAxis(entries[a2], axis) - centerOnAxis(entries[b], axis) || a2 - b);
+      const mid = Math.max(1, Math.floor(indexes.length / 2));
+      return {
+        min: cloneVec3$1(bounds.min),
+        max: cloneVec3$1(bounds.max),
+        left: build(indexes.slice(0, mid)),
+        right: build(indexes.slice(mid)),
+        indexes: null
+      };
+    };
+    this.root = entries.length > 0 ? build(entries.map((_2, index2) => index2)) : null;
+    this.nodeCount = nodeCount;
+  }
+  overlapPairs(options = {}) {
+    const padding = Math.max(0, options.padding ?? 0);
+    const pairs = [];
+    let nodePairChecks = 0;
+    let leafPairChecks = 0;
+    const addLeafPair = (sourceIndex, targetIndex) => {
+      var _a3;
+      const source = this.entries[sourceIndex];
+      const target = this.entries[targetIndex];
+      leafPairChecks += 1;
+      if ((_a3 = options.skipPair) == null ? void 0 : _a3.call(options, source, target, sourceIndex, targetIndex)) return;
+      if (!aabbOverlaps(source, target, padding)) return;
+      pairs.push({ sourceIndex, targetIndex });
+    };
+    const between = (a2, b) => {
+      nodePairChecks += 1;
+      if (!aabbOverlaps(a2, b, padding)) return;
+      if (a2.indexes && b.indexes) {
+        for (const sourceIndex of a2.indexes) {
+          for (const targetIndex of b.indexes) addLeafPair(Math.min(sourceIndex, targetIndex), Math.max(sourceIndex, targetIndex));
+        }
+        return;
+      }
+      if (!b.indexes && (a2.indexes || nodeVolume(a2) <= nodeVolume(b))) {
+        between(a2, b.left);
+        between(a2, b.right);
+        return;
+      }
+      between(a2.left, b);
+      between(a2.right, b);
+    };
+    const within = (node) => {
+      if (node.indexes) {
+        for (let i = 0; i < node.indexes.length; i += 1) {
+          for (let j = i + 1; j < node.indexes.length; j += 1) addLeafPair(node.indexes[i], node.indexes[j]);
+        }
+        return;
+      }
+      within(node.left);
+      within(node.right);
+      between(node.left, node.right);
+    };
+    if (this.root) within(this.root);
+    return {
+      pairs,
+      stats: {
+        objectCount: this.entries.length,
+        nodeCount: this.nodeCount,
+        nodePairChecks,
+        leafPairChecks
+      }
+    };
+  }
+}
 const DEFAULT_COLLISION_INSPECTION_OPTIONS = {
   minOverlapVolume: 0.1
 };
-function cloneVec3$1(value) {
+function cloneVec3(value) {
   return [value[0], value[1], value[2]];
 }
 function isIdentityTransform(matrix) {
@@ -339463,8 +341733,8 @@ function prepareEntry(entry) {
   if (isIdentityTransform(entry.transform)) {
     return {
       ...entry,
-      min: cloneVec3$1(entry.min),
-      max: cloneVec3$1(entry.max)
+      min: cloneVec3(entry.min),
+      max: cloneVec3(entry.max)
     };
   }
   const bbox = transformBBox(entry.min, entry.max, entry.transform);
@@ -339475,56 +341745,26 @@ function prepareEntry(entry) {
     max: bbox.max
   };
 }
-function bboxOverlaps(a2, b) {
-  return [0, 1, 2].every((axis) => a2.min[axis] < b.max[axis] && a2.max[axis] > b.min[axis]);
-}
 function collisionId(a2, b) {
   return `${a2.id}__${b.id}`;
 }
-function estimateSweepPairCount$1(entries, axis) {
-  const ordered = entries.map((entry) => ({ min: entry.min[axis], max: entry.max[axis] })).sort((a2, b) => a2.min - b.min || a2.max - b.max);
-  const endValues = ordered.map((entry) => entry.max).sort((a2, b) => a2 - b);
-  let expired = 0;
-  let count = 0;
-  for (let seen2 = 0; seen2 < ordered.length; seen2 += 1) {
-    const currentMin = ordered[seen2].min;
-    while (expired < seen2 && endValues[expired] <= currentMin) expired += 1;
-    count += seen2 - expired;
-  }
-  return count;
+function shouldSkipPair(a2, b, options) {
+  if (options.skipIntraGroup && a2.groupName && a2.groupName === b.groupName) return true;
+  if (options.skipMockPairs && a2.mock && b.mock) return true;
+  return false;
 }
-function chooseSweepAxis$1(entries) {
-  let bestAxis = 0;
-  let bestCount = estimateSweepPairCount$1(entries, bestAxis);
-  for (const axis of [1, 2]) {
-    const count = estimateSweepPairCount$1(entries, axis);
-    if (count < bestCount) {
-      bestAxis = axis;
-      bestCount = count;
-    }
-  }
-  return bestAxis;
-}
-function collectCandidatePairs$1(entries) {
-  if (entries.length < 2) return { pairs: [], bboxPairChecks: 0 };
-  const axis = chooseSweepAxis$1(entries);
-  const ordered = entries.map((entry, index2) => ({ entry, index: index2 })).sort((a2, b) => a2.entry.min[axis] - b.entry.min[axis] || a2.entry.max[axis] - b.entry.max[axis] || a2.index - b.index);
-  let active = [];
-  const pairs = [];
-  let bboxPairChecks = 0;
-  for (const current of ordered) {
-    active = active.filter((candidate) => candidate.entry.max[axis] > current.entry.min[axis]);
-    for (const candidate of active) {
-      bboxPairChecks += 1;
-      if (!bboxOverlaps(candidate.entry, current.entry)) continue;
-      const sourceIndex = Math.min(candidate.index, current.index);
-      const targetIndex = Math.max(candidate.index, current.index);
-      pairs.push({ sourceIndex, targetIndex });
-    }
-    active.push(current);
-  }
-  pairs.sort((a2, b) => a2.sourceIndex - b.sourceIndex || a2.targetIndex - b.targetIndex);
-  return { pairs, bboxPairChecks };
+function collectCandidatePairs(entries, options) {
+  const index2 = new AabbSpatialIndex(entries, 1);
+  const result = index2.overlapPairs({
+    padding: options.bboxPadding,
+    skipPair: (a2, b) => shouldSkipPair(a2, b, options)
+  });
+  const pairs = result.pairs.map((pair) => ({
+    ...pair,
+    bboxOverlapVolume: aabbOverlapVolume(entries[pair.sourceIndex], entries[pair.targetIndex])
+  }));
+  pairs.sort((a2, b) => b.bboxOverlapVolume - a2.bboxOverlapVolume || a2.sourceIndex - b.sourceIndex || a2.targetIndex - b.targetIndex);
+  return { pairs, bboxPairChecks: result.stats.leafPairChecks };
 }
 function serializeCollisionFinding(finding) {
   return {
@@ -339540,14 +341780,32 @@ function serializeCollisionFinding(finding) {
   };
 }
 function analyzeCollisionIntersections(entries, rawOptions = {}) {
+  const maxCandidatePairs = rawOptions.maxCandidatePairs === void 0 ? null : Math.max(0, Math.trunc(rawOptions.maxCandidatePairs));
+  const maxElapsedMs = rawOptions.maxElapsedMs === void 0 ? null : Math.max(0, rawOptions.maxElapsedMs);
   const options = {
-    minOverlapVolume: rawOptions.minOverlapVolume ?? DEFAULT_COLLISION_INSPECTION_OPTIONS.minOverlapVolume
+    minOverlapVolume: rawOptions.minOverlapVolume ?? DEFAULT_COLLISION_INSPECTION_OPTIONS.minOverlapVolume,
+    maxCandidatePairs,
+    maxElapsedMs,
+    bboxPadding: Math.max(0, rawOptions.bboxPadding ?? 0),
+    skipIntraGroup: rawOptions.skipIntraGroup === true,
+    skipMockPairs: rawOptions.skipMockPairs === true,
+    includeBBoxCandidates: rawOptions.includeBBoxCandidates !== false
   };
   const warnings = [];
   const collisions = [];
   const preparedEntries = entries.map((entry) => prepareEntry(entry));
-  const { pairs: candidatePairs, bboxPairChecks } = collectCandidatePairs$1(preparedEntries);
-  for (const pair of candidatePairs) {
+  const { pairs: candidatePairs, bboxPairChecks } = collectCandidatePairs(preparedEntries, options);
+  const limitedCandidatePairs = options.maxCandidatePairs === null ? candidatePairs : candidatePairs.slice(0, options.maxCandidatePairs);
+  const pairLimitSkippedPairCount = candidatePairs.length - limitedCandidatePairs.length;
+  let testedPairCount = 0;
+  let timeBudgetStopped = false;
+  const exactStarted = performance.now();
+  for (const pair of limitedCandidatePairs) {
+    if (options.maxElapsedMs !== null && (options.maxElapsedMs <= 0 || performance.now() - exactStarted >= options.maxElapsedMs)) {
+      timeBudgetStopped = true;
+      break;
+    }
+    testedPairCount += 1;
     const a2 = preparedEntries[pair.sourceIndex];
     const b = preparedEntries[pair.targetIndex];
     try {
@@ -339572,6 +341830,40 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
       warnings.push(`Could not boolean-test ${a2.name} against ${b.name}: ${message}`);
     }
   }
+  const exactCheckMs = performance.now() - exactStarted;
+  const timeBudgetSkippedPairCount = timeBudgetStopped ? limitedCandidatePairs.length - testedPairCount : 0;
+  const skippedPairCount = pairLimitSkippedPairCount + timeBudgetSkippedPairCount;
+  const bboxCandidates = options.includeBBoxCandidates ? candidatePairs.map((pair, index2) => {
+    const source = preparedEntries[pair.sourceIndex];
+    const target = preparedEntries[pair.targetIndex];
+    const exactChecked = index2 < testedPairCount;
+    let skippedBy;
+    if (!exactChecked) {
+      skippedBy = index2 >= limitedCandidatePairs.length ? "pair-limit" : "time-budget";
+    }
+    return {
+      index: index2 + 1,
+      sourceIndex: pair.sourceIndex,
+      targetIndex: pair.targetIndex,
+      sourceId: source.id,
+      targetId: target.id,
+      sourceName: source.name,
+      targetName: target.name,
+      bboxOverlapVolume: pair.bboxOverlapVolume,
+      exactChecked,
+      ...skippedBy ? { skippedBy } : {}
+    };
+  }) : [];
+  if (pairLimitSkippedPairCount > 0) {
+    warnings.push(
+      `Collision check candidate set was limited to ${limitedCandidatePairs.length}/${candidatePairs.length} bbox-overlapping object pair(s); ${pairLimitSkippedPairCount} lower-priority pair(s) were skipped by maxCandidatePairs=${options.maxCandidatePairs}. Increase the collision pair limit for exhaustive checking.`
+    );
+  }
+  if (timeBudgetSkippedPairCount > 0) {
+    warnings.push(
+      `Collision check stopped after ${exactCheckMs.toFixed(0)} ms; tested ${testedPairCount}/${limitedCandidatePairs.length} selected bbox-overlapping object pair(s), skipping ${timeBudgetSkippedPairCount} by maxElapsedMs=${options.maxElapsedMs}. Increase the collision time budget for a deeper check.`
+    );
+  }
   const objects = preparedEntries.map((entry, index2) => ({
     index: index2,
     id: entry.id,
@@ -339580,482 +341872,33 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
     treePath: entry.treePath,
     mock: entry.mock === true,
     bbox: {
-      min: cloneVec3$1(entry.min),
-      max: cloneVec3$1(entry.max)
+      min: cloneVec3(entry.min),
+      max: cloneVec3(entry.max)
     }
   }));
   return {
     method: "boolean-intersection",
     options,
     broadphase: {
-      method: "sweep-and-prune",
+      method: "aabb-bvh",
       allPairCount: preparedEntries.length * (preparedEntries.length - 1) / 2,
       bboxPairChecks,
-      booleanPairChecks: candidatePairs.length
+      booleanPairChecks: testedPairCount
     },
     objectCount: objects.length,
+    candidatePairCount: candidatePairs.length,
+    testedPairCount,
+    skippedPairCount,
+    pairLimitSkippedPairCount,
+    timeBudgetSkippedPairCount,
+    exactCheckMs,
     collisionCount: collisions.length,
+    bboxCandidates,
     objects,
     collisions,
     warnings
   };
 }
-const DEFAULT_ROUGHNESS_INSPECTION_OPTIONS = {
-  smoothAngleDeg: 5,
-  sharpAngleDeg: 30,
-  harshAngleDeg: 90
-};
-const ROUGHNESS_COLORS = {
-  smooth: [62, 72, 84],
-  moderate: [255, 214, 0],
-  sharp: [255, 124, 34],
-  harsh: [255, 42, 96]
-};
-function resolveRoughnessInspectionOptions(raw = {}) {
-  const options = {
-    smoothAngleDeg: raw.smoothAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.smoothAngleDeg,
-    sharpAngleDeg: raw.sharpAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.sharpAngleDeg,
-    harshAngleDeg: raw.harshAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.harshAngleDeg
-  };
-  if (!Number.isFinite(options.smoothAngleDeg) || options.smoothAngleDeg < 0) {
-    throw new Error(`smoothAngleDeg must be a finite non-negative angle (got ${options.smoothAngleDeg}).`);
-  }
-  if (!Number.isFinite(options.sharpAngleDeg) || options.sharpAngleDeg <= options.smoothAngleDeg) {
-    throw new Error(`sharpAngleDeg must be greater than smoothAngleDeg (got ${options.sharpAngleDeg}).`);
-  }
-  if (!Number.isFinite(options.harshAngleDeg) || options.harshAngleDeg <= options.sharpAngleDeg || options.harshAngleDeg > 180) {
-    throw new Error(`harshAngleDeg must be greater than sharpAngleDeg and <= 180 (got ${options.harshAngleDeg}).`);
-  }
-  return options;
-}
-function roughnessClassForAngle(angleDeg, options) {
-  if (angleDeg >= options.harshAngleDeg) return "harsh";
-  if (angleDeg >= options.sharpAngleDeg) return "sharp";
-  if (angleDeg >= options.smoothAngleDeg) return "moderate";
-  return "smooth";
-}
-function roughnessScoreForAngle(angleDeg, options) {
-  if (angleDeg < options.sharpAngleDeg) return 0;
-  if (angleDeg < options.harshAngleDeg) {
-    return MathUtils.lerp(0.48, 0.82, (angleDeg - options.sharpAngleDeg) / (options.harshAngleDeg - options.sharpAngleDeg));
-  }
-  return 1;
-}
-function roughnessColorForAngle(angleDeg, options) {
-  const cls = roughnessClassForAngle(angleDeg, options);
-  if (cls === "smooth" || cls === "harsh") return ROUGHNESS_COLORS[cls];
-  if (cls === "moderate") {
-    return lerpRgb(
-      ROUGHNESS_COLORS.moderate,
-      ROUGHNESS_COLORS.sharp,
-      (angleDeg - options.smoothAngleDeg) / (options.sharpAngleDeg - options.smoothAngleDeg)
-    );
-  }
-  return lerpRgb(
-    ROUGHNESS_COLORS.sharp,
-    ROUGHNESS_COLORS.harsh,
-    (angleDeg - options.sharpAngleDeg) / (options.harshAngleDeg - options.sharpAngleDeg)
-  );
-}
-function lerpRgb(a2, b, t) {
-  const clamped = MathUtils.clamp(t, 0, 1);
-  return [
-    Math.round(MathUtils.lerp(a2[0], b[0], clamped)),
-    Math.round(MathUtils.lerp(a2[1], b[1], clamped)),
-    Math.round(MathUtils.lerp(a2[2], b[2], clamped))
-  ];
-}
-function emptyRoughnessSummary() {
-  return {
-    triangleCount: 0,
-    edgeCount: 0,
-    boundaryEdgeCount: 0,
-    nonManifoldEdgeCount: 0,
-    smoothAreaPercent: 0,
-    moderateAreaPercent: 0,
-    sharpAreaPercent: 0,
-    harshAreaPercent: 0,
-    roughAreaPercent: 0,
-    meanAngleDeg: null,
-    p50AngleDeg: null,
-    p90AngleDeg: null,
-    p95AngleDeg: null,
-    p99AngleDeg: null,
-    maxAngleDeg: null,
-    qualityScore: 0
-  };
-}
-function summarizeRoughnessTriangles(triangles, edgeAngles, edgeCount, boundaryEdgeCount, nonManifoldEdgeCount, options) {
-  const areaByClass = {
-    smooth: 0,
-    moderate: 0,
-    sharp: 0,
-    harsh: 0
-  };
-  let totalArea = 0;
-  for (const tri of triangles) {
-    const area2 = Number.isFinite(tri.area) ? tri.area : 0;
-    totalArea += area2;
-    areaByClass[roughnessClassForAngle(tri.maxAngleDeg, options)] += area2;
-  }
-  const sortedAngles = [...edgeAngles].sort((lhs, rhs) => lhs - rhs);
-  const meanAngleDeg = sortedAngles.length > 0 ? Number((sortedAngles.reduce((sum2, angle) => sum2 + angle, 0) / sortedAngles.length).toFixed(2)) : null;
-  const qualityScore = totalArea > 0 ? Math.round(
-    MathUtils.clamp(
-      100 * (areaByClass.smooth + areaByClass.moderate * 0.9) / totalArea - 50 * areaByClass.harsh / totalArea,
-      0,
-      100
-    )
-  ) : 0;
-  const safePercent = (value) => totalArea > 0 ? Number((value / totalArea * 100).toFixed(2)) : 0;
-  return {
-    triangleCount: triangles.length,
-    edgeCount,
-    boundaryEdgeCount,
-    nonManifoldEdgeCount,
-    smoothAreaPercent: safePercent(areaByClass.smooth),
-    moderateAreaPercent: safePercent(areaByClass.moderate),
-    sharpAreaPercent: safePercent(areaByClass.sharp),
-    harshAreaPercent: safePercent(areaByClass.harsh),
-    roughAreaPercent: safePercent(areaByClass.sharp + areaByClass.harsh),
-    meanAngleDeg,
-    p50AngleDeg: percentile(sortedAngles, 0.5),
-    p90AngleDeg: percentile(sortedAngles, 0.9),
-    p95AngleDeg: percentile(sortedAngles, 0.95),
-    p99AngleDeg: percentile(sortedAngles, 0.99),
-    maxAngleDeg: sortedAngles.length > 0 ? Number(sortedAngles[sortedAngles.length - 1].toFixed(2)) : null,
-    qualityScore
-  };
-}
-function percentile(sorted, q) {
-  if (sorted.length === 0) return null;
-  const index2 = MathUtils.clamp(Math.floor(sorted.length * q), 0, sorted.length - 1);
-  return Number(sorted[index2].toFixed(2));
-}
-const DEG_PER_RAD = 180 / Math.PI;
-function analyzeRoughnessGeometry(sourceGeometry, rawOptions = {}) {
-  const options = resolveRoughnessInspectionOptions(rawOptions);
-  const geometry = sourceGeometry.index ? sourceGeometry.toNonIndexed() : sourceGeometry.clone();
-  const position = geometry.getAttribute("position");
-  const warnings = [];
-  if (!position || position.count < 3) {
-    return { geometry, summary: emptyRoughnessSummary(), warnings: ["No triangle geometry."] };
-  }
-  const triangleCount = Math.floor(position.count / 3);
-  const normals = new Array(triangleCount);
-  const triangles = new Array(triangleCount);
-  const edges = /* @__PURE__ */ new Map();
-  const colors = new Float32Array(position.count * 3);
-  const scores = new Float32Array(position.count);
-  const a2 = new Vector3();
-  const b = new Vector3();
-  const c2 = new Vector3();
-  const ac = new Vector3();
-  const normal = new Vector3();
-  const bbox = new Box3().setFromBufferAttribute(position);
-  const snap = Math.max(1e-6, bbox.getSize(new Vector3()).length() * 1e-8);
-  for (let tri = 0; tri < triangleCount; tri += 1) {
-    const offset2 = tri * 3;
-    readVertex(position, offset2, a2);
-    readVertex(position, offset2 + 1, b);
-    readVertex(position, offset2 + 2, c2);
-    normal.subVectors(b, a2).cross(ac.subVectors(c2, a2));
-    const areaTwice = normal.length();
-    triangles[tri] = { area: areaTwice * 0.5, maxAngleDeg: 0 };
-    normals[tri] = areaTwice > 1e-12 ? normal.multiplyScalar(1 / areaTwice).clone() : new Vector3(0, 0, 1);
-    const keys = [vertexKey(a2, snap), vertexKey(b, snap), vertexKey(c2, snap)];
-    for (let edge = 0; edge < 3; edge += 1) {
-      const key = edgeKey(keys[edge], keys[(edge + 1) % 3]);
-      let record = edges.get(key);
-      if (!record) {
-        record = { triangles: [] };
-        edges.set(key, record);
-      }
-      record.triangles.push(tri);
-    }
-  }
-  const { boundaryEdgeCount, nonManifoldEdgeCount, edgeAngles } = markTriangleRoughness(edges, triangles, normals);
-  if (boundaryEdgeCount > 0) warnings.push(`${boundaryEdgeCount} boundary edge(s) were treated as harsh roughness.`);
-  if (nonManifoldEdgeCount > 0) warnings.push(`${nonManifoldEdgeCount} non-manifold edge(s) were treated as harsh roughness.`);
-  for (let tri = 0; tri < triangleCount; tri += 1) {
-    const { maxAngleDeg } = triangles[tri];
-    const color = roughnessColorForAngle(maxAngleDeg, options);
-    const score = roughnessScoreForAngle(maxAngleDeg, options);
-    const offset2 = tri * 3;
-    for (let vertex2 = 0; vertex2 < 3; vertex2 += 1) {
-      const colorOffset = (offset2 + vertex2) * 3;
-      colors[colorOffset] = color[0] / 255;
-      colors[colorOffset + 1] = color[1] / 255;
-      colors[colorOffset + 2] = color[2] / 255;
-      scores[offset2 + vertex2] = score;
-    }
-  }
-  geometry.setAttribute("color", new BufferAttribute(colors, 3));
-  geometry.setAttribute("roughnessScore", new BufferAttribute(scores, 1));
-  geometry.computeBoundingBox();
-  return {
-    geometry,
-    summary: summarizeRoughnessTriangles(triangles, edgeAngles, edges.size, boundaryEdgeCount, nonManifoldEdgeCount, options),
-    warnings
-  };
-}
-function markTriangleRoughness(edges, triangles, normals) {
-  const edgeAngles = [];
-  let boundaryEdgeCount = 0;
-  let nonManifoldEdgeCount = 0;
-  for (const edge of edges.values()) {
-    if (edge.triangles.length === 1) {
-      boundaryEdgeCount += 1;
-      markTriangles(edge.triangles, triangles, 180);
-      edgeAngles.push(180);
-      continue;
-    }
-    if (edge.triangles.length > 2) {
-      nonManifoldEdgeCount += 1;
-      markTriangles(edge.triangles, triangles, 180);
-      edgeAngles.push(180);
-      continue;
-    }
-    const [first, second] = edge.triangles;
-    const dot2 = MathUtils.clamp(normals[first].dot(normals[second]), -1, 1);
-    const angleDeg = Math.acos(dot2) * DEG_PER_RAD;
-    markTriangles(edge.triangles, triangles, angleDeg);
-    edgeAngles.push(angleDeg);
-  }
-  return { boundaryEdgeCount, nonManifoldEdgeCount, edgeAngles };
-}
-function readVertex(position, index2, target) {
-  target.set(position.getX(index2), position.getY(index2), position.getZ(index2));
-}
-function vertexKey(point2, snap) {
-  return `${Math.round(point2.x / snap)},${Math.round(point2.y / snap)},${Math.round(point2.z / snap)}`;
-}
-function edgeKey(a2, b) {
-  return a2 < b ? `${a2}|${b}` : `${b}|${a2}`;
-}
-function markTriangles(indices, triangles, angleDeg) {
-  for (const index2 of indices) {
-    triangles[index2].maxAngleDeg = Math.max(triangles[index2].maxAngleDeg, angleDeg);
-  }
-}
-const DEFAULT_THICKNESS_INSPECTION_OPTIONS = {
-  minThickness: 1.2,
-  warnThickness: 2,
-  maxThickness: 6,
-  maxSamplesPerObject: 5e3
-};
-const THICKNESS_COLORS = {
-  critical: [255, 28, 28],
-  warning: [255, 150, 0],
-  ok: [60, 220, 90],
-  thick: [70, 145, 255],
-  unknown: [90, 90, 90]
-};
-function finitePositive(value, fallback, label) {
-  if (value === void 0) return fallback;
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new Error(`${label} must be a positive finite number.`);
-  }
-  return value;
-}
-function resolveThicknessInspectionOptions(raw = {}) {
-  const minThickness = finitePositive(raw.minThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.minThickness, "minThickness");
-  const warnThickness = finitePositive(raw.warnThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.warnThickness, "warnThickness");
-  const maxThickness = finitePositive(raw.maxThickness, DEFAULT_THICKNESS_INSPECTION_OPTIONS.maxThickness, "maxThickness");
-  const maxSamplesPerObject = finitePositive(
-    raw.maxSamplesPerObject,
-    DEFAULT_THICKNESS_INSPECTION_OPTIONS.maxSamplesPerObject,
-    "maxSamplesPerObject"
-  );
-  if (minThickness > warnThickness) {
-    throw new Error("minThickness must be less than or equal to warnThickness.");
-  }
-  if (warnThickness > maxThickness) {
-    throw new Error("warnThickness must be less than or equal to maxThickness.");
-  }
-  return {
-    minThickness,
-    warnThickness,
-    maxThickness,
-    maxSamplesPerObject: Math.max(1, Math.floor(maxSamplesPerObject))
-  };
-}
-function lerp(a2, b, t) {
-  return a2 + (b - a2) * Math.max(0, Math.min(1, t));
-}
-function lerpColor(a2, b, t) {
-  return [Math.round(lerp(a2[0], b[0], t)), Math.round(lerp(a2[1], b[1], t)), Math.round(lerp(a2[2], b[2], t))];
-}
-function thicknessClass(thickness, options) {
-  if (thickness == null || !Number.isFinite(thickness) || thickness <= 0) return "unknown";
-  if (thickness <= options.minThickness) return "critical";
-  if (thickness <= options.warnThickness) return "warning";
-  if (thickness <= options.maxThickness) return "ok";
-  return "thick";
-}
-function thicknessColor(thickness, options) {
-  const cls = thicknessClass(thickness, options);
-  if (cls === "unknown") return THICKNESS_COLORS.unknown;
-  if (cls === "critical") return THICKNESS_COLORS.critical;
-  if (cls === "warning") {
-    const span = Math.max(1e-9, options.warnThickness - options.minThickness);
-    return lerpColor(THICKNESS_COLORS.critical, THICKNESS_COLORS.warning, ((thickness ?? 0) - options.minThickness) / span);
-  }
-  if (cls === "ok") {
-    const span = Math.max(1e-9, options.maxThickness - options.warnThickness);
-    return lerpColor(THICKNESS_COLORS.ok, THICKNESS_COLORS.thick, ((thickness ?? 0) - options.warnThickness) / span);
-  }
-  return THICKNESS_COLORS.thick;
-}
-function sampleArea(sample) {
-  const area2 = sample.area ?? 1;
-  return Number.isFinite(area2) && area2 > 0 ? area2 : 1;
-}
-function weightedQuantile(samples, q) {
-  if (samples.length === 0) return null;
-  const sorted = [...samples].sort((a2, b) => a2.thickness - b.thickness);
-  const totalArea = sorted.reduce((sum2, sample) => sum2 + sample.area, 0);
-  const target = totalArea * Math.max(0, Math.min(1, q));
-  let cumulative = 0;
-  for (const sample of sorted) {
-    cumulative += sample.area;
-    if (cumulative >= target) return sample.thickness;
-  }
-  return sorted[sorted.length - 1].thickness;
-}
-function percent(part, total) {
-  if (total <= 0) return 0;
-  return part / total * 100;
-}
-function summarizeThicknessSamples(samples, options) {
-  const resolved = [];
-  let totalArea = 0;
-  let resolvedArea = 0;
-  let unresolvedArea = 0;
-  let criticalArea = 0;
-  let warningArea = 0;
-  let weightedSum = 0;
-  for (const sample of samples) {
-    const area2 = sampleArea(sample);
-    totalArea += area2;
-    const value = sample.thickness;
-    if (value == null || !Number.isFinite(value) || value <= 0) {
-      unresolvedArea += area2;
-      continue;
-    }
-    resolved.push({ thickness: value, area: area2 });
-    resolvedArea += area2;
-    weightedSum += value * area2;
-    if (value <= options.minThickness) {
-      criticalArea += area2;
-    } else if (value <= options.warnThickness) {
-      warningArea += area2;
-    }
-  }
-  const values = resolved.map((sample) => sample.thickness);
-  return {
-    sampleCount: samples.length,
-    resolvedCount: resolved.length,
-    unresolvedCount: samples.length - resolved.length,
-    minThickness: values.length > 0 ? Math.min(...values) : null,
-    p05Thickness: weightedQuantile(resolved, 0.05),
-    medianThickness: weightedQuantile(resolved, 0.5),
-    meanThickness: resolvedArea > 0 ? weightedSum / resolvedArea : null,
-    maxThickness: values.length > 0 ? Math.max(...values) : null,
-    criticalAreaPercent: percent(criticalArea, resolvedArea),
-    warningAreaPercent: percent(warningArea, resolvedArea),
-    belowWarnAreaPercent: percent(criticalArea + warningArea, resolvedArea),
-    unresolvedAreaPercent: percent(unresolvedArea, totalArea)
-  };
-}
-function cloneGeometryForFaceColors(geometry) {
-  return geometry.index ? geometry.toNonIndexed() : geometry.clone();
-}
-function geometryMaxDimension(geometry) {
-  geometry.computeBoundingBox();
-  const box2 = geometry.boundingBox;
-  if (!box2) return 1;
-  const size = new Vector3();
-  box2.getSize(size);
-  return Math.max(1, size.x, size.y, size.z);
-}
-function firstOppositeSurfaceDistance(raycaster, mesh, point2, direction2, epsilon2, far) {
-  const origin = point2.clone().addScaledVector(direction2, epsilon2);
-  raycaster.set(origin, direction2);
-  raycaster.near = epsilon2;
-  raycaster.far = far;
-  const hit = raycaster.intersectObject(mesh, false).find((entry) => entry.distance > epsilon2);
-  return hit ? hit.distance + epsilon2 : null;
-}
-function triangleThickness(raycaster, mesh, centroid, normal, epsilon2, far) {
-  const forward = firstOppositeSurfaceDistance(raycaster, mesh, centroid, normal, epsilon2, far);
-  const backward = firstOppositeSurfaceDistance(raycaster, mesh, centroid, normal.clone().negate(), epsilon2, far);
-  if (forward == null) return backward;
-  if (backward == null) return forward;
-  return Math.min(forward, backward);
-}
-function analyzeThicknessGeometry(sourceGeometry, rawOptions = {}) {
-  const options = resolveThicknessInspectionOptions(rawOptions);
-  const geometry = cloneGeometryForFaceColors(sourceGeometry);
-  const position = geometry.getAttribute("position");
-  if (!position || position.count < 3) {
-    return { geometry, samples: [], triangleCount: 0, sampledTriangleCount: 0, sampleStride: 1, warnings: ["No triangle geometry."] };
-  }
-  const triangleCount = Math.floor(position.count / 3);
-  const sampleStride = Math.max(1, Math.ceil(triangleCount / options.maxSamplesPerObject));
-  const maxDim = geometryMaxDimension(geometry);
-  const epsilon2 = Math.max(1e-4, maxDim * 1e-6);
-  const far = Math.max(maxDim * 4, options.maxThickness * 4, 1);
-  const colors = new Float32Array(position.count * 3);
-  const samples = [];
-  const warnings = [];
-  const rayMaterial = new MeshBasicMaterial({ side: DoubleSide });
-  const rayMesh = new Mesh(geometry, rayMaterial);
-  const raycaster = new Raycaster();
-  if (sampleStride > 1) {
-    warnings.push(`Triangle sampling stride ${sampleStride}; increase --thickness-samples for denser analysis.`);
-  }
-  const a2 = new Vector3();
-  const b = new Vector3();
-  const c2 = new Vector3();
-  const ac = new Vector3();
-  const normal = new Vector3();
-  const centroid = new Vector3();
-  let sampledTriangleCount = 0;
-  let lastThickness = null;
-  for (let tri = 0; tri < triangleCount; tri += 1) {
-    const offset2 = tri * 3;
-    a2.fromBufferAttribute(position, offset2);
-    b.fromBufferAttribute(position, offset2 + 1);
-    c2.fromBufferAttribute(position, offset2 + 2);
-    normal.subVectors(b, a2).cross(ac.subVectors(c2, a2));
-    const areaTwice = normal.length();
-    const area2 = areaTwice * 0.5;
-    let thickness = lastThickness;
-    if (tri % sampleStride === 0) {
-      sampledTriangleCount += 1;
-      if (areaTwice <= 1e-12) {
-        thickness = null;
-      } else {
-        normal.multiplyScalar(1 / areaTwice);
-        centroid.copy(a2).add(b).add(c2).multiplyScalar(1 / 3);
-        thickness = triangleThickness(raycaster, rayMesh, centroid, normal, epsilon2, far);
-      }
-      lastThickness = thickness;
-      samples.push({ thickness, area: area2 });
-    }
-    const color = thicknessColor(thickness, options);
-    for (let vertex2 = 0; vertex2 < 3; vertex2 += 1) {
-      const colorOffset = (offset2 + vertex2) * 3;
-      colors[colorOffset] = color[0] / 255;
-      colors[colorOffset + 1] = color[1] / 255;
-      colors[colorOffset + 2] = color[2] / 255;
-    }
-  }
-  geometry.setAttribute("color", new BufferAttribute(colors, 3));
-  rayMaterial.dispose();
-  return { geometry, samples, triangleCount, sampledTriangleCount, sampleStride, warnings };
-}
 const VECTOR_KEYS = /* @__PURE__ */ new Set(["pos", "position", "target", "lookat", "aim", "up"]);
 const roundNumber = (value, digits) => {
   const scale2 = 10 ** digits;
@@ -340227,494 +342070,6 @@ function localAabbPlaneRelation(min2, max2, plane, eps = 1e-7) {
   if (minDistance > -eps) return "positive";
   return "crossing";
 }
-const DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS = {
-  contactTolerance: 0.05,
-  minOverlapVolume: 0.1,
-  exactGeometry: false
-};
-const AXIS_NAMES = ["x", "y", "z"];
-class UnionFind {
-  constructor(size) {
-    __publicField(this, "parent");
-    __publicField(this, "rank");
-    this.parent = Array.from({ length: size }, (_2, index2) => index2);
-    this.rank = Array.from({ length: size }, () => 0);
-  }
-  find(value) {
-    const parent = this.parent[value];
-    if (parent === value) return value;
-    const root = this.find(parent);
-    this.parent[value] = root;
-    return root;
-  }
-  union(a2, b) {
-    const rootA = this.find(a2);
-    const rootB = this.find(b);
-    if (rootA === rootB) return;
-    if (this.rank[rootA] < this.rank[rootB]) {
-      this.parent[rootA] = rootB;
-      return;
-    }
-    if (this.rank[rootA] > this.rank[rootB]) {
-      this.parent[rootB] = rootA;
-      return;
-    }
-    this.parent[rootB] = rootA;
-    this.rank[rootA] += 1;
-  }
-}
-function cloneVec3(value) {
-  return [value[0], value[1], value[2]];
-}
-function emptyBBox() {
-  return {
-    min: [Infinity, Infinity, Infinity],
-    max: [-Infinity, -Infinity, -Infinity]
-  };
-}
-function expandBBox(target, min2, max2) {
-  for (let axis = 0; axis < 3; axis += 1) {
-    target.min[axis] = Math.min(target.min[axis], min2[axis]);
-    target.max[axis] = Math.max(target.max[axis], max2[axis]);
-  }
-}
-function intervalGap$1(aMin, aMax, bMin, bMax) {
-  if (aMax < bMin) return bMin - aMax;
-  if (bMax < aMin) return aMin - bMax;
-  return 0;
-}
-function nearestBoundaryGap(a2, b, axis) {
-  return Math.min(Math.abs(a2.max[axis] - b.min[axis]), Math.abs(b.max[axis] - a2.min[axis]));
-}
-function bboxGaps(a2, b) {
-  return [
-    intervalGap$1(a2.min[0], a2.max[0], b.min[0], b.max[0]),
-    intervalGap$1(a2.min[1], a2.max[1], b.min[1], b.max[1]),
-    intervalGap$1(a2.min[2], a2.max[2], b.min[2], b.max[2])
-  ];
-}
-function maxGap(gaps) {
-  return Math.max(gaps[0], gaps[1], gaps[2]);
-}
-function hasPositiveGap(gaps) {
-  return gaps[0] > 0 || gaps[1] > 0 || gaps[2] > 0;
-}
-function bboxInteriorOverlaps(a2, b) {
-  for (let axis = 0; axis < 3; axis += 1) {
-    if (Math.min(a2.max[axis], b.max[axis]) - Math.max(a2.min[axis], b.min[axis]) <= 0) return false;
-  }
-  return true;
-}
-function bboxOverlapVolume(a2, b) {
-  let volume = 1;
-  for (let axis = 0; axis < 3; axis += 1) {
-    volume *= Math.max(0, Math.min(a2.max[axis], b.max[axis]) - Math.max(a2.min[axis], b.min[axis]));
-  }
-  return volume;
-}
-function estimateSweepPairCount(entries, axis, tolerance) {
-  const ordered = entries.map((entry) => ({ min: entry.min[axis], max: entry.max[axis] })).sort((a2, b) => a2.min - b.min || a2.max - b.max);
-  const endValues = ordered.map((entry) => entry.max + tolerance).sort((a2, b) => a2 - b);
-  let expired = 0;
-  let count = 0;
-  for (let seen2 = 0; seen2 < ordered.length; seen2 += 1) {
-    const currentMin = ordered[seen2].min;
-    while (expired < seen2 && endValues[expired] < currentMin) expired += 1;
-    count += seen2 - expired;
-  }
-  return count;
-}
-function chooseSweepAxis(entries, tolerance) {
-  let bestAxis = 0;
-  let bestCount = estimateSweepPairCount(entries, bestAxis, tolerance);
-  for (const axis of [1, 2]) {
-    const count = estimateSweepPairCount(entries, axis, tolerance);
-    if (count < bestCount) {
-      bestAxis = axis;
-      bestCount = count;
-    }
-  }
-  return bestAxis;
-}
-function collectCandidatePairs(entries, tolerance) {
-  if (entries.length < 2) return [];
-  const axis = chooseSweepAxis(entries, tolerance);
-  const ordered = entries.map((entry, index2) => ({ entry, index: index2 })).sort((a2, b) => a2.entry.min[axis] - b.entry.min[axis] || a2.entry.max[axis] - b.entry.max[axis] || a2.index - b.index);
-  let active = [];
-  const pairs = [];
-  for (const current of ordered) {
-    active = active.filter((candidate) => candidate.entry.max[axis] + tolerance >= current.entry.min[axis]);
-    for (const candidate of active) {
-      const gaps = bboxGaps(candidate.entry, current.entry);
-      if (maxGap(gaps) > tolerance) continue;
-      const sourceIndex = Math.min(candidate.index, current.index);
-      const targetIndex = Math.max(candidate.index, current.index);
-      pairs.push({ sourceIndex, targetIndex, gaps });
-    }
-    active.push(current);
-  }
-  pairs.sort((a2, b) => a2.sourceIndex - b.sourceIndex || a2.targetIndex - b.targetIndex);
-  return pairs;
-}
-function contactFromBBoxes(a2, b, tolerance) {
-  const gaps = bboxGaps(a2, b);
-  const largestGap = maxGap(gaps);
-  if (largestGap > tolerance) return { touching: false, gap: largestGap };
-  const separatedAxes = gaps.map((gap, axis) => ({ gap, axis })).filter((entry) => entry.gap > 0);
-  if (separatedAxes.length > 0) {
-    const nearest2 = separatedAxes.reduce((best, entry) => entry.gap > best.gap ? entry : best, separatedAxes[0]);
-    return { touching: true, gap: nearest2.gap, axis: AXIS_NAMES[nearest2.axis] };
-  }
-  const boundaryAxes = AXIS_NAMES.map((axisName, axis) => ({
-    axis,
-    axisName,
-    gap: nearestBoundaryGap(a2, b, axis)
-  })).filter((entry) => entry.gap <= tolerance);
-  if (boundaryAxes.length === 0) return { touching: false, gap: 0 };
-  const nearest = boundaryAxes.reduce((best, entry) => entry.gap < best.gap ? entry : best, boundaryAxes[0]);
-  return { touching: true, gap: nearest.gap, axis: nearest.axisName };
-}
-function intersectionVolume(a2, b) {
-  try {
-    const hit = a2.shape.intersect(b.shape);
-    if (hit.isEmpty()) return { volume: 0 };
-    const volume = hit.volume();
-    return { volume: Number.isFinite(volume) ? volume : 0 };
-  } catch (err2) {
-    const message = err2 instanceof Error ? err2.message : String(err2);
-    return { volume: null, warning: `Could not boolean-test ${a2.name} against ${b.name}: ${message}` };
-  }
-}
-function bodyCountForEntry(entry) {
-  if (typeof entry.bodyCount === "number" && Number.isFinite(entry.bodyCount)) {
-    return Math.max(0, Math.round(entry.bodyCount));
-  }
-  return 1;
-}
-function makeEdge(entries, sourceIndex, targetIndex, edge) {
-  const source = entries[sourceIndex];
-  const target = entries[targetIndex];
-  return {
-    sourceIndex,
-    targetIndex,
-    sourceId: source.id,
-    targetId: target.id,
-    sourceName: source.name,
-    targetName: target.name,
-    ...edge
-  };
-}
-function analyzePhysicalConnectivity(entries, rawOptions = {}) {
-  const options = {
-    contactTolerance: rawOptions.contactTolerance ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.contactTolerance,
-    minOverlapVolume: rawOptions.minOverlapVolume ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.minOverlapVolume,
-    exactGeometry: rawOptions.exactGeometry ?? DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS.exactGeometry
-  };
-  const warnings = [];
-  const edges = [];
-  const unionFind = new UnionFind(entries.length);
-  for (const pair of collectCandidatePairs(entries, options.contactTolerance)) {
-    const i = pair.sourceIndex;
-    const j = pair.targetIndex;
-    const a2 = entries[i];
-    const b = entries[j];
-    const bboxOverlaps2 = !hasPositiveGap(pair.gaps) && bboxInteriorOverlaps(a2, b);
-    if (options.exactGeometry && bboxOverlaps2) {
-      const overlap = intersectionVolume(a2, b);
-      if (overlap.warning) warnings.push(overlap.warning);
-      if (overlap.volume != null && overlap.volume > options.minOverlapVolume) {
-        unionFind.union(i, j);
-        edges.push(
-          makeEdge(entries, i, j, {
-            kind: "overlap",
-            method: "boolean-intersection",
-            gap: 0,
-            overlapVolume: overlap.volume
-          })
-        );
-        continue;
-      }
-      if (overlap.volume != null && overlap.volume > 0) {
-        unionFind.union(i, j);
-        edges.push(
-          makeEdge(entries, i, j, {
-            kind: "touching",
-            method: "boolean-intersection",
-            gap: 0,
-            overlapVolume: overlap.volume
-          })
-        );
-        continue;
-      }
-    }
-    if (bboxOverlaps2) {
-      unionFind.union(i, j);
-      edges.push(
-        makeEdge(entries, i, j, {
-          kind: "overlap",
-          method: "bbox-overlap",
-          gap: 0,
-          overlapVolume: bboxOverlapVolume(a2, b)
-        })
-      );
-    } else {
-      const contact = contactFromBBoxes(a2, b, options.contactTolerance);
-      if (!contact.touching) continue;
-      unionFind.union(i, j);
-      edges.push(
-        makeEdge(entries, i, j, {
-          kind: "touching",
-          method: "bbox-contact",
-          gap: contact.gap,
-          axis: contact.axis
-        })
-      );
-    }
-  }
-  const objects = entries.map((entry, index2) => ({
-    index: index2,
-    id: entry.id,
-    name: entry.name,
-    groupName: entry.groupName,
-    treePath: entry.treePath,
-    mock: entry.mock === true,
-    bodyCount: bodyCountForEntry(entry),
-    bbox: {
-      min: cloneVec3(entry.min),
-      max: cloneVec3(entry.max)
-    },
-    componentIndex: 0
-  }));
-  const componentByRoot = /* @__PURE__ */ new Map();
-  const rootToComponentIndex = /* @__PURE__ */ new Map();
-  for (let objectIndex = 0; objectIndex < objects.length; objectIndex += 1) {
-    const root = unionFind.find(objectIndex);
-    let component = componentByRoot.get(root);
-    if (!component) {
-      component = {
-        index: componentByRoot.size + 1,
-        objectIndexes: [],
-        objectIds: [],
-        objectNames: [],
-        objectCount: 0,
-        bodyCount: 0,
-        bbox: emptyBBox()
-      };
-      componentByRoot.set(root, component);
-      rootToComponentIndex.set(root, component.index);
-    }
-    const object = objects[objectIndex];
-    object.componentIndex = rootToComponentIndex.get(root) ?? component.index;
-    component.objectIndexes.push(object.index);
-    component.objectIds.push(object.id);
-    component.objectNames.push(object.name);
-    component.objectCount += 1;
-    component.bodyCount += object.bodyCount;
-    expandBBox(component.bbox, object.bbox.min, object.bbox.max);
-  }
-  const components = [...componentByRoot.values()];
-  return {
-    method: options.exactGeometry ? "boolean-overlap-plus-bbox-contact" : "bbox-neighborhood",
-    options,
-    objectCount: objects.length,
-    componentCount: components.length,
-    objects,
-    components,
-    edges,
-    warnings
-  };
-}
-const EPSILON = 1e-9;
-function intervalGap(aMin, aMax, bMin, bMax) {
-  if (aMax < bMin) return bMin - aMax;
-  if (bMax < aMin) return aMin - bMax;
-  return 0;
-}
-function bboxGap(a2, b) {
-  const axisGaps = [
-    intervalGap(a2.bbox.min[0], a2.bbox.max[0], b.bbox.min[0], b.bbox.max[0]),
-    intervalGap(a2.bbox.min[1], a2.bbox.max[1], b.bbox.min[1], b.bbox.max[1]),
-    intervalGap(a2.bbox.min[2], a2.bbox.max[2], b.bbox.min[2], b.bbox.max[2])
-  ];
-  const gap = Math.sqrt(axisGaps[0] ** 2 + axisGaps[1] ** 2 + axisGaps[2] ** 2);
-  return { gap, axisGaps };
-}
-function bboxVolume(component) {
-  const dx = Math.max(0, component.bbox.max[0] - component.bbox.min[0]);
-  const dy = Math.max(0, component.bbox.max[1] - component.bbox.min[1]);
-  const dz = Math.max(0, component.bbox.max[2] - component.bbox.min[2]);
-  return dx * dy * dz;
-}
-function compareDefaultRoot(a2, b) {
-  if (a2.bodyCount !== b.bodyCount) return a2.bodyCount - b.bodyCount;
-  if (a2.objectCount !== b.objectCount) return a2.objectCount - b.objectCount;
-  const volumeDelta = bboxVolume(a2) - bboxVolume(b);
-  if (Math.abs(volumeDelta) > EPSILON) return volumeDelta;
-  return b.index - a2.index;
-}
-function defaultRootComponentIndex(components) {
-  if (components.length === 0) return null;
-  return components.reduce((best, component) => compareDefaultRoot(component, best) > 0 ? component : best, components[0]).index;
-}
-function componentPositionByIndex(components) {
-  return new Map(components.map((component, position) => [component.index, position]));
-}
-function computeNearestComponents(components) {
-  const nearest = components.map(() => ({ nearestGap: null, nearestComponentIndex: null }));
-  for (let sourcePosition = 0; sourcePosition < components.length; sourcePosition += 1) {
-    for (let targetPosition = sourcePosition + 1; targetPosition < components.length; targetPosition += 1) {
-      const sourceComponent = components[sourcePosition];
-      const targetComponent = components[targetPosition];
-      const edge = bboxGap(sourceComponent, targetComponent);
-      if (!Number.isFinite(edge.gap)) continue;
-      const source = nearest[sourcePosition];
-      if (source.nearestGap == null || edge.gap < source.nearestGap - EPSILON || Math.abs(edge.gap - source.nearestGap) <= EPSILON && targetComponent.index < (source.nearestComponentIndex ?? Infinity)) {
-        source.nearestGap = edge.gap;
-        source.nearestComponentIndex = targetComponent.index;
-      }
-      const target = nearest[targetPosition];
-      if (target.nearestGap == null || edge.gap < target.nearestGap - EPSILON || Math.abs(edge.gap - target.nearestGap) <= EPSILON && sourceComponent.index < (target.nearestComponentIndex ?? Infinity)) {
-        target.nearestGap = edge.gap;
-        target.nearestComponentIndex = sourceComponent.index;
-      }
-    }
-  }
-  return nearest;
-}
-function computeRootDistances(components, rootComponentIndex) {
-  if (rootComponentIndex == null) return [];
-  const positions = componentPositionByIndex(components);
-  const rootPosition = positions.get(rootComponentIndex);
-  if (rootPosition == null) {
-    throw new Error(`rootComponentIndex ${rootComponentIndex} does not match any physical component`);
-  }
-  const visited = components.map(() => false);
-  const distances = components.map(() => Infinity);
-  const parents = components.map(() => null);
-  const parentGaps = components.map(() => null);
-  distances[rootPosition] = 0;
-  for (; ; ) {
-    let current = -1;
-    for (let i = 0; i < components.length; i += 1) {
-      if (visited[i]) continue;
-      if (current === -1 || distances[i] < distances[current] - EPSILON || Math.abs(distances[i] - distances[current]) <= EPSILON && components[i].index < components[current].index) {
-        current = i;
-      }
-    }
-    if (current === -1 || !Number.isFinite(distances[current])) break;
-    visited[current] = true;
-    for (let targetPosition = 0; targetPosition < components.length; targetPosition += 1) {
-      if (visited[targetPosition] || targetPosition === current) continue;
-      const edge = bboxGap(components[current], components[targetPosition]);
-      if (!Number.isFinite(edge.gap)) continue;
-      const nextDistance = distances[current] + edge.gap;
-      if (nextDistance < distances[targetPosition] - EPSILON || Math.abs(nextDistance - distances[targetPosition]) <= EPSILON && components[current].index < (parents[targetPosition] ?? Infinity)) {
-        distances[targetPosition] = nextDistance;
-        parents[targetPosition] = components[current].index;
-        parentGaps[targetPosition] = edge.gap;
-      }
-    }
-  }
-  return components.map((_2, position) => ({
-    rootDistance: distances[position],
-    parentComponentIndex: parents[position],
-    parentGap: parentGaps[position]
-  }));
-}
-function makeGapEdge(source, target) {
-  const gap = bboxGap(source, target);
-  return {
-    sourceComponentIndex: source.index,
-    targetComponentIndex: target.index,
-    sourceObjectNames: [...source.objectNames],
-    targetObjectNames: [...target.objectNames],
-    gap: gap.gap,
-    axisGaps: gap.axisGaps
-  };
-}
-function compactGapEdges(components, nearest, rooted) {
-  const componentByIndex = new Map(components.map((component) => [component.index, component]));
-  const seen2 = /* @__PURE__ */ new Set();
-  const edges = [];
-  const add2 = (sourceIndex, targetIndex) => {
-    if (targetIndex == null || sourceIndex === targetIndex) return;
-    const source = componentByIndex.get(Math.min(sourceIndex, targetIndex));
-    const target = componentByIndex.get(Math.max(sourceIndex, targetIndex));
-    if (!source || !target) return;
-    const key = `${source.index}:${target.index}`;
-    if (seen2.has(key)) return;
-    seen2.add(key);
-    edges.push(makeGapEdge(source, target));
-  };
-  components.forEach((component, position) => {
-    var _a3, _b3;
-    add2(component.index, ((_a3 = nearest[position]) == null ? void 0 : _a3.nearestComponentIndex) ?? null);
-    add2(component.index, ((_b3 = rooted[position]) == null ? void 0 : _b3.parentComponentIndex) ?? null);
-  });
-  return edges.sort((a2, b) => a2.sourceComponentIndex - b.sourceComponentIndex || a2.targetComponentIndex - b.targetComponentIndex);
-}
-function analyzeDistanceInspection(entries, rawOptions = {}) {
-  const connectivity = analyzePhysicalConnectivity(entries, rawOptions);
-  const rootComponentIndex = rawOptions.rootComponentIndex ?? defaultRootComponentIndex(connectivity.components);
-  const nearest = computeNearestComponents(connectivity.components);
-  const rooted = computeRootDistances(connectivity.components, rootComponentIndex);
-  const gapEdges = compactGapEdges(connectivity.components, nearest, rooted);
-  const componentByIndex = /* @__PURE__ */ new Map();
-  const components = connectivity.components.map((component, position) => {
-    var _a3, _b3;
-    const rootData = rooted[position] ?? {
-      rootDistance: rootComponentIndex === component.index ? 0 : Infinity,
-      parentComponentIndex: null,
-      parentGap: null
-    };
-    const decorated = {
-      ...component,
-      isRoot: component.index === rootComponentIndex,
-      rootDistance: rootData.rootDistance,
-      nearestGap: ((_a3 = nearest[position]) == null ? void 0 : _a3.nearestGap) ?? null,
-      nearestComponentIndex: ((_b3 = nearest[position]) == null ? void 0 : _b3.nearestComponentIndex) ?? null,
-      parentComponentIndex: rootData.parentComponentIndex,
-      parentGap: rootData.parentGap
-    };
-    componentByIndex.set(component.index, decorated);
-    return decorated;
-  });
-  const objects = connectivity.objects.map((object) => {
-    const component = componentByIndex.get(object.componentIndex);
-    return {
-      ...object,
-      rootDistance: (component == null ? void 0 : component.rootDistance) ?? Infinity,
-      nearestGap: (component == null ? void 0 : component.nearestGap) ?? null,
-      nearestComponentIndex: (component == null ? void 0 : component.nearestComponentIndex) ?? null,
-      parentComponentIndex: (component == null ? void 0 : component.parentComponentIndex) ?? null,
-      parentGap: (component == null ? void 0 : component.parentGap) ?? null
-    };
-  });
-  const finiteDistances = components.map((component) => component.rootDistance).filter(Number.isFinite);
-  const maxRootDistance = finiteDistances.length > 0 ? Math.max(...finiteDistances) : 0;
-  return {
-    method: "physical-component-bbox-gap-graph",
-    distanceMethod: "axis-aligned-bbox-gap",
-    options: {
-      contactTolerance: connectivity.options.contactTolerance,
-      minOverlapVolume: connectivity.options.minOverlapVolume,
-      rootComponentIndex
-    },
-    objectCount: connectivity.objectCount,
-    componentCount: connectivity.componentCount,
-    rootComponentIndex,
-    maxRootDistance,
-    gapEdgeCount: connectivity.components.length * (connectivity.components.length - 1) / 2,
-    objects,
-    components,
-    gapEdges,
-    connectivity: {
-      method: connectivity.method,
-      edges: connectivity.edges
-    },
-    warnings: [...connectivity.warnings]
-  };
-}
 export {
   Matrix4 as $,
   ACESFilmicToneMapping as A,
@@ -340810,7 +342165,7 @@ export {
   DEFAULT_ACTIVE_BACKEND as ay,
   isConstraintSketch as az,
   PCFShadowMap as b,
-  generateCuttingLayoutPdf as b$,
+  initKernelManifoldOnly as b$,
   PointLight as b0,
   DirectionalLight as b1,
   analyzeCollisionIntersections as b2,
@@ -340821,64 +342176,61 @@ export {
   runScript as b7,
   MeshPhysicalMaterial as b8,
   LineSegments as b9,
-  normalizeCutPlane as bA,
-  toClippingPlane as bB,
-  findJointAnimationClip as bC,
-  resolveJointAnimation as bD,
-  resolveJointViewValues as bE,
-  getShapePorts as bF,
-  getShapeUsedPorts as bG,
-  DEFAULT_VIEW_CONFIG as bH,
-  getKernelFaceNameForTriangle as bI,
-  analyzePhysicalConnectivity as bJ,
-  analyzeDistanceInspection as bK,
-  initKernel as bL,
-  initSolverWasm as bM,
-  BoxGeometry as bN,
-  localAabbPlaneRelation as bO,
-  ShapeUtils as bP,
+  findJointAnimationClip as bA,
+  resolveJointAnimation as bB,
+  resolveJointViewValues as bC,
+  getShapePorts as bD,
+  getShapeUsedPorts as bE,
+  DEFAULT_VIEW_CONFIG as bF,
+  getKernelFaceNameForTriangle as bG,
+  initKernel as bH,
+  initSolverWasm as bI,
+  BoxGeometry as bJ,
+  localAabbPlaneRelation as bK,
+  ShapeUtils as bL,
+  aabbInteriorOverlaps as bM,
+  aabbOverlapVolume as bN,
+  AabbSpatialIndex as bO,
+  aabbGaps as bP,
   Group as bQ,
-  resolveRoughnessInspectionOptions as bR,
-  ROUGHNESS_COLORS as bS,
-  resolveThicknessInspectionOptions as bT,
-  summarizeThicknessSamples as bU,
-  THICKNESS_COLORS as bV,
-  intersectWithPlane as bW,
-  parseCameraCliSpec as bX,
-  PMREMGenerator as bY,
-  serializeCollisionFinding as bZ,
-  worldAuthorPlaneToLocal as b_,
-  analyzeThicknessGeometry as ba,
-  analyzeRoughnessGeometry as bb,
-  getRenderStylePreset as bc,
-  AdditiveBlending as bd,
-  CatmullRomCurve3 as be,
-  TubeGeometry as bf,
-  MeshStandardMaterial as bg,
-  compileSdfNode3 as bh,
-  buildSdfRaymarchFragmentShader as bi,
-  SDF_RAYMARCH_PROXY_VERTEX_SHADER as bj,
-  Shape2 as bk,
-  ShapeGeometry as bl,
-  ShaderLib as bm,
-  CylinderGeometry as bn,
-  parseViewportCameraState as bo,
-  createResolvedExplodeConfig as bp,
-  explodeBoundsCenter as bq,
-  explodeMergeBounds as br,
-  resolveExplodeDirective as bs,
-  computeExplodeMotion as bt,
-  getSketchWorldMatrix as bu,
-  explodeAdd as bv,
-  hasExplodeOverride as bw,
-  resolveExplodeLocalFanDirection as bx,
-  explodeMul as by,
-  explodeLeafFanStage as bz,
+  intersectWithPlane as bR,
+  parseCameraCliSpec as bS,
+  PMREMGenerator as bT,
+  PointsMaterial as bU,
+  Points$1 as bV,
+  serializeCollisionFinding as bW,
+  worldAuthorPlaneToLocal as bX,
+  generateCuttingLayoutPdf as bY,
+  getCameraForwardVector as bZ,
+  RENDER_STYLE_OPTIONS as b_,
+  getRenderStylePreset as ba,
+  AdditiveBlending as bb,
+  CatmullRomCurve3 as bc,
+  TubeGeometry as bd,
+  MeshStandardMaterial as be,
+  compileSdfNode3 as bf,
+  buildSdfRaymarchFragmentShader as bg,
+  SDF_RAYMARCH_PROXY_VERTEX_SHADER as bh,
+  Shape2 as bi,
+  ShapeGeometry as bj,
+  ShaderLib as bk,
+  CylinderGeometry as bl,
+  parseViewportCameraState as bm,
+  createResolvedExplodeConfig as bn,
+  explodeBoundsCenter as bo,
+  explodeMergeBounds as bp,
+  resolveExplodeDirective as bq,
+  computeExplodeMotion as br,
+  getSketchWorldMatrix as bs,
+  explodeAdd as bt,
+  hasExplodeOverride as bu,
+  resolveExplodeLocalFanDirection as bv,
+  explodeMul as bw,
+  explodeLeafFanStage as bx,
+  normalizeCutPlane as by,
+  toClippingPlane as bz,
   SRGBColorSpace as c,
-  getCameraForwardVector as c0,
-  RENDER_STYLE_OPTIONS as c1,
-  initKernelManifoldOnly as c2,
-  __viteBrowserExternal$1 as c3,
+  __viteBrowserExternal$1 as c0,
   Layers as d,
   Color as e,
   RGBAFormat as f,