forgecad 0.9.5 → 0.9.6

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

@@ -799,18 +799,18 @@ function cloneSdfNode(node) {
   }
 }
 const SHEET_METAL_EDGES = ["top", "right", "bottom", "left"];
-const EPS$c = 1e-9;
+const EPS$d = 1e-9;
 function isFinitePositive$3(value) {
   return Number.isFinite(value) && value > 0;
 }
 function isFiniteNonNegative(value) {
   return Number.isFinite(value) && value >= 0;
 }
-function cloneVec3$3(vec2) {
+function cloneVec3$5(vec2) {
   return [vec2[0], vec2[1], vec2[2]];
 }
 function cloneFaceAxis(vec2) {
-  return vec2 ? cloneVec3$3(vec2) : void 0;
+  return vec2 ? cloneVec3$5(vec2) : void 0;
 }
 function cloneSheetMetalModel(model) {
   if (!model) return null;
@@ -840,7 +840,7 @@ function edgeDisplayName(edge) {
   return `sheetMetal().flange("${edge}", ...)`;
 }
 function normalizeAngle(angleDeg) {
-  return Math.abs(angleDeg) <= EPS$c ? 0 : angleDeg;
+  return Math.abs(angleDeg) <= EPS$d ? 0 : angleDeg;
 }
 function validateSheetMetalModel(model) {
   if (!isFinitePositive$3(model.panel.width) || !isFinitePositive$3(model.panel.height)) {
@@ -852,7 +852,7 @@ function validateSheetMetalModel(model) {
   if (!isFiniteNonNegative(model.bendRadius)) {
     return "sheetMetal() requires a finite non-negative bendRadius.";
   }
-  if (model.bendRadius <= EPS$c) {
+  if (model.bendRadius <= EPS$d) {
     return "sheetMetal() v1 requires a positive bendRadius so the bend region stays explicit instead of collapsing into a sharp fold.";
   }
   if (model.bendAllowance.kind !== "k-factor") {
@@ -914,7 +914,7 @@ function deriveSheetMetalModel(model) {
     const trimEnd = flanges.has(adjacent.end) ? model.cornerRelief.size : 0;
     const fullLength = edge === "top" || edge === "bottom" ? model.panel.width : model.panel.height;
     const span = fullLength - trimStart - trimEnd;
-    if (!(span > EPS$c)) {
+    if (!(span > EPS$d)) {
       throw new Error(
         `${edgeDisplayName(edge)} loses all usable span after applying the defended rectangular corner relief size ${model.cornerRelief.size}.`
       );
@@ -972,7 +972,7 @@ function transformPlacement(origin, u2, v, normal) {
   };
 }
 function translatePlan(plan, x2, y2, z2) {
-  if (Math.abs(x2) <= EPS$c && Math.abs(y2) <= EPS$c && Math.abs(z2) <= EPS$c) return cloneShapeCompilePlan(plan);
+  if (Math.abs(x2) <= EPS$d && Math.abs(y2) <= EPS$d && Math.abs(z2) <= EPS$d) return cloneShapeCompilePlan(plan);
   return appendShapeCompileTransform(cloneShapeCompilePlan(plan), {
     kind: "translate",
     x: x2,
@@ -1120,8 +1120,8 @@ function lowerSheetMetalBasePlan(model, output) {
 function descriptor(name, center, normal, planar, uAxis, vAxis, semantic = "face", memberNames = [name], coplanar = planar) {
   return {
     name,
-    center: cloneVec3$3(center),
-    normal: cloneVec3$3(normal),
+    center: cloneVec3$5(center),
+    normal: cloneVec3$5(normal),
     planar,
     uAxis: cloneFaceAxis(uAxis),
     vAxis: cloneFaceAxis(vAxis),
@@ -1374,10 +1374,10 @@ function describeSheetMetalPlanarRegionFrames(model, output) {
     const size = sheetMetalPlanarRegionSize(derived, face.name);
     return {
       name: face.name,
-      center: cloneVec3$3(face.center),
-      normal: cloneVec3$3(face.normal),
-      uAxis: cloneVec3$3(face.uAxis),
-      vAxis: cloneVec3$3(face.vAxis),
+      center: cloneVec3$5(face.center),
+      normal: cloneVec3$5(face.normal),
+      uAxis: cloneVec3$5(face.uAxis),
+      vAxis: cloneVec3$5(face.vAxis),
       width: size.width,
       height: size.height,
       thickness: derived.thickness
@@ -1416,7 +1416,7 @@ function cloneShapeWorkplanePlacement(placement) {
     placement: cloneSketchPlacementModel(placement.placement)
   };
 }
-const EPS$b = 1e-10;
+const EPS$c = 1e-10;
 function subVec3(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
@@ -1442,7 +1442,7 @@ function projectRadial(v, axis) {
 function signedAngleAroundAxis(from, to, axis) {
   const fromLen = lengthVec3$1(from);
   const toLen = lengthVec3$1(to);
-  if (fromLen < EPS$b || toLen < EPS$b) return 0;
+  if (fromLen < EPS$c || toLen < EPS$c) return 0;
   const fn = scaleVec3(from, 1 / fromLen);
   const tn = scaleVec3(to, 1 / toLen);
   const sin2 = dotVec3$4(axis, crossVec3$2(fn, tn));
@@ -1463,19 +1463,19 @@ function solveRotateAroundAngle(axis, pivot, movingPoint, targetPoint, options =
   const targetDecomp = projectRadial(target, unitAxis);
   const movingRadialLen = lengthVec3$1(movingDecomp.radial);
   const targetRadialLen = lengthVec3$1(targetDecomp.radial);
-  if (movingRadialLen < EPS$b) {
-    if (mode === "line" && targetRadialLen >= EPS$b) {
+  if (movingRadialLen < EPS$c) {
+    if (mode === "line" && targetRadialLen >= EPS$c) {
       throw new Error("rotateAroundTo(...): moving point lies on the rotation axis, so line alignment is impossible");
     }
     return 0;
   }
   if (mode === "plane") {
-    if (targetRadialLen < EPS$b) {
+    if (targetRadialLen < EPS$c) {
       throw new Error("rotateAroundTo(...): target point lies on the rotation axis, so the target plane is undefined");
     }
     return signedAngleAroundAxis(movingDecomp.radial, targetDecomp.radial, unitAxis);
   }
-  if (targetRadialLen < EPS$b) {
+  if (targetRadialLen < EPS$c) {
     throw new Error("rotateAroundTo(...): target line lies on the rotation axis, but the moving point does not");
   }
   const axialTol = 1e-8 * Math.max(1, Math.abs(movingDecomp.axial), Math.abs(targetDecomp.axial));
@@ -1515,10 +1515,10 @@ function multiplyMat4(a2, b) {
 }
 function normalizeVec3$5(v) {
   const len2 = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-  if (len2 < EPS$b) throw new Error("Axis must be non-zero");
+  if (len2 < EPS$c) throw new Error("Axis must be non-zero");
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
-function transformPoint$1(m2, p2, w2) {
+function transformPoint$2(m2, p2, w2) {
   const x2 = p2[0], y2 = p2[1], z2 = p2[2];
   return [
     m2[0] * x2 + m2[4] * y2 + m2[8] * z2 + m2[12] * w2,
@@ -1545,7 +1545,7 @@ function invertMat4(m2) {
   const b10 = a21 * a33 - a23 * a31;
   const b11 = a22 * a33 - a23 * a32;
   const det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
-  if (Math.abs(det) < EPS$b) throw new Error("Transform matrix is not invertible");
+  if (Math.abs(det) < EPS$c) throw new Error("Transform matrix is not invertible");
   const invDet = 1 / det;
   out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * invDet;
   out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * invDet;
@@ -1638,11 +1638,11 @@ class Transform {
   }
   /** Transform a point using homogeneous coordinates. */
   point(p2) {
-    return transformPoint$1(this.m, p2, 1);
+    return transformPoint$2(this.m, p2, 1);
   }
   /** Transform a direction vector without translation. */
   vector(v) {
-    return transformPoint$1(this.m, v, 0);
+    return transformPoint$2(this.m, v, 0);
   }
   /** Return the transform as a raw 4x4 matrix array. */
   toArray() {
@@ -3302,14 +3302,14 @@ function sweepPathToPolylineAdaptive(path2, baseSamples = 48) {
   pts.push(evalPathAt(path2, 1));
   return pts;
 }
-const EPS$a = 1e-8;
+const EPS$b = 1e-8;
 const SUPPORTED_VERTICAL_EDGE_NAMES = ["vert-bl", "vert-br", "vert-tr", "vert-tl"];
 function midpoint$4(start, end) {
   return [(start[0] + end[0]) * 0.5, (start[1] + end[1]) * 0.5, (start[2] + end[2]) * 0.5];
 }
 function normalize$8(v) {
   const len2 = Math.hypot(v[0], v[1], v[2]);
-  if (len2 <= EPS$a) throw new Error("Edge feature selection requires a non-zero direction vector");
+  if (len2 <= EPS$b) throw new Error("Edge feature selection requires a non-zero direction vector");
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function subtract(a2, b) {
@@ -3391,7 +3391,7 @@ function rigidTransformForEdgeStep(step) {
     case "mirror": {
       const [nx0, ny0, nz0] = [step.normalX, step.normalY, step.normalZ];
       const len2 = Math.hypot(nx0, ny0, nz0);
-      if (len2 <= EPS$a) return Transform.identity();
+      if (len2 <= EPS$b) return Transform.identity();
       const nx = nx0 / len2;
       const ny = ny0 / len2;
       const nz = nz0 / len2;
@@ -3702,7 +3702,7 @@ function isRectangleProfile(points) {
     return [next[0] - point2[0], next[1] - point2[1]];
   });
   const lengths2 = vectors.map(([x2, y2]) => Math.hypot(x2, y2));
-  if (lengths2.some((length4) => length4 <= EPS$a)) return false;
+  if (lengths2.some((length4) => length4 <= EPS$b)) return false;
   const dot01 = vectors[0][0] * vectors[1][0] + vectors[0][1] * vectors[1][1];
   const dot12 = vectors[1][0] * vectors[2][0] + vectors[1][1] * vectors[2][1];
   const dot23 = vectors[2][0] * vectors[3][0] + vectors[2][1] * vectors[3][1];
@@ -5769,13 +5769,13 @@ function parseMeshFile(data, format) {
       return parse3mf(data);
   }
 }
-const EPS$9 = 1e-8;
+const EPS$a = 1e-8;
 function length$3(v) {
   return Math.hypot(v[0], v[1], v[2]);
 }
 function normalize$7(v) {
   const len2 = length$3(v);
-  if (len2 < EPS$9) throw new Error("Plane normal must be non-zero");
+  if (len2 < EPS$a) throw new Error("Plane normal must be non-zero");
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function resolvePlaneOriginNormal(plane) {
@@ -5797,12 +5797,12 @@ function resolvePlaneOriginNormal(plane) {
 function rotationToPlaneSpace(normal) {
   const n = normalize$7(normal);
   const dot2 = n[2];
-  if (dot2 > 1 - EPS$9) {
+  if (dot2 > 1 - EPS$a) {
     return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
   }
   let axis;
   let angle;
-  if (dot2 < -1 + EPS$9) {
+  if (dot2 < -1 + EPS$a) {
     axis = [1, 0, 0];
     angle = Math.PI;
   } else {
@@ -8364,10 +8364,10 @@ function scale$6(v, s) {
 function sub$7(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
-function cross$7(a2, b) {
+function cross$8(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
-function makeEdge(name, start, end, faceName, curve) {
+function makeEdge$1(name, start, end, faceName, curve) {
   return {
     name,
     start,
@@ -8400,7 +8400,7 @@ function buildSurfaceSheetTopology(boundaries, options = {}) {
   const center = options.center ?? average$1(corners);
   const uAxis = normalizeAxis$1(sub$7(midpoint$3(u1Start, u1End), midpoint$3(u0Start, u0End)));
   const vAxis = normalizeAxis$1(sub$7(midpoint$3(v1Start, v1End), midpoint$3(v0Start, v0End)));
-  const normal = normalizeAxis$1(options.normal ?? cross$7(uAxis, vAxis));
+  const normal = normalizeAxis$1(options.normal ?? cross$8(uAxis, vAxis));
   const faces = /* @__PURE__ */ new Map();
   faces.set(faceName, {
     name: faceName,
@@ -8411,10 +8411,10 @@ function buildSurfaceSheetTopology(boundaries, options = {}) {
     surface: options.surface
   });
   const edges = /* @__PURE__ */ new Map();
-  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));
+  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));
   return { faces, edges };
 }
 function attachSurfaceSheetTopology(shape, boundaries, options = {}) {
@@ -8432,7 +8432,7 @@ function attachSurfaceSheetTopology(shape, boundaries, options = {}) {
   });
   return shape;
 }
-function cloneVec3$2(value) {
+function cloneVec3$4(value) {
   return [value[0], value[1], value[2]];
 }
 function cloneNurbsFaceTrimLoop(loop) {
@@ -8454,38 +8454,38 @@ function cloneFaceSurface(surface) {
   if (!surface) return void 0;
   switch (surface.kind) {
     case "plane":
-      return { kind: "plane", normal: cloneVec3$2(surface.normal) };
+      return { kind: "plane", normal: cloneVec3$4(surface.normal) };
     case "cylinder":
       return {
         kind: "cylinder",
-        origin: cloneVec3$2(surface.origin),
-        axis: cloneVec3$2(surface.axis),
+        origin: cloneVec3$4(surface.origin),
+        axis: cloneVec3$4(surface.axis),
         radius: surface.radius,
         height: surface.height
       };
     case "cone":
       return {
         kind: "cone",
-        origin: cloneVec3$2(surface.origin),
-        axis: cloneVec3$2(surface.axis),
+        origin: cloneVec3$4(surface.origin),
+        axis: cloneVec3$4(surface.axis),
         radiusBottom: surface.radiusBottom,
         radiusTop: surface.radiusTop,
         height: surface.height
       };
     case "sphere":
-      return { kind: "sphere", center: cloneVec3$2(surface.center), radius: surface.radius };
+      return { kind: "sphere", center: cloneVec3$4(surface.center), radius: surface.radius };
     case "torus":
       return {
         kind: "torus",
-        center: cloneVec3$2(surface.center),
-        axis: cloneVec3$2(surface.axis),
+        center: cloneVec3$4(surface.center),
+        axis: cloneVec3$4(surface.axis),
         majorRadius: surface.majorRadius,
         minorRadius: surface.minorRadius
       };
     case "ruled":
       return {
         kind: "ruled",
-        rails: surface.rails.map((rail2) => rail2.map(cloneVec3$2))
+        rails: surface.rails.map((rail2) => rail2.map(cloneVec3$4))
       };
     case "nurbs":
       return {
@@ -8498,9 +8498,9 @@ function cloneEdgeCurve(curve) {
   if (!curve) return void 0;
   switch (curve.kind) {
     case "line":
-      return { ...curve, start: cloneVec3$2(curve.start), end: cloneVec3$2(curve.end) };
+      return { ...curve, start: cloneVec3$4(curve.start), end: cloneVec3$4(curve.end) };
     case "circle":
-      return { ...curve, center: cloneVec3$2(curve.center), axis: cloneVec3$2(curve.axis) };
+      return { ...curve, center: cloneVec3$4(curve.center), axis: cloneVec3$4(curve.axis) };
     case "surfaceIso":
       return { ...curve, parameterRange: [curve.parameterRange[0], curve.parameterRange[1]] };
     case "nurbsUv":
@@ -8518,7 +8518,7 @@ function cloneEdgeCurve(curve) {
   }
 }
 function makeLineEdgeCurve(start, end, faceName) {
-  return faceName ? { kind: "line", start: cloneVec3$2(start), end: cloneVec3$2(end), faceName } : { kind: "line", start: cloneVec3$2(start), end: cloneVec3$2(end) };
+  return faceName ? { kind: "line", start: cloneVec3$4(start), end: cloneVec3$4(end), faceName } : { kind: "line", start: cloneVec3$4(start), end: cloneVec3$4(end) };
 }
 function edgeCurveFaceName(curve) {
   switch (curve.kind) {
@@ -10302,6 +10302,7 @@ function buildSweepLevelSetInput(profilePolygons, pathInput, options) {
     edgeLength: options.edgeLength
   };
 }
+const EPS$9 = 1e-9;
 function resamplePolygon(poly, targetCount) {
   if (poly.length < 2) return poly;
   if (targetCount <= 0) return [];
@@ -10339,6 +10340,78 @@ function resamplePolygon(poly, targetCount) {
   }
   return out;
 }
+function resamplePolygonByAngle(poly, targetCount, center = polygonCentroid$2(poly)) {
+  if (poly.length < 3 || targetCount <= 0) return null;
+  if (!isConvexPolygon(poly)) return null;
+  const out = [];
+  for (let index2 = 0; index2 < targetCount; index2 += 1) {
+    const angle = index2 / targetCount * Math.PI * 2;
+    const point2 = rayPolygonIntersection(center, [Math.cos(angle), Math.sin(angle)], poly);
+    if (!point2) return null;
+    out.push(point2);
+  }
+  return out;
+}
+function rayPolygonIntersection(origin, direction2, poly) {
+  let bestT = Infinity;
+  let best = null;
+  for (let index2 = 0; index2 < poly.length; index2 += 1) {
+    const a2 = poly[index2];
+    const b = poly[(index2 + 1) % poly.length];
+    const edge = [b[0] - a2[0], b[1] - a2[1]];
+    const denom = cross$7(direction2, edge);
+    if (Math.abs(denom) < EPS$9) continue;
+    const delta = [a2[0] - origin[0], a2[1] - origin[1]];
+    const rayT = cross$7(delta, edge) / denom;
+    const edgeT = cross$7(delta, direction2) / denom;
+    if (rayT >= -EPS$9 && edgeT >= -EPS$9 && edgeT <= 1 + EPS$9 && rayT < bestT) {
+      bestT = rayT;
+      best = [origin[0] + direction2[0] * rayT, origin[1] + direction2[1] * rayT];
+    }
+  }
+  return best;
+}
+function polygonCentroid$2(poly) {
+  let area2 = 0;
+  let cx = 0;
+  let cy = 0;
+  for (let index2 = 0; index2 < poly.length; index2 += 1) {
+    const a2 = poly[index2];
+    const b = poly[(index2 + 1) % poly.length];
+    const crossValue = cross$7(a2, b);
+    area2 += crossValue;
+    cx += (a2[0] + b[0]) * crossValue;
+    cy += (a2[1] + b[1]) * crossValue;
+  }
+  if (Math.abs(area2) < EPS$9) return averagePoint(poly);
+  return [cx / (3 * area2), cy / (3 * area2)];
+}
+function averagePoint(poly) {
+  let x2 = 0;
+  let y2 = 0;
+  for (const point2 of poly) {
+    x2 += point2[0];
+    y2 += point2[1];
+  }
+  return [x2 / poly.length, y2 / poly.length];
+}
+function isConvexPolygon(poly) {
+  let sign2 = 0;
+  for (let index2 = 0; index2 < poly.length; index2 += 1) {
+    const a2 = poly[index2];
+    const b = poly[(index2 + 1) % poly.length];
+    const c2 = poly[(index2 + 2) % poly.length];
+    const turn = cross$7([b[0] - a2[0], b[1] - a2[1]], [c2[0] - b[0], c2[1] - b[1]]);
+    if (Math.abs(turn) < EPS$9) continue;
+    const currentSign = Math.sign(turn);
+    if (sign2 !== 0 && currentSign !== sign2) return false;
+    sign2 = currentSign;
+  }
+  return sign2 !== 0;
+}
+function cross$7(a2, b) {
+  return a2[0] * b[1] - a2[1] * b[0];
+}
 function loftStitched(profiles2, heights, wasm) {
   if (profiles2.length < 2) return null;
   const classified = profiles2.map((loops) => classifyLoops(loops));
@@ -10467,8 +10540,10 @@ function stitchSingleLoopLoft(loops, heights, wasm) {
     maxPoints = Math.max(maxPoints, loop.length);
   }
   const N = Math.max(maxPoints, 24);
+  const angularSamples = normalizedLoops.map((loop) => resamplePolygonByAngle(loop, N));
+  const useAngularSamples = angularSamples.every((samples) => samples != null);
   const resampled = normalizedLoops.map((loop, i) => {
-    const pts2d = resamplePolygon(loop, N);
+    const pts2d = useAngularSamples ? angularSamples[i] : resamplePolygon(loop, N);
     const z2 = heights[i];
     return pts2d.map(([x2, y2]) => [x2, y2, z2]);
   });
@@ -10530,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-CRoBhJKH.js");
+    const { default: __vite_default__ } = await import("./manifold-DzZ4VRPs.js");
     return { default: __vite_default__ };
   }, true ? [] : void 0)).default;
   performance.mark("manifold:imported");
@@ -22414,7 +22489,7 @@ function marchingTetrahedra(sdfFn, bounds, edgeLength2) {
   };
 }
 const EPS$8 = 1e-9;
-function finitePositive(value) {
+function finitePositive$1(value) {
   return Number.isFinite(value) && value > EPS$8;
 }
 function clampNonNegative(value) {
@@ -22433,7 +22508,7 @@ function distancePreservingMatrixScale(matrix) {
   const sx = length4(col0);
   const sy = length4(col1);
   const sz = length4(col2);
-  if (!finitePositive(sx) || !finitePositive(sy) || !finitePositive(sz)) return null;
+  if (!finitePositive$1(sx) || !finitePositive$1(sy) || !finitePositive$1(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;
@@ -22450,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(sx) || !finitePositive(sy) || !finitePositive(sz)) return null;
+      if (!finitePositive$1(sx) || !finitePositive$1(sy) || !finitePositive$1(sz)) return null;
       return Math.abs(sx - sy) <= EPS$8 && Math.abs(sx - sz) <= EPS$8 ? sx : null;
     }
   }
@@ -22490,7 +22565,7 @@ function translatedPlan(base, z2) {
   };
 }
 function offsetCylinderDimensions(plan, thickness) {
-  if (!finitePositive(plan.height)) return null;
+  if (!finitePositive$1(plan.height)) return null;
   const radiusTop = plan.radiusTop ?? plan.radius;
   const slope = (radiusTop - plan.radius) / plan.height;
   const normalScale = Math.hypot(1, slope);
@@ -22499,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(height) || radiusBottom < -EPS$8 || offsetRadiusTop < -EPS$8) return null;
+  if (!finitePositive$1(height) || radiusBottom < -EPS$8 || offsetRadiusTop < -EPS$8) return null;
   return {
     zMin,
     height,
@@ -22557,7 +22632,7 @@ function rectangleCandidatePointsFromProfile(plan) {
     case "rect": {
       const width = Math.abs(plan.width);
       const height = Math.abs(plan.height);
-      if (!finitePositive(width) || !finitePositive(height)) return null;
+      if (!finitePositive$1(width) || !finitePositive$1(height)) return null;
       const halfWidth = width / 2;
       const halfHeight = height / 2;
       const points = [
@@ -22591,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(xMax) || !finitePositive(zMax - zMin)) return null;
+  if (xMin < -EPS$8 || !finitePositive$1(xMax) || !finitePositive$1(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 {
@@ -22604,7 +22679,7 @@ function rectangleFootprintFromProfile(plan) {
 function circleFootprintFromProfile(plan) {
   if (plan.kind !== "circle") return null;
   const radius = Math.abs(plan.radius);
-  if (!finitePositive(radius)) return null;
+  if (!finitePositive$1(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);
@@ -22613,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(xScale) || !finitePositive(yScale)) return null;
+  if (!finitePositive$1(xScale) || !finitePositive$1(yScale)) return null;
   if (Math.abs(xScale - yScale) > EPS$8 || Math.abs(dot2) > EPS$8 * xScale * yScale) return null;
   return {
     center,
@@ -22626,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(minorRadius) || minorRadius >= circle2.center[0] - EPS$8) return null;
+  if (!finitePositive$1(minorRadius) || minorRadius >= circle2.center[0] - EPS$8) return null;
   return translatedPlan(
     {
       kind: "torus",
@@ -22673,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(outerRadius) || !finitePositive(height) || outerRadius <= innerRadius + EPS$8) return null;
+  if (innerRadius < -EPS$8 || !finitePositive$1(outerRadius) || !finitePositive$1(height) || outerRadius <= innerRadius + EPS$8) return null;
   const zCenter = (rectangle.zMin + rectangle.zMax) / 2;
   if (innerRadius <= EPS$8) {
     return translatedPlan(
@@ -22714,11 +22789,11 @@ function offsetSolidAnalyticPrimitivePlan(base, thickness) {
       };
     }
     case "box": {
-      if (!finitePositive(base.z)) return null;
+      if (!finitePositive$1(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(x2) || !finitePositive(y2) || !finitePositive(z2)) return null;
+      if (!finitePositive$1(x2) || !finitePositive$1(y2) || !finitePositive$1(z2)) return null;
       return translatedPlan(
         {
           kind: "box",
@@ -22745,7 +22820,7 @@ function offsetSolidAnalyticPrimitivePlan(base, thickness) {
     }
     case "sphere": {
       const radius = base.radius + thickness;
-      if (!finitePositive(radius)) return null;
+      if (!finitePositive$1(radius)) return null;
       return {
         kind: "sphere",
         radius,
@@ -22754,7 +22829,7 @@ function offsetSolidAnalyticPrimitivePlan(base, thickness) {
     }
     case "torus": {
       const minorRadius = base.minorRadius + thickness;
-      if (!finitePositive(minorRadius) || minorRadius >= base.majorRadius - EPS$8) return null;
+      if (!finitePositive$1(minorRadius) || minorRadius >= base.majorRadius - EPS$8) return null;
       return {
         kind: "torus",
         majorRadius: base.majorRadius,
@@ -23494,18 +23569,18 @@ function faceAxes(face) {
   }
   return {};
 }
-function edgeKey(start, end) {
+function edgeKey$1(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(start, end);
+  const target = edgeKey$1(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(faceStart, faceEnd) === target) return i;
+    if (faceStart && faceEnd && edgeKey$1(faceStart, faceEnd) === target) return i;
   }
   return null;
 }
@@ -23706,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(start, end);
+    const key = edgeKey$1(start, end);
     if (seenEdges.has(key)) continue;
     seenEdges.set(key, edges.size);
     const display = explicitEdgeDisplayName(payload, explicitEdge, explicitEdgeIndex, start, end);
@@ -23726,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(start, end);
+        const key = edgeKey$1(start, end);
         if (seenEdges.has(key)) continue;
         seenEdges.set(key, edges.size);
         edges.set(`${face.id}:edge-${i}`, {
@@ -30608,17 +30683,17 @@ function emptyFaceTable() {
     blockedQueries: []
   };
 }
-function cloneVec3$1(vec2) {
+function cloneVec3$3(vec2) {
   return [vec2[0], vec2[1], vec2[2]];
 }
 function cloneFaceRefValue(face) {
   return {
     ...face,
-    normal: cloneVec3$1(face.normal),
-    center: cloneVec3$1(face.center),
+    normal: cloneVec3$3(face.normal),
+    center: cloneVec3$3(face.center),
     query: cloneFaceQueryRef(face.query),
-    uAxis: face.uAxis ? cloneVec3$1(face.uAxis) : void 0,
-    vAxis: face.vAxis ? cloneVec3$1(face.vAxis) : void 0,
+    uAxis: face.uAxis ? cloneVec3$3(face.uAxis) : void 0,
+    vAxis: face.vAxis ? cloneVec3$3(face.vAxis) : void 0,
     surface: cloneFaceSurface(face.surface),
     descendant: face.descendant ? cloneFaceDescendantMetadata(face.descendant) : void 0
   };
@@ -31473,11 +31548,11 @@ function resolveShapeFaceTableInternal(plan, owner) {
       for (const descriptor2 of describeSheetMetalFaces(plan.model, plan.output)) {
         registerFace(table2, {
           name: descriptor2.name,
-          normal: cloneVec3$1(descriptor2.normal),
-          center: cloneVec3$1(descriptor2.center),
+          normal: cloneVec3$3(descriptor2.normal),
+          center: cloneVec3$3(descriptor2.center),
           planar: descriptor2.planar,
-          uAxis: descriptor2.uAxis ? cloneVec3$1(descriptor2.uAxis) : void 0,
-          vAxis: descriptor2.vAxis ? cloneVec3$1(descriptor2.vAxis) : void 0,
+          uAxis: descriptor2.uAxis ? cloneVec3$3(descriptor2.uAxis) : void 0,
+          vAxis: descriptor2.vAxis ? cloneVec3$3(descriptor2.vAxis) : void 0,
           query: createTrackedFaceQuery(descriptor2.name, owner),
           descendant: createFaceDescendantMetadata(descriptor2.semantic, descriptor2.memberNames, descriptor2.coplanar)
         });
@@ -31504,7 +31579,7 @@ function resolveShapeFaceTableInternal(plan, owner) {
             baseFace.center[2] - baseFace.normal[2] * plan.thickness
           ],
           normal: [-baseFace.normal[0], -baseFace.normal[1], -baseFace.normal[2]],
-          uAxis: baseFace.uAxis ? cloneVec3$1(baseFace.uAxis) : void 0,
+          uAxis: baseFace.uAxis ? cloneVec3$3(baseFace.uAxis) : void 0,
           vAxis: baseFace.vAxis ? [-baseFace.vAxis[0], -baseFace.vAxis[1], -baseFace.vAxis[2]] : void 0,
           query: createdQuery
         });
@@ -31570,15 +31645,15 @@ function resolveShapeFaceTableInternal(plan, owner) {
       if (counterboreFloorQuery && plan.hole.counterbore) {
         registerFace(table2, {
           name: "counterbore-floor",
-          normal: cloneVec3$1(workplane.normal),
+          normal: cloneVec3$3(workplane.normal),
           center: [
             origin[0] + inward[0] * plan.hole.counterbore.depth,
             origin[1] + inward[1] * plan.hole.counterbore.depth,
             origin[2] + inward[2] * plan.hole.counterbore.depth
           ],
           planar: true,
-          uAxis: cloneVec3$1(workplane.u),
-          vAxis: cloneVec3$1(workplane.v),
+          uAxis: cloneVec3$3(workplane.u),
+          vAxis: cloneVec3$3(workplane.v),
           query: counterboreFloorQuery
         });
       }
@@ -31602,11 +31677,11 @@ function resolveShapeFaceTableInternal(plan, owner) {
       if (floorQuery) {
         registerFace(table2, {
           name: "floor",
-          normal: cloneVec3$1(workplane.normal),
+          normal: cloneVec3$3(workplane.normal),
           center: [origin[0] + inward[0] * forward.depth, origin[1] + inward[1] * forward.depth, origin[2] + inward[2] * forward.depth],
           planar: true,
-          uAxis: cloneVec3$1(workplane.u),
-          vAxis: cloneVec3$1(workplane.v),
+          uAxis: cloneVec3$3(workplane.u),
+          vAxis: cloneVec3$3(workplane.v),
           query: floorQuery
         });
       }
@@ -31617,7 +31692,7 @@ function resolveShapeFaceTableInternal(plan, owner) {
           normal: [-workplane.normal[0], -workplane.normal[1], -workplane.normal[2]],
           center: [origin[0] - inward[0] * reverse.depth, origin[1] - inward[1] * reverse.depth, origin[2] - inward[2] * reverse.depth],
           planar: true,
-          uAxis: cloneVec3$1(workplane.u),
+          uAxis: cloneVec3$3(workplane.u),
           vAxis: [-workplane.v[0], -workplane.v[1], -workplane.v[2]],
           query: capQuery
         });
@@ -31796,11 +31871,11 @@ function resolveShapeFaceTableInternal(plan, owner) {
         })();
         registerFace(table2, {
           name: "floor",
-          normal: cloneVec3$1(placement.workplane.normal),
+          normal: cloneVec3$3(placement.workplane.normal),
           center: floorCenter,
           planar: true,
-          uAxis: cloneVec3$1(placement.workplane.u),
-          vAxis: cloneVec3$1(placement.workplane.v),
+          uAxis: cloneVec3$3(placement.workplane.u),
+          vAxis: cloneVec3$3(placement.workplane.v),
           query: floorQuery
         });
       }
@@ -31815,7 +31890,7 @@ function resolveShapeFaceTableInternal(plan, owner) {
             origin[2] - depthDir[2] * reverse.depth
           ],
           planar: true,
-          uAxis: cloneVec3$1(placement.workplane.u),
+          uAxis: cloneVec3$3(placement.workplane.u),
           vAxis: [-placement.workplane.v[0], -placement.workplane.v[1], -placement.workplane.v[2]],
           query: capQuery
         });
@@ -32001,7 +32076,7 @@ function preservedShapeFaceQueries(basePlan) {
   return listShapeFaceQueries(basePlan);
 }
 const PLACEMENT_REFERENCE_KINDS = ["points", "edges", "surfaces", "objects"];
-function cloneVec3(value, label) {
+function cloneVec3$2(value, label) {
   if (!Array.isArray(value) || value.length < 3) {
     throw new Error(`${label} must be a [x, y, z] tuple`);
   }
@@ -32027,23 +32102,23 @@ function isBoundsObject(value) {
 function toObjectBounds(value, label) {
   if (isBoundsObject(value)) {
     return {
-      min: cloneVec3(value.min, `${label}.min`),
-      max: cloneVec3(value.max, `${label}.max`)
+      min: cloneVec3$2(value.min, `${label}.min`),
+      max: cloneVec3$2(value.max, `${label}.max`)
     };
   }
   if (typeof value === "object" && value != null) {
     if ("boundingBox" in value && typeof value.boundingBox === "function") {
       const bounds = value.boundingBox();
       return {
-        min: cloneVec3(bounds.min, `${label}.min`),
-        max: cloneVec3(bounds.max, `${label}.max`)
+        min: cloneVec3$2(bounds.min, `${label}.min`),
+        max: cloneVec3$2(bounds.max, `${label}.max`)
       };
     }
     if ("_bbox" in value && typeof value._bbox === "function") {
       const bounds = value._bbox();
       return {
-        min: cloneVec3(bounds.min, `${label}.min`),
-        max: cloneVec3(bounds.max, `${label}.max`)
+        min: cloneVec3$2(bounds.min, `${label}.min`),
+        max: cloneVec3$2(bounds.max, `${label}.max`)
       };
     }
   }
@@ -32087,24 +32162,24 @@ function createPlacementReferences() {
 function clonePlacementReferences(refs) {
   const out = createPlacementReferences();
   for (const [name, point2] of Object.entries(refs.points)) {
-    out.points[name] = cloneVec3(point2, `points.${name}`);
+    out.points[name] = cloneVec3$2(point2, `points.${name}`);
   }
   for (const [name, edge] of Object.entries(refs.edges)) {
     out.edges[name] = {
-      start: cloneVec3(edge.start, `edges.${name}.start`),
-      end: cloneVec3(edge.end, `edges.${name}.end`)
+      start: cloneVec3$2(edge.start, `edges.${name}.start`),
+      end: cloneVec3$2(edge.end, `edges.${name}.end`)
     };
   }
   for (const [name, surface] of Object.entries(refs.surfaces)) {
     out.surfaces[name] = {
-      center: cloneVec3(surface.center, `surfaces.${name}.center`),
-      normal: cloneVec3(surface.normal, `surfaces.${name}.normal`)
+      center: cloneVec3$2(surface.center, `surfaces.${name}.center`),
+      normal: cloneVec3$2(surface.normal, `surfaces.${name}.normal`)
     };
   }
   for (const [name, objectRef] of Object.entries(refs.objects)) {
     out.objects[name] = {
-      min: cloneVec3(objectRef.min, `objects.${name}.min`),
-      max: cloneVec3(objectRef.max, `objects.${name}.max`)
+      min: cloneVec3$2(objectRef.min, `objects.${name}.min`),
+      max: cloneVec3$2(objectRef.max, `objects.${name}.max`)
     };
   }
   return out;
@@ -32112,18 +32187,18 @@ function clonePlacementReferences(refs) {
 function normalizePlacementReferenceInput(input = {}) {
   const out = createPlacementReferences();
   for (const [name, point2] of Object.entries(input.points ?? {})) {
-    out.points[name] = cloneVec3(point2, `points.${name}`);
+    out.points[name] = cloneVec3$2(point2, `points.${name}`);
   }
   for (const [name, edge] of Object.entries(input.edges ?? {})) {
     out.edges[name] = {
-      start: cloneVec3(edge.start, `edges.${name}.start`),
-      end: cloneVec3(edge.end, `edges.${name}.end`)
+      start: cloneVec3$2(edge.start, `edges.${name}.start`),
+      end: cloneVec3$2(edge.end, `edges.${name}.end`)
     };
   }
   for (const [name, surface] of Object.entries(input.surfaces ?? {})) {
     out.surfaces[name] = {
-      center: cloneVec3(surface.center, `surfaces.${name}.center`),
-      normal: normalizeVector$1(cloneVec3(surface.normal, `surfaces.${name}.normal`))
+      center: cloneVec3$2(surface.center, `surfaces.${name}.center`),
+      normal: normalizeVector$1(cloneVec3$2(surface.normal, `surfaces.${name}.normal`))
     };
   }
   for (const [name, objectRef] of Object.entries(input.objects ?? {})) {
@@ -32134,23 +32209,23 @@ function normalizePlacementReferenceInput(input = {}) {
 function mergePlacementReferences(...refsList) {
   const out = createPlacementReferences();
   for (const refs of refsList) {
-    for (const [name, point2] of Object.entries(refs.points)) out.points[name] = cloneVec3(point2, `points.${name}`);
+    for (const [name, point2] of Object.entries(refs.points)) out.points[name] = cloneVec3$2(point2, `points.${name}`);
     for (const [name, edge] of Object.entries(refs.edges)) {
       out.edges[name] = {
-        start: cloneVec3(edge.start, `edges.${name}.start`),
-        end: cloneVec3(edge.end, `edges.${name}.end`)
+        start: cloneVec3$2(edge.start, `edges.${name}.start`),
+        end: cloneVec3$2(edge.end, `edges.${name}.end`)
       };
     }
     for (const [name, surface] of Object.entries(refs.surfaces)) {
       out.surfaces[name] = {
-        center: cloneVec3(surface.center, `surfaces.${name}.center`),
-        normal: cloneVec3(surface.normal, `surfaces.${name}.normal`)
+        center: cloneVec3$2(surface.center, `surfaces.${name}.center`),
+        normal: cloneVec3$2(surface.normal, `surfaces.${name}.normal`)
       };
     }
     for (const [name, objectRef] of Object.entries(refs.objects)) {
       out.objects[name] = {
-        min: cloneVec3(objectRef.min, `objects.${name}.min`),
-        max: cloneVec3(objectRef.max, `objects.${name}.max`)
+        min: cloneVec3$2(objectRef.min, `objects.${name}.min`),
+        max: cloneVec3$2(objectRef.max, `objects.${name}.max`)
       };
     }
   }
@@ -32194,7 +32269,7 @@ function resolvePointFromKind(refs, kind, name, selector, originalRef) {
       const point2 = refs.points[name];
       if (!point2) return null;
       if (selector != null) placementRefSelectorError(originalRef, "does not support selectors");
-      return cloneVec3(point2, `points.${name}`);
+      return cloneVec3$2(point2, `points.${name}`);
     }
     case "edges": {
       const edge = refs.edges[name];
@@ -32202,8 +32277,8 @@ function resolvePointFromKind(refs, kind, name, selector, originalRef) {
       if (selector == null || selector === "midpoint" || selector === "center") {
         return midpoint$2(edge.start, edge.end);
       }
-      if (selector === "start") return cloneVec3(edge.start, `edges.${name}.start`);
-      if (selector === "end") return cloneVec3(edge.end, `edges.${name}.end`);
+      if (selector === "start") return cloneVec3$2(edge.start, `edges.${name}.start`);
+      if (selector === "end") return cloneVec3$2(edge.end, `edges.${name}.end`);
       placementRefSelectorError(originalRef, "supports only .start, .end, or .midpoint");
     }
     case "surfaces": {
@@ -32212,7 +32287,7 @@ function resolvePointFromKind(refs, kind, name, selector, originalRef) {
       if (selector != null && selector !== "center") {
         placementRefSelectorError(originalRef, "supports only .center");
       }
-      return cloneVec3(surface.center, `surfaces.${name}.center`);
+      return cloneVec3$2(surface.center, `surfaces.${name}.center`);
     }
     case "objects": {
       const objectRef = refs.objects[name];
@@ -35822,7 +35897,7 @@ function edgesBetweenFaces(shape, faceA, faceBs) {
   });
   return coalesceEdges(result);
 }
-const EPSILON$2 = 1e-8;
+const EPSILON$3 = 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;
@@ -35830,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$2 && det < EPSILON$2) return null;
+  if (det > -EPSILON$3 && det < EPSILON$3) 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;
@@ -35869,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$2 * 100) {
+    if (deduped.length === 0 || Math.abs(hit.distance - deduped[deduped.length - 1].distance) > EPSILON$3 * 100) {
       deduped.push(hit);
     }
   }
@@ -41412,7 +41487,7 @@ function rodrigues(rv) {
 function rotateVec3(R, v) {
   return [R[0] * v[0] + R[1] * v[1] + R[2] * v[2], R[3] * v[0] + R[4] * v[1] + R[5] * v[2], R[6] * v[0] + R[7] * v[1] + R[8] * v[2]];
 }
-function transformPoint(rv, translation, point2) {
+function transformPoint$1(rv, translation, point2) {
   const R = rodrigues(rv);
   const rotated = rotateVec3(R, point2);
   return [rotated[0] + translation[0], rotated[1] + translation[1], rotated[2] + translation[2]];
@@ -41642,7 +41717,7 @@ function createContext(bodies) {
     toWorld(bodyId, point2) {
       const body = bodies.get(bodyId);
       if (!body) throw new Error(`Unknown body: ${bodyId}`);
-      return transformPoint(body.rotation, body.position, point2);
+      return transformPoint$1(body.rotation, body.position, point2);
     },
     toWorldDir(bodyId, dir) {
       const body = bodies.get(bodyId);
@@ -41656,7 +41731,7 @@ function createContext(bodies) {
       if (!face) throw new Error(`Unknown face "${faceName}" on body "${bodyId}"`);
       return {
         normal: normalize3(transformDir(body.rotation, face.normal)),
-        center: transformPoint(body.rotation, body.position, face.center)
+        center: transformPoint$1(body.rotation, body.position, face.center)
       };
     },
     worldAxis(bodyId, axisName) {
@@ -41665,7 +41740,7 @@ function createContext(bodies) {
       const axis = body.axes.get(axisName);
       if (!axis) throw new Error(`Unknown axis "${axisName}" on body "${bodyId}"`);
       return {
-        origin: transformPoint(body.rotation, body.position, axis.origin),
+        origin: transformPoint$1(body.rotation, body.position, axis.origin),
         direction: normalize3(transformDir(body.rotation, axis.direction))
       };
     },
@@ -41674,7 +41749,7 @@ function createContext(bodies) {
       if (!body) throw new Error(`Unknown body: ${bodyId}`);
       const pt = body.points.get(pointName);
       if (!pt) throw new Error(`Unknown point "${pointName}" on body "${bodyId}"`);
-      return transformPoint(body.rotation, body.position, pt.position);
+      return transformPoint$1(body.rotation, body.position, pt.position);
     }
   };
 }
@@ -47218,10 +47293,8 @@ class PathBuilder {
     if (radius <= 0) throw new Error("fillet: radius must be positive");
     const n = this.segs.length;
     if (n < 2) throw new Error("fillet: need at least 2 segments before a fillet");
-    const prev = this.segs[n - 2];
     const curr = this.segs[n - 1];
-    curr.kind === "line" || curr.kind === "move" ? prev.kind === "line" || prev.kind === "move" ? 0 : 0 : 0;
-    const { trimA, trimB, arcSeg } = this.computeFilletGeom(radius);
+    const { trimA, arcSeg } = this.computeFilletGeom(radius);
     if (!arcSeg) throw new Error("fillet: cannot fillet these segments (parallel or degenerate)");
     this.trimLastSegEnd(n - 2, trimA[0], trimA[1]);
     const trimmedSeg = { ...curr };
@@ -47293,7 +47366,6 @@ class PathBuilder {
   }
   getSegDirAt(seg, which) {
     if (seg.kind === "line" || seg.kind === "move") {
-      this.segs.length;
       const idx = this.segs.indexOf(seg);
       if (seg.kind === "line") {
         let sx, sy;
@@ -47535,6 +47607,41 @@ class PathBuilder {
     }
     return pts;
   }
+  /**
+   * Return the open path as a sampled 2D polyline.
+   *
+   * This is for construction geometry such as guide rails, measured centerlines,
+   * and curve-driven helpers where the authored path should stay open instead of
+   * becoming a filled sketch or stroked profile.
+   *
+   * **Example**
+   *
+   * ```ts
+   * const rail = path()
+   *   .moveTo(24, 0)
+   *   .bezierTo(32, 44, 28, 92, 18, 120)
+   *   .toPolyline();
+   * ```
+   *
+   * @returns A sampled open polyline.
+   * @category Path Builder
+   */
+  toPolyline() {
+    const moveCount = this.segs.filter((seg) => seg.kind === "move").length;
+    if (moveCount > 1) {
+      throw new Error("path().toPolyline() supports one continuous open path. Use separate path() builders for separate rails.");
+    }
+    const pts = [];
+    for (const point2 of this.tessellate()) {
+      if (!point2.every(Number.isFinite)) throw new Error("path().toPolyline() produced a non-finite point");
+      const previous = pts[pts.length - 1];
+      if (!previous || Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-9) {
+        pts.push(point2);
+      }
+    }
+    if (pts.length < 2) throw new Error("path().toPolyline() needs at least 2 points");
+    return pts;
+  }
   // ── Output ────────────────────────────────────────────────────────────────
   /**
    * Close the path and return a filled `Sketch`.
@@ -49173,7 +49280,7 @@ function beltDrive(options) {
   };
 }
 const GEAR_META_KEY = Symbol.for("forgecad.library.gearMeta");
-const EPSILON$1 = 1e-9;
+const EPSILON$2 = 1e-9;
 function clamp01$1(value) {
   return Math.max(-1, Math.min(1, value));
 }
@@ -49292,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$1, pitchRadius - options.dedendum);
-  if (!(rootRadius < outerRadius - EPSILON$1)) {
+  const rootRadius = Math.max(EPSILON$2, pitchRadius - options.dedendum);
+  if (!(rootRadius < outerRadius - EPSILON$2)) {
     throw new Error("spurGear: invalid radii (root radius must be smaller than outer radius)");
   }
-  if (options.boreDiameter > 0 && options.boreDiameter * 0.5 >= rootRadius - EPSILON$1) {
+  if (options.boreDiameter > 0 && options.boreDiameter * 0.5 >= rootRadius - EPSILON$2) {
     throw new Error("spurGear: bore is too large for the computed root radius");
   }
   return {
@@ -49319,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$1) {
+  if (thicknessAtPitch <= EPSILON$2) {
     throw new Error("spurGear: backlash leaves no tooth thickness at pitch circle");
   }
   const halfThicknessAtPitch = thicknessAtPitch / (2 * meta2.pitchRadius);
@@ -49328,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$1;
+  const hasFillets = filletRadius > EPSILON$2;
   const leftFlank = [];
   const rightFlank = [];
   for (let i = 0; i <= flankSteps; i++) {
@@ -49556,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$1) throw new Error(`${scope}: angular sweep must be <= 360 degrees`);
+  if (sweep2 > 360 + EPSILON$2) throw new Error(`${scope}: angular sweep must be <= 360 degrees`);
   return Math.min(360, sweep2);
 }
 function buildSpurToothRegionProfile(meta2, firstTooth, toothCount, segmentsPerTooth) {
@@ -49571,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$1) {
+  if (Math.abs(sweepDeg - 360) < EPSILON$2) {
     const outer = circle2d(options.outerRadius, segments);
     return innerRadius > 0 ? difference2d(outer, circle2d(innerRadius, segments)) : outer;
   }
@@ -49655,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$1) {
+    if (firstGearRegion && this.boreDiameter * 0.5 >= firstGearRegion.rootRadius - EPSILON$2) {
       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 });
@@ -49701,7 +49808,7 @@ class DriveWheelBuilder {
     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$1) {
+    if (this.faceWidth !== void 0 && localFaceWidth !== void 0 && Math.abs(this.faceWidth - localFaceWidth) > EPSILON$2) {
       throw new Error(`${scope}: region faceWidth must match driveWheel faceWidth`);
     }
     return faceWidth;
@@ -49924,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$1)) {
+  if (!(outerRadius > rootRadius + EPSILON$2)) {
     throw new Error("ringGear: outer diameter/rim width leaves no ring body");
   }
   return {
@@ -49976,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$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");
+  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");
   const meta2 = {
     kind: "ring",
     module: normalized.module,
@@ -50051,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$1) throw new Error("rackGear: backlash leaves no tooth thickness");
+  if (thicknessAtPitch <= EPSILON$2) 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$1) {
+  if (halfTip <= EPSILON$2) {
     throw new Error("rackGear: tooth tip collapsed (increase module or lower pressure angle/addendum)");
   }
   const toothSketch = polygon([
@@ -50123,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$1 && angle < shaftAngleRad - EPSILON$1)) {
+  if (!(angle > EPSILON$2 && angle < shaftAngleRad - EPSILON$2)) {
     throw new Error("bevelGear: could not derive a valid pitch angle from teeth/shaft angle");
   }
   return angle * 180 / Math.PI;
@@ -50158,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$1, Math.sin(pitchAngleRad));
+  const coneDistance = pitchRadius / Math.max(EPSILON$2, Math.sin(pitchAngleRad));
   if (!isFinitePositive(coneDistance)) {
     throw new Error("bevelGear: invalid cone distance");
   }
@@ -50167,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$1 && topScale <= 1)) {
+  if (!(topScale > EPSILON$2 && topScale <= 1)) {
     throw new Error("bevelGear: computed top scale is invalid");
   }
   return {
@@ -50283,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$1, Math.tan(alpha)));
+  const autoCenterDistance = nominalCenterDistance + requestedBacklash / (2 * Math.max(EPSILON$2, Math.tan(alpha)));
   const centerDistance = options.centerDistance ?? autoCenterDistance;
   if (!Number.isFinite(centerDistance) || centerDistance <= 0) {
     throw new Error("gearPair: centerDistance must be > 0");
@@ -50312,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$1));
+  const cosWorking = clamp01$1(baseSum / Math.max(centerDistance, EPSILON$2));
   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$1, basePitch);
+  const contactRatio = pathLength / Math.max(EPSILON$2, basePitch);
   if (contactRatio < 1) {
     diagnostics.push({
       level: "error",
@@ -50447,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$1, Math.sin(pinionPitchAngleRad));
-  const coneDistanceGear = gear.meta.coneDistance ?? gear.meta.pitchRadius / Math.max(EPSILON$1, Math.sin(gearPitchAngleRad));
+  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 coneDistance = (coneDistancePinion + coneDistanceGear) * 0.5;
   if (Math.abs(coneDistancePinion - coneDistanceGear) > pinion.meta.module * 0.5) {
     diagnostics.push({
@@ -50457,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$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;
+  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;
   if (pinionToApex <= 0 || gearToApex <= 0) {
     diagnostics.push({
       level: "warn",
@@ -51253,11 +51360,11 @@ function inverseLerp(x2, y2, value) {
     return 0;
   }
 }
-function lerp$3(x2, y2, t) {
+function lerp$6(x2, y2, t) {
   return (1 - t) * x2 + t * y2;
 }
 function damp(x2, y2, lambda, dt) {
-  return lerp$3(x2, y2, 1 - Math.exp(-lambda * dt));
+  return lerp$6(x2, y2, 1 - Math.exp(-lambda * dt));
 }
 function pingpong(x2, length4 = 1) {
   return length4 - Math.abs(euclideanModulo(x2, length4 * 2) - length4);
@@ -51450,7 +51557,7 @@ const MathUtils = {
    * @param {number} t - The interpolation factor in the closed interval `[0, 1]`.
    * @return {number} The interpolated value.
    */
-  lerp: lerp$3,
+  lerp: lerp$6,
   /**
    * 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
@@ -60404,9 +60511,9 @@ class Color {
   lerpHSL(color, alpha) {
     this.getHSL(_hslA);
     color.getHSL(_hslB);
-    const h = lerp$3(_hslA.h, _hslB.h, alpha);
-    const s = lerp$3(_hslA.s, _hslB.s, alpha);
-    const l = lerp$3(_hslA.l, _hslB.l, alpha);
+    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);
     this.setHSL(h, s, l);
     return this;
   }
@@ -92404,7 +92511,7 @@ function requireFinite$7(value, label) {
   }
   return value;
 }
-function requireVec3$2(value, label) {
+function requireVec3$3(value, label) {
   if (!Array.isArray(value) || value.length !== 3) {
     throw new Error(`${label} must be [x, y, z]`);
   }
@@ -92448,7 +92555,7 @@ function normalizeOptions(options) {
     out.size = requireFinite$7(options.size, "Viewport.label options.size");
     if (out.size <= 0) throw new Error("Viewport.label options.size must be positive");
   }
-  if (options.offset !== void 0) out.offset = requireVec3$2(options.offset, "Viewport.label options.offset");
+  if (options.offset !== void 0) out.offset = requireVec3$3(options.offset, "Viewport.label options.offset");
   if (options.anchor !== void 0) {
     if (!VALID_ANCHORS.has(options.anchor)) {
       throw new Error(`Viewport.label options.anchor must be one of: ${Array.from(VALID_ANCHORS).join(", ")}`);
@@ -92465,7 +92572,7 @@ function collectRenderLabel(text, at, options) {
   if (typeof text !== "string" || text.trim().length === 0) {
     throw new Error("Viewport.label text must be a non-empty string");
   }
-  const normalizedAt = requireVec3$2(at, "Viewport.label at");
+  const normalizedAt = requireVec3$3(at, "Viewport.label at");
   const normalizedOptions = normalizeOptions(options);
   _collected$4.push({
     id: `render-label-${_nextId++}`,
@@ -92884,7 +92991,7 @@ function requireFinite$6(value, label) {
   }
   return value;
 }
-function requireVec3$1(value, label) {
+function requireVec3$2(value, label) {
   if (!Array.isArray(value) || value.length !== 3) {
     throw new Error(`${label} must be [x, y, z]`);
   }
@@ -92912,9 +93019,9 @@ const VALID_ENVIRONMENT_PRESETS = /* @__PURE__ */ new Set([
 ]);
 function validateCamera(cam, label) {
   const out = {};
-  if (cam.position !== void 0) out.position = requireVec3$1(cam.position, `${label}.position`);
-  if (cam.target !== void 0) out.target = requireVec3$1(cam.target, `${label}.target`);
-  if (cam.up !== void 0) out.up = requireVec3$1(cam.up, `${label}.up`);
+  if (cam.position !== void 0) out.position = requireVec3$2(cam.position, `${label}.position`);
+  if (cam.target !== void 0) out.target = requireVec3$2(cam.target, `${label}.target`);
+  if (cam.up !== void 0) out.up = requireVec3$2(cam.up, `${label}.up`);
   if (cam.fov !== void 0) {
     out.fov = requireFinite$6(cam.fov, `${label}.fov`);
     if (out.fov <= 0 || out.fov >= 180) throw new Error(`${label}.fov must be between 0 and 180`);
@@ -93049,8 +93156,8 @@ function validateLight(light, label) {
   const out = { type: light.type };
   if (light.color !== void 0) out.color = requireColor(light.color, `${label}.color`);
   if (light.intensity !== void 0) out.intensity = requireFinite$6(light.intensity, `${label}.intensity`);
-  if (light.position !== void 0) out.position = requireVec3$1(light.position, `${label}.position`);
-  if (light.target !== void 0) out.target = requireVec3$1(light.target, `${label}.target`);
+  if (light.position !== void 0) out.position = requireVec3$2(light.position, `${label}.position`);
+  if (light.target !== void 0) out.target = requireVec3$2(light.target, `${label}.target`);
   if (light.groundColor !== void 0) out.groundColor = requireColor(light.groundColor, `${label}.groundColor`);
   if (light.skyColor !== void 0) out.skyColor = requireColor(light.skyColor, `${label}.skyColor`);
   if (light.angle !== void 0) out.angle = requireFinite$6(light.angle, `${label}.angle`);
@@ -94582,7 +94689,7 @@ function scale$1(v, s) {
 function dot$2(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
-function lerp$2(a2, b, t) {
+function lerp$5(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function frameMatrix$1(x2, y2, z2, p2) {
@@ -94593,7 +94700,7 @@ function axisVector(axis, sign2 = 1) {
   if (axis === "Y") return [0, sign2, 0];
   return [0, 0, sign2];
 }
-function axisPosition(axis, point2) {
+function axisPosition$1(axis, point2) {
   return point2[AXIS_INDEX[axis]];
 }
 function crossPointForStation(axis, point2) {
@@ -94601,7 +94708,7 @@ function crossPointForStation(axis, point2) {
   if (axis === "Y") return [point2[0], -point2[2]];
   return [point2[1], point2[2]];
 }
-function orientLoftToAxis(shape, axis) {
+function orientLoftToAxis$1(shape, axis) {
   if (axis === "Z") return shape;
   if (axis === "Y") return shape.rotateX(-90);
   return shape.transform([0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1]);
@@ -94658,9 +94765,9 @@ function interpolateQuery(a2, b, t) {
   }
   return {
     side: sideA,
-    u: lerp$2(a2.u ?? 0.5, b.u ?? 0.5, t),
-    v: lerp$2(a2.v ?? 0.5, b.v ?? 0.5, t),
-    offset: lerp$2(a2.offset ?? 0, b.offset ?? 0, t)
+    u: lerp$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)
   };
 }
 function resolvePathQueries(points) {
@@ -94727,8 +94834,8 @@ class ProductSkin {
     this.stations = stations;
     this.rails = rails;
     for (const [name2, query] of Object.entries(refs)) this.refQueries.set(name2, cloneQuery(query));
-    this.axisMin = Math.min(...stations.map((station) => axisPosition(axis, station.center)));
-    this.axisMax = Math.max(...stations.map((station) => axisPosition(axis, station.center)));
+    this.axisMin = Math.min(...stations.map((station) => axisPosition$1(axis, station.center)));
+    this.axisMax = Math.max(...stations.map((station) => axisPosition$1(axis, station.center)));
     this.diagnosticsValue = {
       ...diagnostics,
       stationNames: stations.map((station) => station.name),
@@ -94785,24 +94892,24 @@ class ProductSkin {
   }
   /** Interpolate center, width, and depth at a normalized v or absolute axis value. */
   stationAt(vOrAxis) {
-    const axisValue = vOrAxis >= 0 && vOrAxis <= 1 ? lerp$2(this.axisMin, this.axisMax, vOrAxis) : clamp$5(vOrAxis, this.axisMin, this.axisMax);
+    const axisValue = vOrAxis >= 0 && vOrAxis <= 1 ? lerp$5(this.axisMin, this.axisMax, vOrAxis) : clamp$5(vOrAxis, this.axisMin, this.axisMax);
     const sorted = this.stations;
     for (let index2 = 0; index2 < sorted.length - 1; index2 += 1) {
       const a2 = sorted[index2];
       const b = sorted[index2 + 1];
-      const aAxis = axisPosition(this.axis, a2.center);
-      const bAxis = axisPosition(this.axis, b.center);
+      const aAxis = axisPosition$1(this.axis, a2.center);
+      const bAxis = axisPosition$1(this.axis, b.center);
       if (axisValue < aAxis - EPS$5 || axisValue > bAxis + EPS$5) continue;
       const span = Math.max(EPS$5, bAxis - aAxis);
       const t = clamp$5((axisValue - aAxis) / span, 0, 1);
       return {
         axisValue,
-        center: [lerp$2(a2.center[0], b.center[0], t), lerp$2(a2.center[1], b.center[1], t), lerp$2(a2.center[2], b.center[2], t)],
-        width: lerp$2(a2.profile.width, b.profile.width, t),
-        depth: lerp$2(a2.profile.depth, b.profile.depth, t),
+        center: [lerp$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),
         dWidth: (b.profile.width - a2.profile.width) / span,
         dDepth: (b.profile.depth - a2.profile.depth) / span,
-        exponent: lerp$2(profileExponent(a2), profileExponent(b), t),
+        exponent: lerp$5(profileExponent(a2), profileExponent(b), t),
         kind: a2.profile.kind === b.profile.kind ? a2.profile.kind : "custom"
       };
     }
@@ -94924,7 +95031,7 @@ class ProductSkinBuilder {
   }
   /** Set named cross-section stations for the product skin. */
   stations(stations) {
-    this.stationsValue = stations.map(toStationSpec).sort((a2, b) => axisPosition(this.axisValue, a2.center) - axisPosition(this.axisValue, b.center));
+    this.stationsValue = stations.map(toStationSpec).sort((a2, b) => axisPosition$1(this.axisValue, a2.center) - axisPosition$1(this.axisValue, b.center));
     return this;
   }
   /** Attach named guide rails for product-skin construction and downstream surface references. */
@@ -94974,9 +95081,9 @@ class ProductSkinBuilder {
       const [x2, y2] = crossPointForStation(this.axisValue, station.center);
       return station.profile.sketch.translate(x2, y2);
     });
-    const heights = this.stationsValue.map((station) => axisPosition(this.axisValue, station.center));
+    const heights = this.stationsValue.map((station) => axisPosition$1(this.axisValue, station.center));
     let shape = loft(localProfiles, heights, { edgeLength: this.edgeLengthValue });
-    shape = orientLoftToAxis(shape, this.axisValue);
+    shape = orientLoftToAxis$1(shape, this.axisValue);
     if (this.colorValue) shape = shape.color(this.colorValue);
     shape = applyMaterial(shape, this.materialValue).as(this.name);
     const warnings = [];
@@ -95635,7 +95742,7 @@ function requirePositive$3(value, label) {
 function clamp$4(value, min2, max2) {
   return Math.max(min2, Math.min(max2, value));
 }
-function lerp$1(a2, b, t) {
+function lerp$4(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function add(a2, b) {
@@ -95685,19 +95792,19 @@ function transformLocal(point2, tangentAcross, normal, tangentAlong, x2, y2, z2
 function interpolateCylinder(a2, b, t, mode) {
   let delta = b.angle - a2.angle;
   if (mode === "shortest" && Math.abs(delta) > 180) delta -= Math.sign(delta) * 360;
-  return { kind: "cylinder", angle: a2.angle + delta * t, z: lerp$1(a2.z, b.z, t), offset: lerp$1(a2.offset ?? 0, b.offset ?? 0, t) };
+  return { kind: "cylinder", angle: a2.angle + delta * t, z: lerp$4(a2.z, b.z, t), offset: lerp$4(a2.offset ?? 0, b.offset ?? 0, t) };
 }
 function interpolatePlane(a2, b, t) {
-  return { kind: "plane", x: lerp$1(a2.x, b.x, t), y: lerp$1(a2.y, b.y, t), offset: lerp$1(a2.offset ?? 0, b.offset ?? 0, t) };
+  return { kind: "plane", x: lerp$4(a2.x, b.x, t), y: lerp$4(a2.y, b.y, t), offset: lerp$4(a2.offset ?? 0, b.offset ?? 0, t) };
 }
 function interpolateProductSkin(a2, b, t) {
   if ((a2.side ?? b.side) !== (b.side ?? a2.side)) throw new Error("SurfacePath on ProductSkin currently supports one side per path; split side transitions into separate members.");
   return {
     kind: "productSkin",
     side: a2.side ?? b.side,
-    u: lerp$1(a2.u ?? 0.5, b.u ?? 0.5, t),
-    v: lerp$1(a2.v ?? 0.5, b.v ?? 0.5, t),
-    offset: lerp$1(a2.offset ?? 0, b.offset ?? 0, t)
+    u: lerp$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)
   };
 }
 class SurfacePath {
@@ -96020,11 +96127,11 @@ function coordinateOnSide(coordinate, side, label) {
   return { ...coordinate, kind: "productSkin", side };
 }
 class ProductSkinCarrier {
-  constructor(skin, name = skin.name, sideValue, offsetValue = 0) {
+  constructor(skin, name = skin.name, sideValue2, offsetValue = 0) {
     __publicField(this, "kind", "productSkin");
     this.skin = skin;
     this.name = name;
-    this.sideValue = sideValue;
+    this.sideValue = sideValue2;
     this.offsetValue = offsetValue;
   }
   surface(side) {
@@ -96795,7 +96902,7 @@ function counterboresForPlate(spec2, width, height, thickness, diagnostics) {
 function minWidthAcrossAlongRange(widthAtT, length4, minAlong, maxAlong) {
   let minWidth = Number.POSITIVE_INFINITY;
   for (let index2 = 0; index2 <= 8; index2 += 1) {
-    const along = lerp$1(minAlong, maxAlong, index2 / 8);
+    const along = lerp$4(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));
   }
@@ -97095,7 +97202,7 @@ function pathParameterAtDistance(samples, distance2) {
     const segmentLength = Math.hypot(b.point[0] - a2.point[0], b.point[1] - a2.point[1], b.point[2] - a2.point[2]);
     if (traveled + segmentLength >= distance2) {
       const localT = segmentLength <= 1e-8 ? 0 : (distance2 - traveled) / segmentLength;
-      return lerp$1(a2.t, b.t, localT);
+      return lerp$4(a2.t, b.t, localT);
     }
     traveled += segmentLength;
   }
@@ -97148,7 +97255,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex <= acrossSegments; acrossIndex += 1) {
-      const across = lerp$1(-width / 2, width / 2, acrossIndex / acrossSegments);
+      const across = lerp$4(-width / 2, width / 2, acrossIndex / acrossSegments);
       mesh.vertices.push(pointAtProfile([across, along], false));
     }
   }
@@ -97158,7 +97265,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex <= acrossSegments; acrossIndex += 1) {
-      const across = lerp$1(-width / 2, width / 2, acrossIndex / acrossSegments);
+      const across = lerp$4(-width / 2, width / 2, acrossIndex / acrossSegments);
       mesh.vertices.push(pointAtProfile([across, along], true));
     }
   }
@@ -97170,7 +97277,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex < acrossSegments; acrossIndex += 1) {
-      const across = lerp$1(-width / 2, width / 2, (acrossIndex + 0.5) / acrossSegments);
+      const across = lerp$4(-width / 2, width / 2, (acrossIndex + 0.5) / acrossSegments);
       filled[alongIndex][acrossIndex] = !holes.some((hole2) => pointInProfileLoop([across, along], hole2));
     }
   }
@@ -99348,7 +99455,7 @@ const Constraint = {
     return builder.constrain({ type: "length", line: resolveLineId(builder, line2), value });
   }
 };
-function requireVec3(v, label) {
+function requireVec3$1(v, label) {
   if (!Array.isArray(v) || v.length !== 3 || !Number.isFinite(v[0]) || !Number.isFinite(v[1]) || !Number.isFinite(v[2])) {
     throw new Error(`${label} must be a [number, number, number] with finite values, got ${JSON.stringify(v)}`);
   }
@@ -99361,24 +99468,24 @@ function requireFiniteNumber(n, label) {
   return n;
 }
 function distance$1(a2, b) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   return Math.hypot(b[0] - a2[0], b[1] - a2[1], b[2] - a2[2]);
 }
 function midpoint$1(a2, b) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   return [(a2[0] + b[0]) / 2, (a2[1] + b[1]) / 2, (a2[2] + b[2]) / 2];
 }
-function lerp(a2, b, t) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+function lerp$3(a2, b, t) {
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   requireFiniteNumber(t, "t");
   return [a2[0] + (b[0] - a2[0]) * t, a2[1] + (b[1] - a2[1]) * t, a2[2] + (b[2] - a2[2]) * t];
 }
 function direction(a2, b) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   const dx = b[0] - a2[0];
   const dy = b[1] - a2[1];
   const dz = b[2] - a2[2];
@@ -99389,8 +99496,8 @@ function direction(a2, b) {
   return [dx / len2, dy / len2, dz / len2];
 }
 function offset(point2, dir, amount) {
-  requireVec3(point2, "point");
-  requireVec3(dir, "dir");
+  requireVec3$1(point2, "point");
+  requireVec3$1(dir, "dir");
   requireFiniteNumber(amount, "amount");
   return [point2[0] + dir[0] * amount, point2[1] + dir[1] * amount, point2[2] + dir[2] * amount];
 }
@@ -99400,7 +99507,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: lerp$3,
   /** 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. */
@@ -104532,9 +104639,84 @@ class ConstraintSketch extends Sketch {
    * Select the single arrangement region that contains the given seed point.
    * Throws if no region contains the seed.
    */
-  detectArrangementRegion(seed) {
+  detectArrangementRegion(_seed2) {
     throw new Error("Not implemented");
   }
+  /**
+   * Return the solved constrained path as a sampled 2D polyline.
+   *
+   * Use this when a construction rail was authored with `constrainedSketch()`
+   * and should feed another operation such as `Loft.pathOnXz(...)`.
+   * The sketch must contain exactly one profile path.
+   *
+   * @param samples - Samples per curved segment. Default 32.
+   * @returns The solved path as an open polyline.
+   */
+  toPolyline(samples = 32) {
+    if (!Number.isFinite(samples) || samples < 2) throw new Error("ConstraintSketch.toPolyline() samples must be at least 2");
+    const profileLoops = this.definition.loops.filter((loop) => loop.type === "profile");
+    if (profileLoops.length !== 1) {
+      throw new Error("ConstraintSketch.toPolyline() requires exactly one profile path");
+    }
+    const sampleCount = Math.max(2, Math.round(samples));
+    const pointMap = new Map(this.definition.points.map((point2) => [point2.id, point2]));
+    const lineMap = new Map(this.definition.lines.map((line2) => [line2.id, line2]));
+    const arcMap = new Map(this.definition.arcs.map((arc) => [arc.id, arc]));
+    const bezierMap = new Map(this.definition.beziers.map((bezier) => [bezier.id, bezier]));
+    const points = [];
+    const appendStart = (point2, label) => {
+      const previous = points[points.length - 1];
+      if (!previous) {
+        points.push(point2);
+        return;
+      }
+      if (Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-6) {
+        throw new Error(`ConstraintSketch.toPolyline() profile path is not continuous at ${label}`);
+      }
+    };
+    const appendPoint = (point2) => {
+      const previous = points[points.length - 1];
+      if (!previous || Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-9) points.push(point2);
+    };
+    const requirePoint = (id, label) => {
+      const point2 = pointMap.get(id);
+      if (!point2) throw new Error(`ConstraintSketch.toPolyline() missing ${label}`);
+      return [point2.x, point2.y];
+    };
+    for (const segment of profileLoops[0].segments) {
+      if (segment.kind === "line") {
+        const line2 = lineMap.get(segment.line);
+        if (!line2) throw new Error(`ConstraintSketch.toPolyline() missing line "${segment.line}"`);
+        appendStart(requirePoint(line2.a, `line "${segment.line}" start point`), `line "${segment.line}"`);
+        appendPoint(requirePoint(line2.b, `line "${segment.line}" end point`));
+      } else if (segment.kind === "arc") {
+        const arc = arcMap.get(segment.arc);
+        if (!arc) throw new Error(`ConstraintSketch.toPolyline() missing arc "${segment.arc}"`);
+        const center = requirePoint(arc.center, `arc "${segment.arc}" center point`);
+        const start = requirePoint(arc.start, `arc "${segment.arc}" start point`);
+        const end = requirePoint(arc.end, `arc "${segment.arc}" end point`);
+        appendStart(start, `arc "${segment.arc}"`);
+        const startAngle = Math.atan2(start[1] - center[1], start[0] - center[0]);
+        const endAngle = Math.atan2(end[1] - center[1], end[0] - center[0]);
+        for (const point2 of tessellateArc(center[0], center[1], arc.radius, startAngle, endAngle, arc.clockwise, sampleCount)) {
+          appendPoint(point2);
+        }
+      } else {
+        const bezier = bezierMap.get(segment.bezier);
+        if (!bezier) throw new Error(`ConstraintSketch.toPolyline() missing bezier "${segment.bezier}"`);
+        const p0 = requirePoint(bezier.p0, `bezier "${segment.bezier}" start point`);
+        const p1 = requirePoint(bezier.p1, `bezier "${segment.bezier}" first control point`);
+        const p2 = requirePoint(bezier.p2, `bezier "${segment.bezier}" second control point`);
+        const p3 = requirePoint(bezier.p3, `bezier "${segment.bezier}" end point`);
+        appendStart(p0, `bezier "${segment.bezier}"`);
+        for (const point2 of tessellateBezier(p0[0], p0[1], p1[0], p1[1], p2[0], p2[1], p3[0], p3[1], sampleCount)) {
+          appendPoint(point2);
+        }
+      }
+    }
+    if (points.length < 2) throw new Error("ConstraintSketch.toPolyline() needs at least 2 points");
+    return points;
+  }
   /**
    * Re-solve the sketch after changing the value of one existing constraint.
    *
@@ -107224,7 +107406,7 @@ function chamferTrackedEdge(shape, edge, size, quadrant = [-1, -1]) {
   );
   return buildEdgeFeatureResult(target, plan, "chamfer");
 }
-const EPSILON = 1e-8;
+const EPSILON$1 = 1e-8;
 function toTuple(point2) {
   return Array.isArray(point2) ? [point2[0], point2[1]] : [point2.x, point2.y];
 }
@@ -107235,7 +107417,7 @@ function distance(a2, b) {
 }
 function normalize(vx, vy) {
   const len2 = Math.hypot(vx, vy);
-  if (len2 <= EPSILON) throw new Error("filletCorners requires non-degenerate edges");
+  if (len2 <= EPSILON$1) throw new Error("filletCorners requires non-degenerate edges");
   return [vx / len2, vy / len2];
 }
 function clamp$3(value, min2, max2) {
@@ -107272,19 +107454,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;
-  const isConcave = turn * winding < -EPSILON;
+  const isConvex = turn * winding > EPSILON$1;
+  const isConcave = turn * winding < -EPSILON$1;
   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 || interiorAngle >= Math.PI - EPSILON) {
+  if (interiorAngle <= EPSILON$1 || interiorAngle >= Math.PI - EPSILON$1) {
     throw new Error(`filletCorners corner ${spec2.index} has an unsupported angle`);
   }
   const tangentDistance = spec2.radius / Math.tan(interiorAngle / 2);
-  if (tangentDistance >= inLength - EPSILON || tangentDistance >= outLength - EPSILON) {
+  if (tangentDistance >= inLength - EPSILON$1 || tangentDistance >= outLength - EPSILON$1) {
     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)}`);
   }
@@ -107314,7 +107496,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) throw new Error("filletCorners requires a non-degenerate polygon");
+  if (Math.abs(area2) <= EPSILON$1) throw new Error("filletCorners requires a non-degenerate polygon");
   const winding = Math.sign(area2);
   const geometryByIndex = /* @__PURE__ */ new Map();
   for (const spec2 of corners) {
@@ -107328,7 +107510,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) {
+    if (exitDistance + entryDistance >= edgeLength2 - EPSILON$1) {
       throw new Error(`filletCorners adjacent fillets overlap on edge ${i} -> ${nextIndex}; reduce one of the radii`);
     }
   }
@@ -119832,6 +120014,295 @@ function polygonVertices(sides, radius, options) {
     centerY: options == null ? void 0 : options.centerY
   });
 }
+const LOFT_GUIDE_EPS = 1e-8;
+function orientLoftToAxis(shape, axis) {
+  if (axis === "Z") return shape;
+  if (axis === "Y") return shape.rotateX(-90);
+  return shape.transform([0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1]);
+}
+function buildRailEvaluators(rails, axis, start, end, railSamples) {
+  const seen2 = /* @__PURE__ */ new Set();
+  return rails.map((rail2) => {
+    if (seen2.has(rail2.side)) throw new Error(`Loft.withGuideRails() received more than one ${rail2.side} rail`);
+    seen2.add(rail2.side);
+    const sampled = sampleRailPath(rail2.path, railSamples);
+    if (sampled.length < 2) throw new Error("Loft guide rails require at least two points");
+    const points = sampled.map((point2) => ({ position: axisPosition(axis, point2), cross: crossPointForAxis(axis, point2) }));
+    const ordered = points[points.length - 1].position >= points[0].position ? points : [...points].reverse();
+    validateRailCoverage(ordered, start, end);
+    return { side: rail2.side, points: ordered };
+  });
+}
+function railCrossAt(rail2, position) {
+  const points = rail2.points;
+  if (position <= points[0].position + LOFT_GUIDE_EPS) return points[0].cross;
+  const last = points[points.length - 1];
+  if (position >= last.position - LOFT_GUIDE_EPS) return last.cross;
+  for (let index2 = 0; index2 < points.length - 1; index2 += 1) {
+    const a2 = points[index2];
+    const b = points[index2 + 1];
+    if (position >= a2.position - LOFT_GUIDE_EPS && position <= b.position + LOFT_GUIDE_EPS) {
+      const t = (position - a2.position) / (b.position - a2.position);
+      return [lerp$2(a2.cross[0], b.cross[0], t), lerp$2(a2.cross[1], b.cross[1], t)];
+    }
+  }
+  throw new Error("Loft guide rail does not cover requested station position");
+}
+function validateRailCoverage(points, start, end) {
+  for (let index2 = 1; index2 < points.length; index2 += 1) {
+    if (points[index2].position - points[index2 - 1].position < LOFT_GUIDE_EPS) {
+      throw new Error("Loft guide rails must be monotone along the loft axis");
+    }
+  }
+  if (points[0].position - start > LOFT_GUIDE_EPS || end - points[points.length - 1].position > LOFT_GUIDE_EPS) {
+    throw new Error("Loft guide rails must cover the full station range");
+  }
+}
+function sampleRailPath(path2, samples) {
+  if (Array.isArray(path2)) return path2.map((point2, index2) => requireVec3(point2, `Loft guide rail point ${index2}`));
+  if (path2 instanceof Curve3D || path2 instanceof HermiteCurve3D || path2 instanceof QuinticHermiteCurve3D || path2 instanceof NurbsCurve3D) {
+    return path2.sample(Math.max(2, Math.round(samples))).map((point2, index2) => requireVec3(point2, `Loft guide rail sample ${index2}`));
+  }
+  throw new Error("Loft guide rail path must be a Vec3[] or ForgeCAD 3D curve");
+}
+function requireVec3(point2, label) {
+  if (!Array.isArray(point2) || point2.length !== 3 || !point2.every(Number.isFinite)) {
+    throw new Error(`${label} must be a finite [x, y, z] point`);
+  }
+  return [point2[0], point2[1], point2[2]];
+}
+function axisPosition(axis, point2) {
+  if (axis === "X") return point2[0];
+  if (axis === "Y") return point2[1];
+  return point2[2];
+}
+function crossPointForAxis(axis, point2) {
+  if (axis === "X") return [point2[1], point2[2]];
+  if (axis === "Y") return [point2[0], -point2[2]];
+  return [point2[0], point2[1]];
+}
+function lerp$2(a2, b, t) {
+  return a2 + (b - a2) * t;
+}
+function loftWithGuideRails(stations, rails, options = {}) {
+  if (stations.length < 2) throw new Error("Loft.withGuideRails() requires at least two stations");
+  if (rails.length === 0) throw new Error("Loft.withGuideRails() requires at least one guide rail");
+  const sortedStations = sortedValidStations(stations);
+  const axis = options.axis ?? "Z";
+  const start = sortedStations[0].position;
+  const end = sortedStations[sortedStations.length - 1].position;
+  const railEvaluators = buildRailEvaluators(rails, axis, start, end, options.railSamples ?? 64);
+  const positions = generatedPositions(sortedStations, options.samples);
+  const profiles2 = positions.map((position) => {
+    const source = profileForPosition(sortedStations, position);
+    const bounds = boundsForPosition(sortedStations, position);
+    return fitProfileToBounds(source, applyRailsToBounds(bounds, railEvaluators, position));
+  });
+  const shape = loft(profiles2, positions, {
+    edgeLength: options.edgeLength,
+    boundsPadding: options.boundsPadding
+  });
+  return orientLoftToAxis(shape, axis);
+}
+function sortedValidStations(stations) {
+  const sorted = [...stations].sort((a2, b) => a2.position - b.position);
+  for (let index2 = 0; index2 < sorted.length; index2 += 1) {
+    if (!Number.isFinite(sorted[index2].position)) throw new Error("Loft.withGuideRails station position must be finite");
+    if (!(sorted[index2].profile instanceof Sketch)) throw new Error("Loft.withGuideRails() stations must use Sketch profiles");
+    if (index2 > 0 && sorted[index2].position - sorted[index2 - 1].position < LOFT_GUIDE_EPS) {
+      throw new Error("Loft.withGuideRails() requires unique, strictly increasing station positions");
+    }
+  }
+  return sorted;
+}
+function generatedPositions(stations, samples) {
+  const count = Math.max(2, Math.round(samples ?? Math.max(9, (stations.length - 1) * 8 + 1)));
+  const start = stations[0].position;
+  const end = stations[stations.length - 1].position;
+  const values = /* @__PURE__ */ new Set();
+  const positions = [];
+  const addPosition = (position) => {
+    const key = position.toFixed(9);
+    if (!values.has(key)) {
+      values.add(key);
+      positions.push(position);
+    }
+  };
+  for (let index2 = 0; index2 < count; index2 += 1) addPosition(start + (end - start) * index2 / (count - 1));
+  for (const station of stations) addPosition(station.position);
+  return positions.sort((a2, b) => a2 - b);
+}
+function profileForPosition(stations, position) {
+  for (let index2 = 0; index2 < stations.length - 1; index2 += 1) {
+    if (position <= stations[index2 + 1].position + LOFT_GUIDE_EPS) return stations[index2].profile;
+  }
+  return stations[stations.length - 1].profile;
+}
+function boundsForPosition(stations, position) {
+  if (position <= stations[0].position + LOFT_GUIDE_EPS) return sketchBounds(stations[0].profile);
+  const last = stations[stations.length - 1];
+  if (position >= last.position - LOFT_GUIDE_EPS) return sketchBounds(last.profile);
+  for (let index2 = 0; index2 < stations.length - 1; index2 += 1) {
+    const a2 = stations[index2];
+    const b = stations[index2 + 1];
+    if (position >= a2.position - LOFT_GUIDE_EPS && position <= b.position + LOFT_GUIDE_EPS) {
+      return lerpBounds(sketchBounds(a2.profile), sketchBounds(b.profile), (position - a2.position) / (b.position - a2.position));
+    }
+  }
+  return sketchBounds(last.profile);
+}
+function applyRailsToBounds(bounds, rails, position) {
+  const centerRail = rails.find((rail2) => rail2.side === "center");
+  const center = centerRail ? railCrossAt(centerRail, position) : void 0;
+  const next = { ...bounds };
+  applyAxisRail(next, "X", sideValue(rails, "left", position, 0), sideValue(rails, "right", position, 0), center == null ? void 0 : center[0]);
+  applyAxisRail(next, "Y", sideValue(rails, "back", position, 1), sideValue(rails, "front", position, 1), center == null ? void 0 : center[1]);
+  if (next.maxX - next.minX < LOFT_GUIDE_EPS || next.maxY - next.minY < LOFT_GUIDE_EPS) {
+    throw new Error("Loft.withGuideRails() guide rails produced a non-positive section size");
+  }
+  return next;
+}
+function sideValue(rails, side, position, crossIndex) {
+  const rail2 = rails.find((entry) => entry.side === side);
+  return rail2 ? railCrossAt(rail2, position)[crossIndex] : void 0;
+}
+function applyAxisRail(bounds, axis, minRail, maxRail, center) {
+  const minKey = axis === "X" ? "minX" : "minY";
+  const maxKey = axis === "X" ? "maxX" : "maxY";
+  const width = bounds[maxKey] - bounds[minKey];
+  if (minRail != null && maxRail != null) {
+    if (maxRail - minRail < LOFT_GUIDE_EPS) throw new Error("Loft.withGuideRails() opposite guide rails crossed");
+    if (center != null && Math.abs((minRail + maxRail) / 2 - center) > 1e-5) {
+      throw new Error("Loft.withGuideRails() center rail conflicts with opposite side rails");
+    }
+    bounds[minKey] = minRail;
+    bounds[maxKey] = maxRail;
+  } else if (maxRail != null) {
+    bounds[maxKey] = maxRail;
+    bounds[minKey] = center != null ? 2 * center - maxRail : maxRail - width;
+  } else if (minRail != null) {
+    bounds[minKey] = minRail;
+    bounds[maxKey] = center != null ? 2 * center - minRail : minRail + width;
+  } else if (center != null) {
+    bounds[minKey] = center - width / 2;
+    bounds[maxKey] = center + width / 2;
+  }
+}
+function fitProfileToBounds(profile, target) {
+  const source = sketchBounds(profile);
+  const sourceWidth = source.maxX - source.minX;
+  const sourceDepth = source.maxY - source.minY;
+  if (sourceWidth < LOFT_GUIDE_EPS || sourceDepth < LOFT_GUIDE_EPS) {
+    throw new Error("Loft.withGuideRails() station profiles must have positive bounds");
+  }
+  const sourceCenter = [(source.minX + source.maxX) / 2, (source.minY + source.maxY) / 2];
+  const targetCenter = [(target.minX + target.maxX) / 2, (target.minY + target.maxY) / 2];
+  return profile.scaleAround(sourceCenter, [(target.maxX - target.minX) / sourceWidth, (target.maxY - target.minY) / sourceDepth]).translate(targetCenter[0] - sourceCenter[0], targetCenter[1] - sourceCenter[1]);
+}
+function sketchBounds(profile) {
+  const bounds = profile.bounds();
+  return { minX: bounds.min[0], maxX: bounds.max[0], minY: bounds.min[1], maxY: bounds.max[1] };
+}
+function lerpBounds(a2, b, t) {
+  return {
+    minX: lerp$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)
+  };
+}
+function lerp$1(a2, b, t) {
+  return a2 + (b - a2) * t;
+}
+function mapLoftPath2D(path2, label, mapper) {
+  const points = sampleLoftPath2D(path2, label);
+  return points.map((point2, index2) => {
+    if (!Array.isArray(point2) || point2.length !== 2 || !point2.every(Number.isFinite)) {
+      throw new Error(`${label} point ${index2} must be a finite [x, y] point`);
+    }
+    return mapper([point2[0], point2[1]]);
+  });
+}
+function sampleLoftPath2D(path2, label) {
+  if (Array.isArray(path2)) {
+    if (path2.length < 2) throw new Error(`${label} requires at least two [x, y] points`);
+    return path2;
+  }
+  if (!path2 || typeof path2 !== "object" || typeof path2.toPolyline !== "function") {
+    throw new Error(`${label} requires a 2D path, solved constrained path, or [x, y] point array`);
+  }
+  const points = path2.toPolyline();
+  if (!Array.isArray(points) || points.length < 2) throw new Error(`${label} path must produce at least two [x, y] points`);
+  return points;
+}
+const Loft = {
+  /** Create a loft station from a 2D profile and an axis position. */
+  station(profile, position) {
+    if (!Number.isFinite(position)) throw new Error("Loft.station position must be finite");
+    return { profile, position };
+  },
+  /** Create a guide rail that constrains the section-local negative-X side. */
+  leftRail(path2) {
+    return { side: "left", path: path2 };
+  },
+  /** Create a guide rail that constrains the section-local positive-X side. */
+  rightRail(path2) {
+    return { side: "right", path: path2 };
+  },
+  /** Create a guide rail that constrains the section-local positive-Y side. */
+  frontRail(path2) {
+    return { side: "front", path: path2 };
+  },
+  /** Create a guide rail that constrains the section-local negative-Y side. */
+  backRail(path2) {
+    return { side: "back", path: path2 };
+  },
+  /** Create a guide rail that moves section centers along the loft. */
+  centerRail(path2) {
+    return { side: "center", path: path2 };
+  },
+  /**
+   * Place a 2D guide path onto the XZ plane.
+   *
+   * The path's first coordinate becomes X and its second coordinate becomes Z.
+   * Use this for left/right silhouette rails authored with `path()` or `constrainedSketch()`.
+   */
+  pathOnXz(path2, y2 = 0) {
+    if (!Number.isFinite(y2)) throw new Error("Loft.pathOnXz y must be finite");
+    return mapLoftPath2D(path2, "Loft.pathOnXz", ([x2, z2]) => [x2, y2, z2]);
+  },
+  /**
+   * Place a 2D guide path onto the YZ plane.
+   *
+   * The path's first coordinate becomes Y and its second coordinate becomes Z.
+   * Use this for front/back crown rails authored with `path()` or `constrainedSketch()`.
+   */
+  pathOnYz(path2, x2 = 0) {
+    if (!Number.isFinite(x2)) throw new Error("Loft.pathOnYz x must be finite");
+    return mapLoftPath2D(path2, "Loft.pathOnYz", ([y2, z2]) => [x2, y2, z2]);
+  },
+  /**
+   * Place a 2D guide path onto the XY plane.
+   *
+   * The path's first coordinate becomes X and its second coordinate becomes Y.
+   * Use this when lofting along X or Y and a rail lives in a horizontal sketch plane.
+   */
+  pathOnXy(path2, z2 = 0) {
+    if (!Number.isFinite(z2)) throw new Error("Loft.pathOnXy z must be finite");
+    return mapLoftPath2D(path2, "Loft.pathOnXy", ([x2, y2]) => [x2, y2, z2]);
+  },
+  /**
+   * Loft through profile stations while forcing generated sections to follow guide rails.
+   *
+   * Stations define the cross-section family. Guide rails define the side or center
+   * paths the loft must pass through. With opposite side rails, the section is scaled
+   * to touch both rails. With one side rail, the section keeps its interpolated size
+   * unless a center rail is also present.
+   */
+  withGuideRails(stations, rails, options = {}) {
+    return loftWithGuideRails(stations, rails, options);
+  }
+};
 let collectedHighlights = [];
 function resetHighlights() {
   collectedHighlights = [];
@@ -120504,7 +120975,7 @@ function resolveCornerYSelection(edges, options = {}) {
   for (const candidate of candidates) {
     const selectedEndpoints = [];
     let totalGap = 0;
-    let maxGap = 0;
+    let maxGap2 = 0;
     for (const edge of edges) {
       const start = edgeEndpoint(edge, "start");
       const end = edgeEndpoint(edge, "end");
@@ -120514,10 +120985,10 @@ function resolveCornerYSelection(edges, options = {}) {
       const gap = Math.min(startGap, endGap);
       selectedEndpoints.push(selected);
       totalGap += gap;
-      maxGap = Math.max(maxGap, gap);
+      maxGap2 = Math.max(maxGap2, gap);
     }
-    if (maxGap <= cornerTolerance && (!best || totalGap < best.totalGap)) {
-      best = { totalGap, maxGap, selectedEndpoints };
+    if (maxGap2 <= cornerTolerance && (!best || totalGap < best.totalGap)) {
+      best = { totalGap, maxGap: maxGap2, selectedEndpoints };
     }
   }
   if (!best) {
@@ -338491,6 +338962,7 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       nurbsSurface,
       spline2d,
       spline3d,
+      Loft,
       loft,
       loftAlongSpine,
       sweep,
@@ -338946,6 +339418,644 @@ function runScript(code, fileName = "main.forge.js", allFiles = {}, options = {}
     }
   }
 }
+const DEFAULT_COLLISION_INSPECTION_OPTIONS = {
+  minOverlapVolume: 0.1
+};
+function cloneVec3$1(value) {
+  return [value[0], value[1], value[2]];
+}
+function isIdentityTransform(matrix) {
+  if (!matrix) return true;
+  const identity = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+  return identity.every((value, index2) => Math.abs(matrix[index2] - value) <= 1e-12);
+}
+function transformPoint(matrix, point2) {
+  const [x2, y2, z2] = point2;
+  return [
+    matrix[0] * x2 + matrix[4] * y2 + matrix[8] * z2 + matrix[12],
+    matrix[1] * x2 + matrix[5] * y2 + matrix[9] * z2 + matrix[13],
+    matrix[2] * x2 + matrix[6] * y2 + matrix[10] * z2 + matrix[14]
+  ];
+}
+function transformBBox(min2, max2, matrix) {
+  const corners = [
+    [min2[0], min2[1], min2[2]],
+    [min2[0], min2[1], max2[2]],
+    [min2[0], max2[1], min2[2]],
+    [min2[0], max2[1], max2[2]],
+    [max2[0], min2[1], min2[2]],
+    [max2[0], min2[1], max2[2]],
+    [max2[0], max2[1], min2[2]],
+    [max2[0], max2[1], max2[2]]
+  ];
+  const outMin = [Infinity, Infinity, Infinity];
+  const outMax = [-Infinity, -Infinity, -Infinity];
+  for (const corner of corners) {
+    const transformed = transformPoint(matrix, corner);
+    for (let axis = 0; axis < 3; axis += 1) {
+      outMin[axis] = Math.min(outMin[axis], transformed[axis]);
+      outMax[axis] = Math.max(outMax[axis], transformed[axis]);
+    }
+  }
+  return { min: outMin, max: outMax };
+}
+function prepareEntry(entry) {
+  if (isIdentityTransform(entry.transform)) {
+    return {
+      ...entry,
+      min: cloneVec3$1(entry.min),
+      max: cloneVec3$1(entry.max)
+    };
+  }
+  const bbox = transformBBox(entry.min, entry.max, entry.transform);
+  return {
+    ...entry,
+    shape: entry.shape.transform(entry.transform),
+    min: bbox.min,
+    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 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 serializeCollisionFinding(finding) {
+  return {
+    index: finding.index,
+    id: finding.id,
+    sourceIndex: finding.sourceIndex,
+    targetIndex: finding.targetIndex,
+    sourceId: finding.sourceId,
+    targetId: finding.targetId,
+    sourceName: finding.sourceName,
+    targetName: finding.targetName,
+    overlapVolume: finding.overlapVolume
+  };
+}
+function analyzeCollisionIntersections(entries, rawOptions = {}) {
+  const options = {
+    minOverlapVolume: rawOptions.minOverlapVolume ?? DEFAULT_COLLISION_INSPECTION_OPTIONS.minOverlapVolume
+  };
+  const warnings = [];
+  const collisions = [];
+  const preparedEntries = entries.map((entry) => prepareEntry(entry));
+  const { pairs: candidatePairs, bboxPairChecks } = collectCandidatePairs$1(preparedEntries);
+  for (const pair of candidatePairs) {
+    const a2 = preparedEntries[pair.sourceIndex];
+    const b = preparedEntries[pair.targetIndex];
+    try {
+      const hit = a2.shape.intersect(b.shape);
+      if (hit.isEmpty()) continue;
+      const overlapVolume = hit.volume();
+      if (!Number.isFinite(overlapVolume) || overlapVolume <= options.minOverlapVolume) continue;
+      collisions.push({
+        index: collisions.length + 1,
+        id: collisionId(a2, b),
+        sourceIndex: pair.sourceIndex,
+        targetIndex: pair.targetIndex,
+        sourceId: a2.id,
+        targetId: b.id,
+        sourceName: a2.name,
+        targetName: b.name,
+        overlapVolume,
+        shape: hit
+      });
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : String(err2);
+      warnings.push(`Could not boolean-test ${a2.name} against ${b.name}: ${message}`);
+    }
+  }
+  const objects = preparedEntries.map((entry, index2) => ({
+    index: index2,
+    id: entry.id,
+    name: entry.name,
+    groupName: entry.groupName,
+    treePath: entry.treePath,
+    mock: entry.mock === true,
+    bbox: {
+      min: cloneVec3$1(entry.min),
+      max: cloneVec3$1(entry.max)
+    }
+  }));
+  return {
+    method: "boolean-intersection",
+    options,
+    broadphase: {
+      method: "sweep-and-prune",
+      allPairCount: preparedEntries.length * (preparedEntries.length - 1) / 2,
+      bboxPairChecks,
+      booleanPairChecks: candidatePairs.length
+    },
+    objectCount: objects.length,
+    collisionCount: collisions.length,
+    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;
@@ -339117,6 +340227,494 @@ 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,
@@ -339212,64 +340810,75 @@ export {
   DEFAULT_ACTIVE_BACKEND as ay,
   isConstraintSketch as az,
   PCFShadowMap as b,
+  generateCuttingLayoutPdf as b$,
   PointLight as b0,
   DirectionalLight as b1,
-  buildShapeFromCompilePlan as b2,
+  analyzeCollisionIntersections as b2,
   shapeToGeometry as b3,
-  sketchToSvg as b4,
-  sketchToDxf as b5,
-  runScript as b6,
-  MeshPhysicalMaterial as b7,
-  LineSegments as b8,
-  getRenderStylePreset as b9,
-  resolveJointAnimation as bA,
-  resolveJointViewValues as bB,
-  getShapePorts as bC,
-  getShapeUsedPorts as bD,
-  DEFAULT_VIEW_CONFIG as bE,
-  getKernelFaceNameForTriangle as bF,
-  initKernel as bG,
-  initSolverWasm as bH,
-  BoxGeometry as bI,
-  localAabbPlaneRelation as bJ,
-  ShapeUtils as bK,
-  Group as bL,
-  intersectWithPlane as bM,
-  parseCameraCliSpec as bN,
-  PMREMGenerator as bO,
-  worldAuthorPlaneToLocal as bP,
-  generateCuttingLayoutPdf as bQ,
-  getCameraForwardVector as bR,
-  RENDER_STYLE_OPTIONS as bS,
-  initKernelManifoldOnly as bT,
-  __viteBrowserExternal$1 as bU,
-  AdditiveBlending as ba,
-  CatmullRomCurve3 as bb,
-  TubeGeometry as bc,
-  MeshStandardMaterial as bd,
-  compileSdfNode3 as be,
-  buildSdfRaymarchFragmentShader as bf,
-  SDF_RAYMARCH_PROXY_VERTEX_SHADER as bg,
-  Shape2 as bh,
-  ShapeGeometry as bi,
-  ShaderLib as bj,
-  CylinderGeometry as bk,
-  parseViewportCameraState as bl,
-  createResolvedExplodeConfig as bm,
-  explodeBoundsCenter as bn,
-  explodeMergeBounds as bo,
-  resolveExplodeDirective as bp,
-  computeExplodeMotion as bq,
-  getSketchWorldMatrix as br,
-  explodeAdd as bs,
-  hasExplodeOverride as bt,
-  resolveExplodeLocalFanDirection as bu,
-  explodeMul as bv,
-  explodeLeafFanStage as bw,
-  normalizeCutPlane as bx,
-  toClippingPlane as by,
-  findJointAnimationClip as bz,
+  buildShapeFromCompilePlan as b4,
+  sketchToSvg as b5,
+  sketchToDxf as b6,
+  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,
+  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,
   SRGBColorSpace as c,
+  getCameraForwardVector as c0,
+  RENDER_STYLE_OPTIONS as c1,
+  initKernelManifoldOnly as c2,
+  __viteBrowserExternal$1 as c3,
   Layers as d,
   Color as e,
   RGBAFormat as f,