forgecad 0.9.5 → 0.9.6

package/dist-cli/forgecad.js

@@ -10389,6 +10389,7 @@ function buildSweepLevelSetInput(profilePolygons, pathInput, options) {
 }
 
 // src/forge/sketch/polygonSampling.ts
+var EPS5 = 1e-9;
 function resamplePolygon(poly, targetCount) {
   if (poly.length < 2) return poly;
   if (targetCount <= 0) return [];
@@ -10426,6 +10427,78 @@ function resamplePolygon(poly, targetCount) {
   }
   return out;
 }
+function resamplePolygonByAngle(poly, targetCount, center = polygonCentroid(poly)) {
+  if (poly.length < 3 || targetCount <= 0) return null;
+  if (!isConvexPolygon(poly)) return null;
+  const out = [];
+  for (let index = 0; index < targetCount; index += 1) {
+    const angle = index / 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 index = 0; index < poly.length; index += 1) {
+    const a = poly[index];
+    const b = poly[(index + 1) % poly.length];
+    const edge = [b[0] - a[0], b[1] - a[1]];
+    const denom = cross2(direction2, edge);
+    if (Math.abs(denom) < EPS5) continue;
+    const delta = [a[0] - origin[0], a[1] - origin[1]];
+    const rayT = cross2(delta, edge) / denom;
+    const edgeT = cross2(delta, direction2) / denom;
+    if (rayT >= -EPS5 && edgeT >= -EPS5 && edgeT <= 1 + EPS5 && rayT < bestT) {
+      bestT = rayT;
+      best = [origin[0] + direction2[0] * rayT, origin[1] + direction2[1] * rayT];
+    }
+  }
+  return best;
+}
+function polygonCentroid(poly) {
+  let area2 = 0;
+  let cx = 0;
+  let cy = 0;
+  for (let index = 0; index < poly.length; index += 1) {
+    const a = poly[index];
+    const b = poly[(index + 1) % poly.length];
+    const crossValue = cross2(a, b);
+    area2 += crossValue;
+    cx += (a[0] + b[0]) * crossValue;
+    cy += (a[1] + b[1]) * crossValue;
+  }
+  if (Math.abs(area2) < EPS5) return averagePoint(poly);
+  return [cx / (3 * area2), cy / (3 * area2)];
+}
+function averagePoint(poly) {
+  let x = 0;
+  let y = 0;
+  for (const point2 of poly) {
+    x += point2[0];
+    y += point2[1];
+  }
+  return [x / poly.length, y / poly.length];
+}
+function isConvexPolygon(poly) {
+  let sign2 = 0;
+  for (let index = 0; index < poly.length; index += 1) {
+    const a = poly[index];
+    const b = poly[(index + 1) % poly.length];
+    const c = poly[(index + 2) % poly.length];
+    const turn = cross2([b[0] - a[0], b[1] - a[1]], [c[0] - b[0], c[1] - b[1]]);
+    if (Math.abs(turn) < EPS5) continue;
+    const currentSign = Math.sign(turn);
+    if (sign2 !== 0 && currentSign !== sign2) return false;
+    sign2 = currentSign;
+  }
+  return sign2 !== 0;
+}
+function cross2(a, b) {
+  return a[0] * b[1] - a[1] * b[0];
+}
 
 // src/forge/backends/manifold/loftStitched.ts
 function loftStitched(profiles2, heights, wasm) {
@@ -10556,8 +10629,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 z = heights[i];
     return pts2d.map(([x, y]) => [x, y, z]);
   });
@@ -10843,13 +10918,13 @@ function computeParallelTransportFrames2(path4, preferredUp) {
   const frames = [];
   const firstTangent = normalize3(sub2(path4[1], path4[0]));
   if (!firstTangent) return null;
-  let x = normalize3(cross2(preferredUp, firstTangent));
+  let x = normalize3(cross3(preferredUp, firstTangent));
   if (!x || length4(x) < 1e-8) {
     const fallback = Math.abs(firstTangent[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
-    x = normalize3(cross2(fallback, firstTangent));
+    x = normalize3(cross3(fallback, firstTangent));
     if (!x) return null;
   }
-  let y = normalize3(cross2(firstTangent, x));
+  let y = normalize3(cross3(firstTangent, x));
   frames.push({ origin: path4[0], x, y, t: firstTangent });
   for (let i = 1; i < n; i++) {
     const prevT = frames[i - 1].t;
@@ -10864,7 +10939,7 @@ function computeParallelTransportFrames2(path4, preferredUp) {
       if (!nt) return null;
       nextT = nt;
     }
-    const v = cross2(prevT, nextT);
+    const v = cross3(prevT, nextT);
     const vLen = length4(v);
     const c = dot(prevT, nextT);
     if (vLen > 1e-10) {
@@ -10952,7 +11027,7 @@ function scale2(v, s) {
 function dot(a, b) {
   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }
-function cross2(a, b) {
+function cross3(a, b) {
   return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
 }
 function length4(v) {
@@ -10965,7 +11040,7 @@ function normalize3(v) {
 }
 function rotateVector2(v, axis, c, s) {
   const kDotV = dot(axis, v);
-  const kCrossV = cross2(axis, v);
+  const kCrossV = cross3(axis, v);
   return [
     v[0] * c + kCrossV[0] * s + axis[0] * kDotV * (1 - c),
     v[1] * c + kCrossV[1] * s + axis[1] * kDotV * (1 - c),
@@ -11257,7 +11332,7 @@ function subtract3(a, b) {
 function addScaled3(point2, direction2, scale8) {
   return [point2[0] + direction2[0] * scale8, point2[1] + direction2[1] * scale8, point2[2] + direction2[2] * scale8];
 }
-function cross3(a, b) {
+function cross32(a, b) {
   return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
 }
 function fromSlicesPlaneFrameForManifold(normalInput) {
@@ -11273,8 +11348,8 @@ function fromSlicesPlaneFrameForManifold(normalInput) {
     return { u: [0, 1, 0], v: [0, 0, nx > 0 ? 1 : -1], normal };
   }
   const reference = Math.abs(nx) < 0.9 ? [1, 0, 0] : [0, 1, 0];
-  const u = normalizeVec32(cross3(reference, normal), "Shape.fromSlices profile u axis");
-  return { u, v: cross3(normal, u), normal };
+  const u = normalizeVec32(cross32(reference, normal), "Shape.fromSlices profile u axis");
+  return { u, v: cross32(normal, u), normal };
 }
 function fromSlicesLocalToWorldMatrixForManifold(normal) {
   const frame = fromSlicesPlaneFrameForManifold(normal);
@@ -11314,7 +11389,7 @@ function isDistancePreservingMatrix(matrix) {
   const col0 = [matrix[0], matrix[1], matrix[2]];
   const col1 = [matrix[4], matrix[5], matrix[6]];
   const col2 = [matrix[8], matrix[9], matrix[10]];
-  const det = dot32(col0, cross3(col1, col2));
+  const det = dot32(col0, cross32(col1, col2));
   return Math.abs(vectorLength3(col0) - 1) <= 1e-6 && Math.abs(vectorLength3(col1) - 1) <= 1e-6 && Math.abs(vectorLength3(col2) - 1) <= 1e-6 && Math.abs(dot32(col0, col1)) <= 1e-6 && Math.abs(dot32(col0, col2)) <= 1e-6 && Math.abs(dot32(col1, col2)) <= 1e-6 && Math.abs(Math.abs(det) - 1) <= 1e-6;
 }
 function offsetSolidTransformDistanceScaleForManifold(step) {
@@ -11486,7 +11561,7 @@ function isStraightMonotonePolylineForManifold(points) {
   for (const point2 of points) {
     const offset2 = subtract3(point2, start);
     const projection = dot32(offset2, axis) / axisLengthSq;
-    const lineDistance = vectorLength3(cross3(offset2, axis)) / axisLength;
+    const lineDistance = vectorLength3(cross32(offset2, axis)) / axisLength;
     if (lineDistance > 1e-5 || projection < -1e-6 || projection > 1 + 1e-6 || projection + 1e-6 < previousProjection) {
       return false;
     }
@@ -11967,11 +12042,11 @@ function lowerVerticalVariableSweepStitchedForManifold(plan, sectionPolygons, wa
   }
   let frameX;
   try {
-    frameX = normalizeVec32(cross3(up, tangent), "variableSweep profile x axis");
+    frameX = normalizeVec32(cross32(up, tangent), "variableSweep profile x axis");
   } catch {
     return null;
   }
-  const frameY = cross3(tangent, frameX);
+  const frameY = cross32(tangent, frameX);
   const span = end[2] - start[2];
   const sections = sectionPolygons.map((section) => ({
     height: start[2] + span * section.t,
@@ -12835,7 +12910,7 @@ function extractMeshFromShape(oc, shape, linearDeflection = DEFAULT_LINEAR_DEFLE
     }
     expl.Next();
   }
-  const EPS18 = 1e-8;
+  const EPS19 = 1e-8;
   const vertProperties = new Float32Array(allPositions);
   const triVerts = new Uint32Array(allIndices);
   const mergeFrom = [];
@@ -12845,7 +12920,7 @@ function extractMeshFromShape(oc, shape, linearDeflection = DEFAULT_LINEAR_DEFLE
     const x = allPositions[i * 3];
     const y = allPositions[i * 3 + 1];
     const z = allPositions[i * 3 + 2];
-    const key = `${Math.round(x / EPS18)}:${Math.round(y / EPS18)}:${Math.round(z / EPS18)}`;
+    const key = `${Math.round(x / EPS19)}:${Math.round(y / EPS19)}:${Math.round(z / EPS19)}`;
     const existing = vertMap.get(key);
     if (existing !== void 0 && existing !== i) {
       mergeFrom.push(i);
@@ -15372,16 +15447,16 @@ function marchingTetrahedra(sdfFn, bounds2, edgeLength2) {
 }
 
 // src/forge/offsetSolidAnalytic.ts
-var EPS5 = 1e-9;
+var EPS6 = 1e-9;
 function finitePositive(value) {
-  return Number.isFinite(value) && value > EPS5;
+  return Number.isFinite(value) && value > EPS6;
 }
 function clampNonNegative(value) {
-  return Math.abs(value) <= EPS5 ? 0 : value;
+  return Math.abs(value) <= EPS6 ? 0 : value;
 }
 function distancePreservingMatrixScale(matrix) {
   if (matrix.length !== 16 || matrix.some((value) => !Number.isFinite(value))) return null;
-  if (Math.abs(matrix[3]) > EPS5 || Math.abs(matrix[7]) > EPS5 || Math.abs(matrix[11]) > EPS5 || Math.abs(matrix[15] - 1) > EPS5) {
+  if (Math.abs(matrix[3]) > EPS6 || Math.abs(matrix[7]) > EPS6 || Math.abs(matrix[11]) > EPS6 || Math.abs(matrix[15] - 1) > EPS6) {
     return null;
   }
   const col0 = [matrix[0], matrix[1], matrix[2]];
@@ -15393,8 +15468,8 @@ function distancePreservingMatrixScale(matrix) {
   const sy = length7(col1);
   const sz = length7(col2);
   if (!finitePositive(sx) || !finitePositive(sy) || !finitePositive(sz)) return null;
-  if (Math.abs(sx - sy) > EPS5 || Math.abs(sx - sz) > EPS5) return null;
-  if (Math.abs(dot12(col0, col1)) > EPS5 || Math.abs(dot12(col0, col2)) > EPS5 || Math.abs(dot12(col1, col2)) > EPS5) return null;
+  if (Math.abs(sx - sy) > EPS6 || Math.abs(sx - sz) > EPS6) return null;
+  if (Math.abs(dot12(col0, col1)) > EPS6 || Math.abs(dot12(col0, col2)) > EPS6 || Math.abs(dot12(col1, col2)) > EPS6) return null;
   return sx;
 }
 function transformStepDistanceScale(step) {
@@ -15410,7 +15485,7 @@ function transformStepDistanceScale(step) {
       const sy = Math.abs(step.y);
       const sz = Math.abs(step.z);
       if (!finitePositive(sx) || !finitePositive(sy) || !finitePositive(sz)) return null;
-      return Math.abs(sx - sy) <= EPS5 && Math.abs(sx - sz) <= EPS5 ? sx : null;
+      return Math.abs(sx - sy) <= EPS6 && Math.abs(sx - sz) <= EPS6 ? sx : null;
     }
   }
 }
@@ -15441,7 +15516,7 @@ function cloneTransformStep(step) {
   }
 }
 function translatedPlan(base, z) {
-  if (Math.abs(z) <= EPS5) return base;
+  if (Math.abs(z) <= EPS6) return base;
   return {
     kind: "transform",
     base,
@@ -15458,7 +15533,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 < -EPS5 || offsetRadiusTop < -EPS5) return null;
+  if (!finitePositive(height) || radiusBottom < -EPS6 || offsetRadiusTop < -EPS6) return null;
   return {
     zMin,
     height,
@@ -15482,7 +15557,7 @@ function transformProfilePoint(point2, transform) {
       const nx = transform.normalX;
       const ny = transform.normalY;
       const len2 = Math.hypot(nx, ny);
-      if (len2 <= EPS5) return point2;
+      if (len2 <= EPS6) return point2;
       const ux = nx / len2;
       const uy = ny / len2;
       const d = point2[0] * ux + point2[1] * uy;
@@ -15496,7 +15571,7 @@ function transformProfilePointThrough(point2, transforms) {
   return out;
 }
 function sameScalar2(a, b) {
-  return Math.abs(a - b) <= EPS5;
+  return Math.abs(a - b) <= EPS6;
 }
 function sameProfilePoint(a, b) {
   return sameScalar2(a[0], b[0]) && sameScalar2(a[1], b[1]);
@@ -15549,7 +15624,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 < -EPS5 || !finitePositive(xMax) || !finitePositive(zMax - zMin)) return null;
+  if (xMin < -EPS6 || !finitePositive(xMax) || !finitePositive(zMax - zMin)) return null;
   const hasCorner = (x, z) => points.some(([px, pz]) => sameScalar2(px, x) && sameScalar2(pz, z));
   if (!hasCorner(xMin, zMin) || !hasCorner(xMax, zMin) || !hasCorner(xMax, zMax) || !hasCorner(xMin, zMax)) return null;
   return {
@@ -15572,7 +15647,7 @@ function circleFootprintFromProfile(plan) {
   const yScale = Math.hypot(yAxis[0], yAxis[1]);
   const dot12 = xAxis[0] * yAxis[0] + xAxis[1] * yAxis[1];
   if (!finitePositive(xScale) || !finitePositive(yScale)) return null;
-  if (Math.abs(xScale - yScale) > EPS5 || Math.abs(dot12) > EPS5 * xScale * yScale) return null;
+  if (Math.abs(xScale - yScale) > EPS6 || Math.abs(dot12) > EPS6 * xScale * yScale) return null;
   return {
     center,
     radius: radius * xScale,
@@ -15580,11 +15655,11 @@ function circleFootprintFromProfile(plan) {
   };
 }
 function fullCircleRevolveTorusPlan(plan, minorRadiusOffset = 0) {
-  if (Math.abs(plan.degrees - 360) > EPS5) return null;
+  if (Math.abs(plan.degrees - 360) > EPS6) return null;
   const circle2 = circleFootprintFromProfile(plan.profile);
-  if (!circle2 || circle2.center[0] <= EPS5) return null;
+  if (!circle2 || circle2.center[0] <= EPS6) return null;
   const minorRadius = circle2.radius + minorRadiusOffset;
-  if (!finitePositive(minorRadius) || minorRadius >= circle2.center[0] - EPS5) return null;
+  if (!finitePositive(minorRadius) || minorRadius >= circle2.center[0] - EPS6) return null;
   return translatedPlan(
     {
       kind: "torus",
@@ -15597,7 +15672,7 @@ function fullCircleRevolveTorusPlan(plan, minorRadiusOffset = 0) {
 }
 function fullAxisRectRevolveCylinderPlan(plan) {
   const rectangle = fullRectRevolveSurfacePlan(plan);
-  if (!rectangle || rectangle.innerRadius > EPS5) return null;
+  if (!rectangle || rectangle.innerRadius > EPS6) return null;
   return translatedPlan(
     {
       kind: "cylinder",
@@ -15620,20 +15695,20 @@ function rectRevolveSurfacePlan(plan) {
   };
 }
 function fullRectRevolveSurfacePlan(plan) {
-  if (Math.abs(plan.degrees - 360) > EPS5) return null;
+  if (Math.abs(plan.degrees - 360) > EPS6) return null;
   return rectRevolveSurfacePlan(plan);
 }
 function offsetFullRectRevolvePlan(plan, thickness) {
   const cylinderPlan2 = fullAxisRectRevolveCylinderPlan(plan);
   if (cylinderPlan2) return offsetSolidAnalyticPrimitivePlan(cylinderPlan2, thickness);
   const rectangle = fullRectRevolveSurfacePlan(plan);
-  if (!rectangle || rectangle.innerRadius <= EPS5) return null;
+  if (!rectangle || rectangle.innerRadius <= EPS6) return null;
   const innerRadius = rectangle.innerRadius - thickness;
   const outerRadius = rectangle.outerRadius + thickness;
   const height = rectangle.zMax - rectangle.zMin + 2 * thickness;
-  if (innerRadius < -EPS5 || !finitePositive(outerRadius) || !finitePositive(height) || outerRadius <= innerRadius + EPS5) return null;
+  if (innerRadius < -EPS6 || !finitePositive(outerRadius) || !finitePositive(height) || outerRadius <= innerRadius + EPS6) return null;
   const zCenter = (rectangle.zMin + rectangle.zMax) / 2;
-  if (innerRadius <= EPS5) {
+  if (innerRadius <= EPS6) {
     return translatedPlan(
       {
         kind: "cylinder",
@@ -15712,7 +15787,7 @@ function offsetSolidAnalyticPrimitivePlan(base, thickness) {
     }
     case "torus": {
       const minorRadius = base.minorRadius + thickness;
-      if (!finitePositive(minorRadius) || minorRadius >= base.majorRadius - EPS5) return null;
+      if (!finitePositive(minorRadius) || minorRadius >= base.majorRadius - EPS6) return null;
       return {
         kind: "torus",
         majorRadius: base.majorRadius,
@@ -18985,7 +19060,7 @@ function isStraightMonotonePolyline(points) {
   for (const point2 of points) {
     const offset2 = subtract32(point2, start);
     const projection = dot33(offset2, axis) / axisLengthSq;
-    const lineDistance = vectorLength32(cross32(offset2, axis)) / axisLength;
+    const lineDistance = vectorLength32(cross33(offset2, axis)) / axisLength;
     if (lineDistance > 1e-5 || projection < -1e-6 || projection > 1 + 1e-6 || projection + 1e-6 < previousProjection) {
       return false;
     }
@@ -19061,7 +19136,7 @@ function isDistancePreservingMatrix2(matrix) {
   const col0 = [matrix[0], matrix[1], matrix[2]];
   const col1 = [matrix[4], matrix[5], matrix[6]];
   const col2 = [matrix[8], matrix[9], matrix[10]];
-  const det = dot33(col0, cross32(col1, col2));
+  const det = dot33(col0, cross33(col1, col2));
   return Math.abs(vectorLength32(col0) - 1) <= eps && Math.abs(vectorLength32(col1) - 1) <= eps && Math.abs(vectorLength32(col2) - 1) <= eps && Math.abs(dot33(col0, col1)) <= eps && Math.abs(dot33(col0, col2)) <= eps && Math.abs(dot33(col1, col2)) <= eps && Math.abs(Math.abs(det) - 1) <= eps;
 }
 function offsetSolidTransformDistanceScale(step) {
@@ -19397,7 +19472,7 @@ function triangleNormal(vertices, triangle) {
   const c = vertices[triangle[2]];
   const ab = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
   const ac = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
-  const normal = cross32(ab, ac);
+  const normal = cross33(ab, ac);
   const len2 = Math.hypot(normal[0], normal[1], normal[2]);
   if (len2 <= 1e-12) return null;
   return [normal[0] / len2, normal[1] / len2, normal[2] / len2];
@@ -19511,7 +19586,7 @@ function lowerSurfaceThickenPlan2(plan) {
   if (!grid) truckUnsupported("surface thickening for this surface source");
   return lowerThickenedSurfaceGrid(grid, plan.thickness);
 }
-function cross32(a, b) {
+function cross33(a, b) {
   return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
 }
 function fromSlicesPlaneFrame(normalInput) {
@@ -19527,8 +19602,8 @@ function fromSlicesPlaneFrame(normalInput) {
     return { u: [0, 1, 0], v: [0, 0, nx > 0 ? 1 : -1], normal };
   }
   const reference = Math.abs(nx) < 0.9 ? [1, 0, 0] : [0, 1, 0];
-  const u = normalizedVector3(cross32(reference, normal), "Shape.fromSlices profile u axis");
-  return { u, v: cross32(normal, u), normal };
+  const u = normalizedVector3(cross33(reference, normal), "Shape.fromSlices profile u axis");
+  return { u, v: cross33(normal, u), normal };
 }
 function fromSlicesLocalToWorldMatrix(normal) {
   const frame = fromSlicesPlaneFrame(normal);
@@ -23835,14 +23910,14 @@ function normalize2d(vec) {
   if (len2 < 1e-12) return [1, 0];
   return [vec[0] / len2, vec[1] / len2];
 }
-function cross33(a, b) {
+function cross34(a, b) {
   return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
 }
 function orthonormalBasisFromNormal(normal) {
   const n = normalizeAxis(normal);
   const seed = Math.abs(n[2]) < 0.9 ? [0, 0, 1] : [0, 1, 0];
-  const u = normalizeAxis(cross33(seed, n));
-  const v = normalizeAxis(cross33(n, u));
+  const u = normalizeAxis(cross34(seed, n));
+  const v = normalizeAxis(cross34(n, u));
   return { u, v };
 }
 function faceFrom2DEdge(name, start, end, zMid, ownerQuery) {
@@ -24718,7 +24793,7 @@ function resolveShapeFaceTableInternal(plan, owner) {
             forwardStart3[1] - reverseStart3[1],
             forwardStart3[2] - reverseStart3[2]
           ]);
-          const normal = normalizeAxis(cross33(edgeVec, depthVec));
+          const normal = normalizeAxis(cross34(edgeVec, depthVec));
           registerFace(table, {
             name: wall.name,
             normal,
@@ -25241,7 +25316,7 @@ function normalize32(v) {
 function dot34(a, b) {
   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }
-function cross34(a, b) {
+function cross35(a, b) {
   return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
 }
 function sub32(a, b) {
@@ -25254,7 +25329,7 @@ function perpendicularTo(axis) {
   const absX = Math.abs(axis[0]);
   const absZ = Math.abs(axis[2]);
   const seed = absX < absZ ? [1, 0, 0] : [0, 0, 1];
-  return normalize32(cross34(axis, seed));
+  return normalize32(cross35(axis, seed));
 }
 function normalizePortInput(input) {
   let origin;
@@ -25404,7 +25479,7 @@ function computeConnectFrame(childBase, childPort, parentPort, _flip, childAlign
   const cI = childBase.point(childAlignPt);
   const cAxis = normalize32(childBase.vector(childPort.axis));
   const cUp = normalize32(childBase.vector(childPort.up));
-  const cRight = normalize32(cross34(cAxis, cUp));
+  const cRight = normalize32(cross35(cAxis, cUp));
   const pOrigin = parentAlignPt;
   const jointKind = childPort.kind ?? parentPort.kind;
   const faceToFace = jointKind !== "prismatic";
@@ -25413,7 +25488,7 @@ function computeConnectFrame(childBase, childPort, parentPort, _flip, childAlign
   if (faceToFace && dot34(cUp, pUp) < 0) {
     pUp = negate3(pUp);
   }
-  const pRight = normalize32(cross34(pAxis, pUp));
+  const pRight = normalize32(cross35(pAxis, pUp));
   const r00 = pRight[0] * cRight[0] + pUp[0] * cUp[0] + pAxis[0] * cAxis[0];
   const r01 = pRight[0] * cRight[1] + pUp[0] * cUp[1] + pAxis[0] * cAxis[1];
   const r02 = pRight[0] * cRight[2] + pUp[0] * cUp[2] + pAxis[0] * cAxis[2];
@@ -25523,7 +25598,7 @@ function normalize33(v) {
   if (l < 1e-10) throw new Error("Cannot normalize zero-length vector");
   return [v[0] / l, v[1] / l, v[2] / l];
 }
-function cross35(a, b) {
+function cross36(a, b) {
   return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
 }
 function sub33(a, b) {
@@ -25533,8 +25608,8 @@ function negate32(v) {
   return [-v[0], -v[1], -v[2]];
 }
 function alignmentMatrix(childOrigin, childAxis, childUp, parentOrigin, parentAxis, parentUp) {
-  const cRight = normalize33(cross35(childAxis, childUp));
-  const pRight = normalize33(cross35(parentAxis, parentUp));
+  const cRight = normalize33(cross36(childAxis, childUp));
+  const pRight = normalize33(cross36(parentAxis, parentUp));
   const r00 = pRight[0] * cRight[0] + parentUp[0] * childUp[0] + parentAxis[0] * childAxis[0];
   const r01 = pRight[0] * cRight[1] + parentUp[0] * childUp[1] + parentAxis[0] * childAxis[1];
   const r02 = pRight[0] * cRight[2] + parentUp[0] * childUp[2] + parentAxis[0] * childAxis[2];
@@ -34501,11 +34576,11 @@ function getLastRustProfile() {
 }
 
 // src/forge/constraints3d/rodrigues.ts
-var EPS6 = 1e-10;
+var EPS7 = 1e-10;
 function rodrigues(rv) {
   const [rx, ry, rz] = rv;
   const theta = Math.sqrt(rx * rx + ry * ry + rz * rz);
-  if (theta < EPS6) {
+  if (theta < EPS7) {
     return [1, -rz, ry, rz, 1, -rx, -ry, rx, 1];
   }
   const c = Math.cos(theta);
@@ -34540,7 +34615,7 @@ function transformDir(rv, dir) {
 function dot36(a, b) {
   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }
-function cross36(a, b) {
+function cross37(a, b) {
   return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
 }
 function sub34(a, b) {
@@ -34551,7 +34626,7 @@ function len33(v) {
 }
 function normalize34(v) {
   const l = len33(v);
-  if (l < EPS6) return [0, 0, 0];
+  if (l < EPS7) return [0, 0, 0];
   return [v[0] / l, v[1] / l, v[2] / l];
 }
 
@@ -34595,7 +34670,7 @@ var axisParallelDef = {
   residual(constraint, ctx) {
     const axisA = ctx.worldAxis(constraint.refA.bodyId, constraint.refA.featureName);
     const axisB = ctx.worldAxis(constraint.refB.bodyId, constraint.refB.featureName);
-    const c = cross36(axisA.direction, axisB.direction);
+    const c = cross37(axisA.direction, axisB.direction);
     const ax = Math.abs(c[0]);
     const ay = Math.abs(c[1]);
     const az = Math.abs(c[2]);
@@ -34612,9 +34687,9 @@ var concentricDef = {
   residual(constraint, ctx) {
     const axisA = ctx.worldAxis(constraint.refA.bodyId, constraint.refA.featureName);
     const axisB = ctx.worldAxis(constraint.refB.bodyId, constraint.refB.featureName);
-    const dirCross = cross36(axisA.direction, axisB.direction);
+    const dirCross = cross37(axisA.direction, axisB.direction);
     const delta = sub34(axisB.origin, axisA.origin);
-    const offsetCross = cross36(delta, axisA.direction);
+    const offsetCross = cross37(delta, axisA.direction);
     const pickTwo = (v) => {
       const ax = Math.abs(v[0]);
       const ay = Math.abs(v[1]);
@@ -34641,7 +34716,7 @@ var faceDistanceDef = {
     const n2 = faceB.normal;
     const delta = sub34(faceB.center, faceA.center);
     const antiParallel = dot36(n1, n2) + 1;
-    const crossMag = len33(cross36(n1, n2));
+    const crossMag = len33(cross37(n1, n2));
     const signedDist = dot36(delta, n1) - distance5;
     return [antiParallel, crossMag, signedDist];
   }
@@ -34683,7 +34758,7 @@ var parallelDef = {
   residual(constraint, ctx) {
     const faceA = ctx.worldFace(constraint.refA.bodyId, constraint.refA.featureName);
     const faceB = ctx.worldFace(constraint.refB.bodyId, constraint.refB.featureName);
-    const c = cross36(faceA.normal, faceB.normal);
+    const c = cross37(faceA.normal, faceB.normal);
     const ax = Math.abs(c[0]);
     const ay = Math.abs(c[1]);
     const az = Math.abs(c[2]);
@@ -34712,7 +34787,7 @@ var pointOnAxisDef = {
     const point2 = ctx.worldPoint(constraint.refA.bodyId, constraint.refA.featureName);
     const axis = ctx.worldAxis(constraint.refB.bodyId, constraint.refB.featureName);
     const delta = sub34(point2, axis.origin);
-    const c = cross36(delta, axis.direction);
+    const c = cross37(delta, axis.direction);
     const ax = Math.abs(c[0]);
     const ay = Math.abs(c[1]);
     const az = Math.abs(c[2]);
@@ -40631,10 +40706,8 @@ var PathBuilder = class {
     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];
-    const cornerX = 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 };
@@ -40707,7 +40780,6 @@ var PathBuilder = class {
   }
   getSegDirAt(seg, which) {
     if (seg.kind === "line" || seg.kind === "move") {
-      const n = this.segs.length;
       const idx = this.segs.indexOf(seg);
       if (seg.kind === "line") {
         let sx, sy;
@@ -40951,6 +41023,41 @@ var PathBuilder = class {
     }
     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`.
@@ -42332,7 +42439,7 @@ function elbow(pipeRadius, bendRadius, angle, options) {
 }
 
 // src/forge/lib/belts.ts
-var EPS7 = 1e-9;
+var EPS8 = 1e-9;
 function assertFinitePositive(apiName, name, value) {
   if (!Number.isFinite(value) || value <= 0) {
     throw new Error(`${apiName}: "${name}" must be a positive finite number.`);
@@ -42358,7 +42465,7 @@ function dist(a, b) {
 }
 function norm(v) {
   const l = len(v);
-  if (l < EPS7) throw new Error("beltDrive: coincident tangent points produced a zero-length direction.");
+  if (l < EPS8) throw new Error("beltDrive: coincident tangent points produced a zero-length direction.");
   return [v[0] / l, v[1] / l];
 }
 function angleOf(center, point2) {
@@ -42424,13 +42531,13 @@ function normalizePulleyAsCircle(pulley, index, radiusOverride) {
 function commonTangents(a, b, mode) {
   const delta = sub5(b.center, a.center);
   const z = dot6(delta, delta);
-  if (z < EPS7) {
+  if (z < EPS8) {
     throw new Error(`beltDrive: pulleys "${a.name}" and "${b.name}" have the same center.`);
   }
   const signedA = mode === "open" ? 1 : -1;
   const r = signedA * a.radius - b.radius;
   const h2 = z - r * r;
-  if (h2 <= EPS7) {
+  if (h2 <= EPS8) {
     const centerDistance = Math.sqrt(z);
     if (mode === "open") {
       throw new Error(
@@ -42506,7 +42613,7 @@ function buildTwoPulleySegments(circles, mode) {
   const [t0, t1] = commonTangents(a, b, mode);
   const candidateA = buildSegmentsForTangentOrder(a, b, t0, t1);
   const candidateB = buildSegmentsForTangentOrder(a, b, t1, t0);
-  if (mode !== "open" || Math.abs(a.radius - b.radius) < EPS7) return candidateA;
+  if (mode !== "open" || Math.abs(a.radius - b.radius) < EPS8) return candidateA;
   const larger = a.radius > b.radius ? a.name : b.name;
   const smaller = a.radius > b.radius ? b.name : a.name;
   const score = (segments) => {
@@ -58559,13 +58666,13 @@ function variableSweep(spine, sections, options = {}) {
 
 // src/forge/productSkin.ts
 var AXIS_INDEX = { X: 0, Y: 1, Z: 2 };
-var EPS8 = 1e-8;
+var EPS9 = 1e-8;
 function clamp6(value, min2, max4) {
   return Math.max(min2, Math.min(max4, value));
 }
 function norm2(v) {
   const length7 = Math.hypot(v[0], v[1], v[2]);
-  if (length7 < EPS8) return [0, 0, 1];
+  if (length7 < EPS9) return [0, 0, 1];
   return [v[0] / length7, v[1] / length7, v[2] / length7];
 }
 function cross7(a, b) {
@@ -58628,12 +58735,12 @@ function superEllipsePoint(rx, ry, exponent, angle) {
   const sin5 = Math.sin(angle);
   const x = rx * Math.sign(cos5) * Math.abs(cos5) ** (2 / exponent);
   const y = ry * Math.sign(sin5) * Math.abs(sin5) ** (2 / exponent);
-  const nx = Math.sign(x) * Math.abs(x / Math.max(rx, EPS8)) ** Math.max(exponent - 1, 1e-3);
-  const ny = Math.sign(y) * Math.abs(y / Math.max(ry, EPS8)) ** Math.max(exponent - 1, 1e-3);
+  const nx = Math.sign(x) * Math.abs(x / Math.max(rx, EPS9)) ** Math.max(exponent - 1, 1e-3);
+  const ny = Math.sign(y) * Math.abs(y / Math.max(ry, EPS9)) ** Math.max(exponent - 1, 1e-3);
   const nLen = Math.hypot(nx, ny);
   return {
     point: [x, y],
-    normal: nLen < EPS8 ? [Math.sign(cos5), Math.sign(sin5)] : [nx / nLen, ny / nLen]
+    normal: nLen < EPS9 ? [Math.sign(cos5), Math.sign(sin5)] : [nx / nLen, ny / nLen]
   };
 }
 function angleForSide(side, u) {
@@ -58645,9 +58752,9 @@ function angleForSide(side, u) {
   return null;
 }
 function sideSpan(side, width, depth) {
-  if (side === "left" || side === "right") return Math.max(depth, EPS8);
-  if (side === "top" || side === "bottom") return Math.max(width, EPS8);
-  return Math.max(width, depth, EPS8);
+  if (side === "left" || side === "right") return Math.max(depth, EPS9);
+  if (side === "top" || side === "bottom") return Math.max(width, EPS9);
+  return Math.max(width, depth, EPS9);
 }
 function interpolateQuery(a, b, t) {
   const sideA = normalizedSide(a.side);
@@ -58793,8 +58900,8 @@ var ProductSkin = class {
       const b = sorted[index + 1];
       const aAxis = axisPosition(this.axis, a.center);
       const bAxis = axisPosition(this.axis, b.center);
-      if (axisValue < aAxis - EPS8 || axisValue > bAxis + EPS8) continue;
-      const span = Math.max(EPS8, bAxis - aAxis);
+      if (axisValue < aAxis - EPS9 || axisValue > bAxis + EPS9) continue;
+      const span = Math.max(EPS9, bAxis - aAxis);
       const t = clamp6((axisValue - aAxis) / span, 0, 1);
       return {
         axisValue,
@@ -59432,7 +59539,7 @@ var ProductRibbonBuilder = class {
         const rawU = (center.u ?? 0.5) + across * this.widthValue / span;
         const u = clamp6(rawU, 0, 1);
         const clampDistance = Math.abs(rawU - u) * span;
-        if (clampDistance > EPS8) {
+        if (clampDistance > EPS9) {
           clampedUCount += 1;
           maxUClampDistance = Math.max(maxUClampDistance, clampDistance);
         }
@@ -59625,7 +59732,7 @@ var Product = {
 };
 
 // src/forge/surface-members/math.ts
-var EPS9 = 1e-8;
+var EPS10 = 1e-8;
 function requireFinite6(value, label) {
   if (!Number.isFinite(value)) throw new Error(`${label} must be a finite number`);
   return value;
@@ -59661,7 +59768,7 @@ function length5(v) {
 }
 function norm3(v, fallback = [0, 0, 1]) {
   const len2 = length5(v);
-  if (len2 < EPS9) return [...fallback];
+  if (len2 < EPS10) return [...fallback];
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function distance(a, b) {
@@ -60033,10 +60140,10 @@ function coordinateOnSide(coordinate, side, label) {
   return { ...coordinate, kind: "productSkin", side };
 }
 var ProductSkinCarrier = class _ProductSkinCarrier {
-  constructor(skin, name = skin.name, sideValue, offsetValue = 0) {
+  constructor(skin, name = skin.name, sideValue2, offsetValue = 0) {
     this.skin = skin;
     this.name = name;
-    this.sideValue = sideValue;
+    this.sideValue = sideValue2;
     this.offsetValue = offsetValue;
   }
   kind = "productSkin";
@@ -62876,7 +62983,7 @@ function mul3(a, s) {
 function dot38(a, b) {
   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }
-function cross37(a, b) {
+function cross38(a, b) {
   return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
 }
 function distance3(a, b) {
@@ -63105,7 +63212,7 @@ function collectShapeTriangles(shape) {
       mesh.vertProperties[i2 * numProp + 1],
       mesh.vertProperties[i2 * numProp + 2]
     ];
-    const n = norm4(cross37(sub35(b, a), sub35(c, a)));
+    const n = norm4(cross38(sub35(b, a), sub35(c, a)));
     tris.push({ a, b, c, normal: n });
   }
   return tris;
@@ -63175,7 +63282,7 @@ function summarizeMetricSeries(values) {
   return [signatureNumber(sum2), signatureNumber(sumSquares), signatureNumber(min2), signatureNumber(max4)].join(":");
 }
 function triangleArea(triangle) {
-  const c = cross37(sub35(triangle.b, triangle.a), sub35(triangle.c, triangle.a));
+  const c = cross38(sub35(triangle.b, triangle.a), sub35(triangle.c, triangle.a));
   return Math.hypot(c[0], c[1], c[2]) * 0.5;
 }
 function makeComponentPageSignature(object) {
@@ -63290,8 +63397,8 @@ function makeViewFrame(view) {
   };
   const c = cfg[view];
   const forward = norm4(mul3(c.camDir, -1));
-  const right = norm4(cross37(forward, c.up));
-  const up = norm4(cross37(right, forward));
+  const right = norm4(cross38(forward, c.up));
+  const up = norm4(cross38(right, forward));
   return { id: view, label: c.label, right, up, forward };
 }
 function isDimensionVisibleInView(dim2, frame, toleranceDeg) {
@@ -63335,9 +63442,9 @@ function pickDimensionOffsetBasis(dirModel, frame) {
     pushCandidate(axisPerp);
   });
   if (candidates.length === 0) {
-    pushCandidate(cross37(dirModel, frame.forward));
-    pushCandidate(cross37(dirModel, frame.up));
-    pushCandidate(cross37(dirModel, frame.right));
+    pushCandidate(cross38(dirModel, frame.forward));
+    pushCandidate(cross38(dirModel, frame.up));
+    pushCandidate(cross38(dirModel, frame.right));
   }
   if (candidates.length === 0) {
     return { dir3: [0, 0, 1], proj: [0, 1], projDir: [0, 1], projLen: 1 };
@@ -65750,7 +65857,7 @@ function offsetSolid(shape, thickness) {
 }
 
 // src/forge/projectionCompile.ts
-var EPS10 = 1e-6;
+var EPS11 = 1e-6;
 var FROM_SLICES_SINGLE_SLICE_HALF_EXTENT = 500;
 function dot9(a, b) {
   return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
@@ -65772,7 +65879,7 @@ function normalize8(vec) {
   if (len2 < 1e-12) return [0, 0, 1];
   return [vec[0] / len2, vec[1] / len2, vec[2] / len2];
 }
-function nearlyEqual(a, b, eps = EPS10) {
+function nearlyEqual(a, b, eps = EPS11) {
   return Math.abs(a - b) <= eps;
 }
 function projectionReplayFailure(sourceShape, plane, sourcePlacement, reason, targetFaceQuery) {
@@ -65898,7 +66005,7 @@ function mapProfileToPlane(profile, sourcePlacement, targetPlane) {
   const d = dot9(sourceV, targetPlane.v);
   const sx = length2d(a, c);
   const sy = length2d(b, d);
-  if (sx < EPS10 || sy < EPS10) {
+  if (sx < EPS11 || sy < EPS11) {
     return { reason: "projection replay requires a non-degenerate in-plane basis." };
   }
   const shear = a * b + c * d;
@@ -65951,8 +66058,8 @@ function circleProjectionProfile(radius, segments) {
 function annulusProjectionProfile(outerRadius, innerRadius, segments) {
   const outer = Math.abs(outerRadius);
   const inner = Math.max(0, Math.abs(innerRadius));
-  if (outer <= EPS10 || inner >= outer - EPS10) return null;
-  if (inner <= EPS10) {
+  if (outer <= EPS11 || inner >= outer - EPS11) return null;
+  if (inner <= EPS11) {
     return circleProjectionProfile(outer, segments);
   }
   return buildBooleanProfileCompilePlan("difference", [circleProjectionProfile(outer, segments), circleProjectionProfile(inner, segments)]);
@@ -66009,7 +66116,7 @@ function convexHull2d(points) {
   const unique = [];
   for (const point2 of points) {
     if (!Number.isFinite(point2[0]) || !Number.isFinite(point2[1])) return null;
-    if (!unique.some((existing) => pointDistance2d(existing, point2) <= EPS10)) {
+    if (!unique.some((existing) => pointDistance2d(existing, point2) <= EPS11)) {
       unique.push(point2);
     }
   }
@@ -66018,7 +66125,7 @@ function convexHull2d(points) {
   const cross13 = (origin, a, b) => (a[0] - origin[0]) * (b[1] - origin[1]) - (a[1] - origin[1]) * (b[0] - origin[0]);
   const lower2 = [];
   for (const point2 of unique) {
-    while (lower2.length >= 2 && cross13(lower2[lower2.length - 2], lower2[lower2.length - 1], point2) <= EPS10) {
+    while (lower2.length >= 2 && cross13(lower2[lower2.length - 2], lower2[lower2.length - 1], point2) <= EPS11) {
       lower2.pop();
     }
     lower2.push(point2);
@@ -66026,7 +66133,7 @@ function convexHull2d(points) {
   const upper = [];
   for (let idx = unique.length - 1; idx >= 0; idx -= 1) {
     const point2 = unique[idx];
-    while (upper.length >= 2 && cross13(upper[upper.length - 2], upper[upper.length - 1], point2) <= EPS10) {
+    while (upper.length >= 2 && cross13(upper[upper.length - 2], upper[upper.length - 1], point2) <= EPS11) {
       upper.pop();
     }
     upper.push(point2);
@@ -66060,7 +66167,7 @@ function transformedBoxProjectionReplayProfile(sourceShape, targetPlane) {
   const halfY = Math.abs(input.box.y) / 2;
   const zMin = Math.min(0, input.box.z);
   const zMax = Math.max(0, input.box.z);
-  if (halfX <= EPS10 || halfY <= EPS10 || zMax - zMin <= EPS10) return null;
+  if (halfX <= EPS11 || halfY <= EPS11 || zMax - zMin <= EPS11) return null;
   const projected = [-halfX, halfX].flatMap(
     (x) => [-halfY, halfY].flatMap(
       (y) => [zMin, zMax].map((z) => {
@@ -66097,10 +66204,10 @@ function transformedCylinderSideProjectionReplayProfile(sourceShape, targetPlane
   const axis = normalize8(input.transform.vector([0, 0, 1]));
   if (!nearlyEqual(dot9(axis, targetPlane.normal), 0, 1e-5)) return null;
   const radiusDirection = normalize8(cross9(targetPlane.normal, axis));
-  if (Math.hypot(radiusDirection[0], radiusDirection[1], radiusDirection[2]) <= EPS10) return null;
+  if (Math.hypot(radiusDirection[0], radiusDirection[1], radiusDirection[2]) <= EPS11) return null;
   const bottomRadius = Math.abs(input.cylinder.radius * input.distanceScale);
   const topRadius = Math.abs((input.cylinder.radiusTop ?? input.cylinder.radius) * input.distanceScale);
-  if (!Number.isFinite(input.cylinder.height) || input.cylinder.height <= EPS10 || Math.max(bottomRadius, topRadius) <= EPS10) return null;
+  if (!Number.isFinite(input.cylinder.height) || input.cylinder.height <= EPS11 || Math.max(bottomRadius, topRadius) <= EPS11) return null;
   const bottomCenter = input.transform.point([0, 0, 0]);
   const topCenter = input.transform.point([0, 0, input.cylinder.height]);
   const projected = [
@@ -66144,7 +66251,7 @@ function transformedTorusSideProjectionReplayProfile(sourceShape, targetPlane) {
   if (!nearlyEqual(dot9(axis, targetPlane.normal), 0, 1e-5)) return null;
   const majorRadius = Math.abs(input.torus.majorRadius * input.distanceScale);
   const minorRadius = Math.abs(input.torus.minorRadius * input.distanceScale);
-  if (majorRadius <= EPS10 || minorRadius <= EPS10 || minorRadius >= majorRadius - EPS10) return null;
+  if (majorRadius <= EPS11 || minorRadius <= EPS11 || minorRadius >= majorRadius - EPS11) return null;
   const radiusDirection = normalize8(cross9(targetPlane.normal, axis));
   const radiusDirectionU = dot9(radiusDirection, targetPlane.u);
   const radiusDirectionV = dot9(radiusDirection, targetPlane.v);
@@ -66235,7 +66342,7 @@ function transformedOffsetExtrudeSideProjectionReplayProfile(sourceShape, target
   const topOrigin = input.transform.point([0, 0, input.extrude.height]);
   const span = sub8(topOrigin, bottomOrigin);
   const height = Math.hypot(span[0], span[1], span[2]);
-  if (!Number.isFinite(height) || height <= EPS10 || height + 2 * input.thickness <= EPS10) return null;
+  if (!Number.isFinite(height) || height <= EPS11 || height + 2 * input.thickness <= EPS11) return null;
   const axis = [span[0] / height, span[1] / height, span[2] / height];
   if (!nearlyEqual(dot9(axis, targetPlane.normal), 0, 1e-5)) return null;
   const radiusDirection = normalize8(cross9(targetPlane.normal, axis));
@@ -66259,11 +66366,11 @@ function transformedOffsetExtrudeSideProjectionReplayProfile(sourceShape, target
   return hull ? { profile: { kind: "polygon", points: hull, transforms: [] }, placement: targetPlanePlacement(targetPlane) } : null;
 }
 function normalizeIntervals2(intervals) {
-  const sorted = intervals.map(([a, b]) => [Math.min(a, b), Math.max(a, b)]).filter(([a, b]) => Number.isFinite(a) && Number.isFinite(b) && b > a + EPS10).sort((a, b) => a[0] - b[0]);
+  const sorted = intervals.map(([a, b]) => [Math.min(a, b), Math.max(a, b)]).filter(([a, b]) => Number.isFinite(a) && Number.isFinite(b) && b > a + EPS11).sort((a, b) => a[0] - b[0]);
   const out = [];
   for (const [a, b] of sorted) {
     const last = out[out.length - 1];
-    if (!last || a > last[1] + EPS10) {
+    if (!last || a > last[1] + EPS11) {
       out.push([a, b]);
     } else {
       last[1] = Math.max(last[1], b);
@@ -66282,7 +66389,7 @@ function intervalGroupsAreStrictlySeparated2(groups) {
   for (let idx = 1; idx < spans.length; idx += 1) {
     const previous = spans[idx - 1];
     const current = spans[idx];
-    if (previous.groupIdx !== current.groupIdx && current.min <= previous.max + EPS10) return false;
+    if (previous.groupIdx !== current.groupIdx && current.min <= previous.max + EPS11) return false;
   }
   return true;
 }
@@ -66299,7 +66406,7 @@ function partialRevolveSegmentCount2(segments) {
 function radialSectorProjectionProfile(innerRadius, outerRadius, degrees2, segments) {
   const inner = Math.max(0, Math.abs(innerRadius));
   const outer = Math.max(0, Math.abs(outerRadius));
-  if (outer <= EPS10 || outer - inner <= EPS10) return null;
+  if (outer <= EPS11 || outer - inner <= EPS11) return null;
   const sweep2 = degrees2 * Math.PI / 180;
   const segmentCount = partialRevolveSegmentCount2(segments);
   const outerArc = [];
@@ -66307,7 +66414,7 @@ function radialSectorProjectionProfile(innerRadius, outerRadius, degrees2, segme
     const theta = sweep2 * i / segmentCount;
     outerArc.push([outer * Math.cos(theta), outer * Math.sin(theta)]);
   }
-  const points = inner <= EPS10 ? [[0, 0], ...outerArc] : [
+  const points = inner <= EPS11 ? [[0, 0], ...outerArc] : [
     ...outerArc,
     ...Array.from({ length: segmentCount + 1 }, (_, idx) => {
       const theta = sweep2 * (segmentCount - idx) / segmentCount;
@@ -66337,7 +66444,7 @@ function transformProfilePoint2(point2, transform) {
     }
     case "mirror": {
       const len2 = Math.hypot(transform.normalX, transform.normalY);
-      if (len2 <= EPS10) return point2;
+      if (len2 <= EPS11) return point2;
       const nx = transform.normalX / len2;
       const ny = transform.normalY / len2;
       const d = point2[0] * nx + point2[1] * ny;
@@ -66375,22 +66482,22 @@ function profileTransformBasis(transforms) {
 }
 function circleRadialProjectionInterval2(plan) {
   const radius = Math.abs(plan.radius);
-  if (!Number.isFinite(radius) || radius <= EPS10) return null;
+  if (!Number.isFinite(radius) || radius <= EPS11) return null;
   const basis = profileTransformBasis(plan.transforms);
   if (!basis) return null;
   const xDeviation = radius * Math.hypot(basis.xAxis[0], basis.yAxis[0]);
-  if (!Number.isFinite(xDeviation) || xDeviation <= EPS10) return null;
+  if (!Number.isFinite(xDeviation) || xDeviation <= EPS11) return null;
   return [basis.center[0] - xDeviation, basis.center[0] + xDeviation];
 }
 function circleProfileFootprint(plan) {
   const radius = Math.abs(plan.radius);
-  if (!Number.isFinite(radius) || radius <= EPS10) return null;
+  if (!Number.isFinite(radius) || radius <= EPS11) return null;
   const basis = profileTransformBasis(plan.transforms);
   if (!basis) return null;
   const xScale = Math.hypot(basis.xAxis[0], basis.xAxis[1]);
   const yScale = Math.hypot(basis.yAxis[0], basis.yAxis[1]);
   const dotAxes = basis.xAxis[0] * basis.yAxis[0] + basis.xAxis[1] * basis.yAxis[1];
-  if (xScale <= EPS10 || yScale <= EPS10 || !nearlyEqual(xScale, yScale, 1e-8) || Math.abs(dotAxes) > 1e-8 * xScale * yScale) {
+  if (xScale <= EPS11 || yScale <= EPS11 || !nearlyEqual(xScale, yScale, 1e-8) || Math.abs(dotAxes) > 1e-8 * xScale * yScale) {
     return null;
   }
   return { center: basis.center, radius: radius * xScale };
@@ -66398,7 +66505,7 @@ function circleProfileFootprint(plan) {
 function rectProfileFootprint(plan) {
   const width = Math.abs(plan.width);
   const height = Math.abs(plan.height);
-  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= EPS10 || height <= EPS10) return null;
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= EPS11 || height <= EPS11) return null;
   const basis = profileTransformBasis(plan.transforms);
   if (!basis || !transformBasisIsAxisAligned(basis)) return null;
   return {
@@ -66416,23 +66523,23 @@ function rectFootprintLoop(rect2) {
   ];
 }
 function transformBasisIsAxisAligned(basis) {
-  const xAxisAligned = Math.abs(basis.xAxis[0]) <= EPS10 || Math.abs(basis.xAxis[1]) <= EPS10;
-  const yAxisAligned = Math.abs(basis.yAxis[0]) <= EPS10 || Math.abs(basis.yAxis[1]) <= EPS10;
+  const xAxisAligned = Math.abs(basis.xAxis[0]) <= EPS11 || Math.abs(basis.xAxis[1]) <= EPS11;
+  const yAxisAligned = Math.abs(basis.yAxis[0]) <= EPS11 || Math.abs(basis.yAxis[1]) <= EPS11;
   const dotAxes = basis.xAxis[0] * basis.yAxis[0] + basis.xAxis[1] * basis.yAxis[1];
   const scaleProduct = Math.hypot(basis.xAxis[0], basis.xAxis[1]) * Math.hypot(basis.yAxis[0], basis.yAxis[1]);
-  return xAxisAligned && yAxisAligned && scaleProduct > EPS10 && Math.abs(dotAxes) <= EPS10 * Math.max(1, scaleProduct);
+  return xAxisAligned && yAxisAligned && scaleProduct > EPS11 && Math.abs(dotAxes) <= EPS11 * Math.max(1, scaleProduct);
 }
 function roundedRectProfileFootprint(plan) {
   const width = Math.abs(plan.width);
   const height = Math.abs(plan.height);
-  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= EPS10 || height <= EPS10) return null;
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= EPS11 || height <= EPS11) return null;
   const radius = Math.max(0, Math.min(Math.abs(plan.radius), width / 2, height / 2));
   const basis = profileTransformBasis(plan.transforms);
   if (!basis) return null;
   const xScale = Math.hypot(basis.xAxis[0], basis.xAxis[1]);
   const yScale = Math.hypot(basis.yAxis[0], basis.yAxis[1]);
   const dotAxes = basis.xAxis[0] * basis.yAxis[0] + basis.xAxis[1] * basis.yAxis[1];
-  if (xScale <= EPS10 || yScale <= EPS10 || !nearlyEqual(xScale, yScale, 1e-8) || Math.abs(dotAxes) > 1e-8 * xScale * yScale) {
+  if (xScale <= EPS11 || yScale <= EPS11 || !nearlyEqual(xScale, yScale, 1e-8) || Math.abs(dotAxes) > 1e-8 * xScale * yScale) {
     return null;
   }
   return {
@@ -66447,14 +66554,14 @@ function roundedRectProfileFootprint(plan) {
 function roundedRectRadialProjectionInterval2(plan) {
   const width = Math.abs(plan.width);
   const height = Math.abs(plan.height);
-  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= EPS10 || height <= EPS10) return null;
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= EPS11 || height <= EPS11) return null;
   const radius = Math.max(0, Math.min(Math.abs(plan.radius), width / 2, height / 2));
   const basis = profileTransformBasis(plan.transforms);
-  if (!basis || Math.hypot(basis.xAxis[0], basis.xAxis[1]) <= EPS10 || Math.hypot(basis.yAxis[0], basis.yAxis[1]) <= EPS10) return null;
+  if (!basis || Math.hypot(basis.xAxis[0], basis.xAxis[1]) <= EPS11 || Math.hypot(basis.yAxis[0], basis.yAxis[1]) <= EPS11) return null;
   const coreHalfWidth = Math.max(0, width / 2 - radius);
   const coreHalfHeight = Math.max(0, height / 2 - radius);
   const xDeviation = Math.abs(basis.xAxis[0]) * coreHalfWidth + Math.abs(basis.yAxis[0]) * coreHalfHeight + radius * Math.hypot(basis.xAxis[0], basis.yAxis[0]);
-  if (!Number.isFinite(xDeviation) || xDeviation <= EPS10) return null;
+  if (!Number.isFinite(xDeviation) || xDeviation <= EPS11) return null;
   return [basis.center[0] - xDeviation, basis.center[0] + xDeviation];
 }
 function profileOuterProjectionLoops(plan) {
@@ -66463,7 +66570,7 @@ function profileOuterProjectionLoops(plan) {
     case "rect": {
       const halfWidth = Math.abs(plan.width) / 2;
       const halfHeight = Math.abs(plan.height) / 2;
-      if (halfWidth <= EPS10 || halfHeight <= EPS10) return null;
+      if (halfWidth <= EPS11 || halfHeight <= EPS11) return null;
       loops = [
         [
           [-halfWidth, -halfHeight],
@@ -66519,7 +66626,7 @@ function profileStrictlyContainsCircle(profile, circle2) {
       const container = circleProfileFootprint(profile);
       if (!container) return false;
       const distance5 = Math.hypot(circle2.center[0] - container.center[0], circle2.center[1] - container.center[1]);
-      return distance5 + circle2.radius < container.radius - EPS10;
+      return distance5 + circle2.radius < container.radius - EPS11;
     }
     case "rect":
     case "polygon":
@@ -66627,7 +66734,7 @@ function pointsProjectionIntervalAlongDirection(points, direction2) {
     min2 = Math.min(min2, projected);
     max4 = Math.max(max4, projected);
   }
-  return min2 <= max4 - EPS10 ? [min2, max4] : null;
+  return min2 <= max4 - EPS11 ? [min2, max4] : null;
 }
 function signedArea2d2(points) {
   let area2 = 0;
@@ -66641,7 +66748,7 @@ function signedArea2d2(points) {
 function strictlyConvexPolygonOrientation(points) {
   if (points.length < 3) return null;
   const area2 = signedArea2d2(points);
-  if (Math.abs(area2) <= EPS10) return null;
+  if (Math.abs(area2) <= EPS11) return null;
   const orientation3 = area2 > 0 ? 1 : -1;
   for (let idx = 0; idx < points.length; idx += 1) {
     const prev = points[(idx + points.length - 1) % points.length];
@@ -66652,7 +66759,7 @@ function strictlyConvexPolygonOrientation(points) {
     const bx = next[0] - current[0];
     const by = next[1] - current[1];
     const cross13 = ax * by - ay * bx;
-    if (cross13 * orientation3 <= EPS10) return null;
+    if (cross13 * orientation3 <= EPS11) return null;
   }
   return orientation3;
 }
@@ -66660,20 +66767,20 @@ function outwardEdgeNormal2d(a, b, orientation3) {
   const dx = b[0] - a[0];
   const dy = b[1] - a[1];
   const length7 = Math.hypot(dx, dy);
-  if (length7 <= EPS10) return null;
+  if (length7 <= EPS11) return null;
   return orientation3 > 0 ? [dy / length7, -dx / length7] : [-dy / length7, dx / length7];
 }
 function lineIntersectionByNormals2d(normalA, offsetA, normalB, offsetB) {
   const det = normalA[0] * normalB[1] - normalA[1] * normalB[0];
-  if (Math.abs(det) <= EPS10) return null;
+  if (Math.abs(det) <= EPS11) return null;
   return [(offsetA * normalB[1] - normalA[1] * offsetB) / det, (normalA[0] * offsetB - offsetA * normalB[0]) / det];
 }
 function profileProjectionIntervalAlongDirection(plan, direction2) {
-  if (Math.hypot(direction2[0], direction2[1]) <= EPS10) return null;
+  if (Math.hypot(direction2[0], direction2[1]) <= EPS11) return null;
   switch (plan.kind) {
     case "circle": {
       const radius = Math.abs(plan.radius);
-      if (!Number.isFinite(radius) || radius <= EPS10) return null;
+      if (!Number.isFinite(radius) || radius <= EPS11) return null;
       const basis = profileTransformBasis(plan.transforms);
       if (!basis) return null;
       const center = basis.center[0] * direction2[0] + basis.center[1] * direction2[1];
@@ -66681,19 +66788,19 @@ function profileProjectionIntervalAlongDirection(plan, direction2) {
         basis.xAxis[0] * direction2[0] + basis.xAxis[1] * direction2[1],
         basis.yAxis[0] * direction2[0] + basis.yAxis[1] * direction2[1]
       );
-      return deviation > EPS10 ? [center - deviation, center + deviation] : null;
+      return deviation > EPS11 ? [center - deviation, center + deviation] : null;
     }
     case "roundedRect": {
       const footprint = roundedRectProfileFootprint(plan);
       if (!footprint) return null;
       const center = footprint.center[0] * direction2[0] + footprint.center[1] * direction2[1];
       const deviation = roundedRectHalfExtentAlong2d(footprint, direction2);
-      return deviation > EPS10 ? [center - deviation, center + deviation] : null;
+      return deviation > EPS11 ? [center - deviation, center + deviation] : null;
     }
     case "rect": {
       const halfWidth = Math.abs(plan.width) / 2;
       const halfHeight = Math.abs(plan.height) / 2;
-      if (halfWidth <= EPS10 || halfHeight <= EPS10) return null;
+      if (halfWidth <= EPS11 || halfHeight <= EPS11) return null;
       const points = transformProfileLoops(
         [
           [
@@ -66740,7 +66847,7 @@ function isCardinalProjectionDirection(direction2) {
   const ax = Math.abs(direction2[0]);
   const ay = Math.abs(direction2[1]);
   const max4 = Math.max(ax, ay);
-  return max4 > EPS10 && (ax <= 1e-6 * max4 || ay <= 1e-6 * max4);
+  return max4 > EPS11 && (ax <= 1e-6 * max4 || ay <= 1e-6 * max4);
 }
 function profileSupportsDefendedMiterOffsetSideInterval(plan, delta) {
   switch (plan.kind) {
@@ -66751,12 +66858,12 @@ function profileSupportsDefendedMiterOffsetSideInterval(plan, delta) {
     case "roundedRect":
       return roundedRectProfileFootprint(plan) != null;
     case "polygon":
-      return delta >= -EPS10;
+      return delta >= -EPS11;
     case "boolean": {
       const profiles2 = booleanProfilesWithParentTransforms2(plan);
       if (!profiles2 || profiles2.length === 0) return false;
       if (plan.op === "union") {
-        return delta >= -EPS10 && profiles2.every((profile) => profileSupportsDefendedMiterOffsetSideInterval(profile, delta));
+        return delta >= -EPS11 && profiles2.every((profile) => profileSupportsDefendedMiterOffsetSideInterval(profile, delta));
       }
       if (plan.op === "intersection") {
         const contained = containedIntersectionProfile2(profiles2);
@@ -66764,7 +66871,7 @@ function profileSupportsDefendedMiterOffsetSideInterval(plan, delta) {
       }
       const [subject, ...clips] = profiles2;
       if (!subject || clips.some((clip) => !profileStrictlyContainsProfile(subject, clip))) return false;
-      if (delta < -EPS10) {
+      if (delta < -EPS11) {
         const insetSubject = insetProfileForContainment(subject, Math.abs(delta));
         if (!insetSubject) return false;
         return clips.every((clip) => {
@@ -66796,13 +66903,13 @@ function profileSupportsExactCircularOffsetSideInterval(plan, delta) {
       if (plan.op !== "difference") return false;
       const [subject, ...clips] = profiles2;
       if (!subject) return false;
-      if (delta >= -EPS10) {
+      if (delta >= -EPS11) {
         return profileSupportsExactCircularOffsetSideInterval(subject, delta) && clips.every((clip) => profileStrictlyContainsProfile(subject, clip));
       }
       const subjectSegments = subject.kind === "circle" ? subject.segments : void 0;
       const subjectCircle = subject.kind === "circle" ? circleProfileFootprint(subject) : null;
       const inset = Math.abs(delta);
-      if (!subjectCircle || subjectCircle.radius <= inset + EPS10) return false;
+      if (!subjectCircle || subjectCircle.radius <= inset + EPS11) return false;
       const subjectInset = translatedProfileIfNeeded(
         circleProjectionProfile(subjectCircle.radius - inset, subjectSegments),
         subjectCircle.center
@@ -66839,9 +66946,9 @@ function offsetProfileProjectionIntervalAlongDirection(plan, direction2, delta)
 }
 function miterOffsetConvexPolygonProfileProjectionIntervalAlongDirection(plan, direction2, delta) {
   const directionLength = Math.hypot(direction2[0], direction2[1]);
-  if (directionLength <= EPS10) return null;
+  if (directionLength <= EPS11) return null;
   const localDelta = delta / directionLength;
-  if (Math.abs(localDelta) <= EPS10) return null;
+  if (Math.abs(localDelta) <= EPS11) return null;
   if (plan.kind === "boolean") {
     const profiles2 = booleanProfilesWithParentTransforms2(plan);
     if (!profiles2 || profiles2.length === 0) return null;
@@ -66852,7 +66959,7 @@ function miterOffsetConvexPolygonProfileProjectionIntervalAlongDirection(plan, d
     if (plan.op === "difference") {
       const [subject, ...clips] = profiles2;
       if (!subject || clips.some((clip) => !profileStrictlyContainsProfile(subject, clip))) return null;
-      if (delta < -EPS10) {
+      if (delta < -EPS11) {
         const subjectInset = miterOffsetConvexPolygonProfileForLocalDelta(subject, localDelta);
         if (!subjectInset) return null;
         const clearance = Math.abs(localDelta);
@@ -66864,7 +66971,7 @@ function miterOffsetConvexPolygonProfileProjectionIntervalAlongDirection(plan, d
       }
       return miterOffsetConvexPolygonProfileProjectionIntervalAlongDirection(subject, direction2, delta);
     }
-    if (plan.op !== "union" || delta < -EPS10) return null;
+    if (plan.op !== "union" || delta < -EPS11) return null;
     const intervals = profiles2.map((profile) => miterOffsetConvexPolygonProfileProjectionIntervalAlongDirection(profile, direction2, delta));
     if (intervals.some((interval) => !interval)) return null;
     const merged = normalizeIntervals2(intervals);
@@ -66874,7 +66981,7 @@ function miterOffsetConvexPolygonProfileProjectionIntervalAlongDirection(plan, d
   return offsetProfile2 ? profileProjectionIntervalAlongDirection(offsetProfile2, direction2) : null;
 }
 function miterOffsetConvexPolygonProfileForLocalDelta(plan, localDelta) {
-  if (Math.abs(localDelta) <= EPS10) return null;
+  if (Math.abs(localDelta) <= EPS11) return null;
   if (plan.kind === "boolean" && plan.op === "intersection") {
     const profiles2 = booleanProfilesWithParentTransforms2(plan);
     if (!profiles2 || profiles2.length === 0) return null;
@@ -66899,7 +67006,7 @@ function miterOffsetConvexPolygonProfileForLocalDelta(plan, localDelta) {
     const offsetPoint = lineIntersectionByNormals2d(prevNormal, prevOffset, nextNormal, nextOffset);
     if (!offsetPoint) return null;
     const miterLength = Math.hypot(offsetPoint[0] - current[0], offsetPoint[1] - current[1]);
-    if (miterLength > 2 * Math.abs(localDelta) + EPS10) return null;
+    if (miterLength > 2 * Math.abs(localDelta) + EPS11) return null;
     offsetPoints.push(offsetPoint);
   }
   if (strictlyConvexPolygonOrientation(offsetPoints) !== orientation3) return null;
@@ -66912,8 +67019,8 @@ function translatedProfileIfNeeded(profile, center) {
   return profile;
 }
 function insetProfileForContainment(plan, distance5) {
-  if (!Number.isFinite(distance5) || distance5 < -EPS10) return null;
-  if (distance5 <= EPS10) return cloneProfileCompilePlan(plan);
+  if (!Number.isFinite(distance5) || distance5 < -EPS11) return null;
+  if (distance5 <= EPS11) return cloneProfileCompilePlan(plan);
   if (plan.kind === "boolean" && plan.op === "intersection") {
     const profiles2 = booleanProfilesWithParentTransforms2(plan);
     if (!profiles2 || profiles2.length === 0) return null;
@@ -66922,11 +67029,11 @@ function insetProfileForContainment(plan, distance5) {
   }
   if (plan.kind === "circle") {
     const circle2 = circleProfileFootprint(plan);
-    return circle2 && circle2.radius > distance5 + EPS10 ? translatedProfileIfNeeded(circleProjectionProfile(circle2.radius - distance5, plan.segments), circle2.center) : null;
+    return circle2 && circle2.radius > distance5 + EPS11 ? translatedProfileIfNeeded(circleProjectionProfile(circle2.radius - distance5, plan.segments), circle2.center) : null;
   }
   if (plan.kind === "rect") {
     const rect2 = rectProfileFootprint(plan);
-    return rect2 && rect2.halfWidth > distance5 + EPS10 && rect2.halfHeight > distance5 + EPS10 ? translatedProfileIfNeeded(
+    return rect2 && rect2.halfWidth > distance5 + EPS11 && rect2.halfHeight > distance5 + EPS11 ? translatedProfileIfNeeded(
       {
         kind: "rect",
         width: 2 * (rect2.halfWidth - distance5),
@@ -66938,7 +67045,7 @@ function insetProfileForContainment(plan, distance5) {
   }
   if (plan.kind === "roundedRect") {
     const roundedRect2 = roundedRectProfileFootprint(plan);
-    if (!roundedRect2 || roundedRect2.halfWidth <= distance5 + EPS10 || roundedRect2.halfHeight <= distance5 + EPS10 || roundedRect2.radius <= distance5 + EPS10) {
+    if (!roundedRect2 || roundedRect2.halfWidth <= distance5 + EPS11 || roundedRect2.halfHeight <= distance5 + EPS11 || roundedRect2.radius <= distance5 + EPS11) {
       return null;
     }
     const profile = {
@@ -66958,8 +67065,8 @@ function insetProfileForContainment(plan, distance5) {
   return null;
 }
 function expandedProfileForContainment(plan, distance5) {
-  if (!Number.isFinite(distance5) || distance5 < -EPS10) return null;
-  if (distance5 <= EPS10) return cloneProfileCompilePlan(plan);
+  if (!Number.isFinite(distance5) || distance5 < -EPS11) return null;
+  if (distance5 <= EPS11) return cloneProfileCompilePlan(plan);
   if (plan.kind === "boolean" && plan.op === "union") {
     const profiles2 = booleanProfilesWithParentTransforms2(plan);
     if (!profiles2 || profiles2.length === 0) return null;
@@ -67019,7 +67126,7 @@ function booleanOffsetProfileProjectionIntervalAlongDirection(plan, direction2,
   const profiles2 = booleanProfilesWithParentTransforms2(plan);
   if (!profiles2 || profiles2.length === 0) return null;
   if (plan.op === "union") {
-    if (delta < -EPS10) return null;
+    if (delta < -EPS11) return null;
     const intervals = profiles2.map((profile) => childInterval(profile, direction2, delta));
     if (intervals.some((interval) => !interval)) return null;
     const merged = normalizeIntervals2(intervals);
@@ -67031,9 +67138,9 @@ function booleanOffsetProfileProjectionIntervalAlongDirection(plan, direction2,
   }
   const [subject, ...clips] = profiles2;
   if (!subject || clips.some((clip) => !profileStrictlyContainsProfile(subject, clip))) return null;
-  if (delta < -EPS10) {
+  if (delta < -EPS11) {
     const directionLength = Math.hypot(direction2[0], direction2[1]);
-    if (directionLength <= EPS10) return null;
+    if (directionLength <= EPS11) return null;
     const clearance = Math.abs(delta) / directionLength;
     const subjectInset = insetProfileForContainment(subject, clearance);
     if (!subjectInset) return null;
@@ -67057,12 +67164,12 @@ function roundedRectOffsetProfileProjectionIntervalAlongDirection(plan, directio
   const footprint = roundedRectProfileFootprint(plan);
   if (!footprint) return null;
   const directionLength = Math.hypot(direction2[0], direction2[1]);
-  if (directionLength <= EPS10) return null;
+  if (directionLength <= EPS11) return null;
   const localDelta = delta / directionLength;
   const halfWidth = footprint.halfWidth + localDelta;
   const halfHeight = footprint.halfHeight + localDelta;
   const radius = footprint.radius + localDelta;
-  if (halfWidth <= EPS10 || halfHeight <= EPS10 || radius <= EPS10 || radius > Math.min(halfWidth, halfHeight) + EPS10) return null;
+  if (halfWidth <= EPS11 || halfHeight <= EPS11 || radius <= EPS11 || radius > Math.min(halfWidth, halfHeight) + EPS11) return null;
   const adjusted = {
     ...footprint,
     halfWidth,
@@ -67071,7 +67178,7 @@ function roundedRectOffsetProfileProjectionIntervalAlongDirection(plan, directio
   };
   const center = footprint.center[0] * direction2[0] + footprint.center[1] * direction2[1];
   const deviation = roundedRectHalfExtentAlong2d(adjusted, direction2);
-  return deviation > EPS10 ? [center - deviation, center + deviation] : null;
+  return deviation > EPS11 ? [center - deviation, center + deviation] : null;
 }
 function miterOffsetRectProfileProjectionIntervalAlongDirection(plan, direction2, delta) {
   const booleanInterval = booleanOffsetProfileProjectionIntervalAlongDirection(
@@ -67085,17 +67192,17 @@ function miterOffsetRectProfileProjectionIntervalAlongDirection(plan, direction2
   const rect2 = rectProfileFootprint(plan);
   if (!rect2) return null;
   const directionLength = Math.hypot(direction2[0], direction2[1]);
-  if (directionLength <= EPS10) return null;
+  if (directionLength <= EPS11) return null;
   const localDelta = delta / directionLength;
   const halfWidth = rect2.halfWidth + localDelta;
   const halfHeight = rect2.halfHeight + localDelta;
-  if (halfWidth <= EPS10 || halfHeight <= EPS10) return null;
+  if (halfWidth <= EPS11 || halfHeight <= EPS11) return null;
   const center = rect2.center[0] * direction2[0] + rect2.center[1] * direction2[1];
   const deviation = halfWidth * Math.abs(direction2[0]) + halfHeight * Math.abs(direction2[1]);
-  return deviation > EPS10 ? [center - deviation, center + deviation] : null;
+  return deviation > EPS11 ? [center - deviation, center + deviation] : null;
 }
 function circularOffsetProfileProjectionIntervalAlongDirection(plan, direction2, delta) {
-  if (plan.kind === "boolean" && plan.op === "union" && delta >= -EPS10) {
+  if (plan.kind === "boolean" && plan.op === "union" && delta >= -EPS11) {
     const profiles2 = booleanProfilesWithParentTransforms2(plan);
     if (!profiles2 || profiles2.length === 0) return null;
     const intervals = profiles2.map((profile) => circularOffsetProfileProjectionIntervalAlongDirection(profile, direction2, delta));
@@ -67108,11 +67215,11 @@ function circularOffsetProfileProjectionIntervalAlongDirection(plan, direction2,
   if (!profileSupportsExactCircularOffsetSideInterval(plan, delta)) return null;
   const min2 = interval[0] - delta;
   const max4 = interval[1] + delta;
-  return max4 > min2 + EPS10 ? [min2, max4] : null;
+  return max4 > min2 + EPS11 ? [min2, max4] : null;
 }
 function miterOffsetProfileProjectionIntervalAlongCardinalDirection(plan, direction2, delta) {
   if (!profileSupportsDefendedMiterOffsetSideInterval(plan, delta)) return null;
-  if (plan.kind === "boolean" && plan.op === "union" && delta >= -EPS10) {
+  if (plan.kind === "boolean" && plan.op === "union" && delta >= -EPS11) {
     const profiles2 = booleanProfilesWithParentTransforms2(plan);
     if (!profiles2 || profiles2.length === 0) return null;
     const intervals = profiles2.map((profile) => miterOffsetProfileProjectionIntervalAlongCardinalDirection(profile, direction2, delta));
@@ -67124,7 +67231,7 @@ function miterOffsetProfileProjectionIntervalAlongCardinalDirection(plan, direct
   if (!interval) return null;
   const min2 = interval[0] - delta;
   const max4 = interval[1] + delta;
-  return max4 > min2 + EPS10 ? [min2, max4] : null;
+  return max4 > min2 + EPS11 ? [min2, max4] : null;
 }
 function containedIntersectionProfile2(profiles2) {
   for (const candidate of profiles2) {
@@ -67140,7 +67247,7 @@ function radialProjectionIntervalsForLoops(loops) {
     let min2 = Infinity;
     let max4 = -Infinity;
     for (const [x] of loop) {
-      if (x < -EPS10) return null;
+      if (x < -EPS11) return null;
       min2 = Math.min(min2, Math.max(0, x));
       max4 = Math.max(max4, Math.max(0, x));
     }
@@ -67162,12 +67269,12 @@ function radialProjectionIntervalsForRevolveProfile2(plan) {
   switch (plan.kind) {
     case "circle": {
       const interval = circleRadialProjectionInterval2(plan);
-      if (!interval || interval[0] < -EPS10) return null;
+      if (!interval || interval[0] < -EPS11) return null;
       return normalizeIntervals2([[Math.max(0, interval[0]), Math.max(0, interval[1])]]);
     }
     case "roundedRect": {
       const interval = roundedRectRadialProjectionInterval2(plan);
-      if (!interval || interval[0] < -EPS10) return null;
+      if (!interval || interval[0] < -EPS11) return null;
       return normalizeIntervals2([[Math.max(0, interval[0]), Math.max(0, interval[1])]]);
     }
     case "boolean": {
@@ -67220,7 +67327,7 @@ function radialProjectionIntervalsForRevolveProfile2(plan) {
   }
 }
 function expandRadialIntervalsForOutwardOffset2(intervals, thickness) {
-  if (!Number.isFinite(thickness) || thickness <= EPS10) return null;
+  if (!Number.isFinite(thickness) || thickness <= EPS11) return null;
   const expanded = intervals.map(([inner, outer]) => [Math.max(0, inner - thickness), outer + thickness]);
   return normalizeIntervals2(expanded);
 }
@@ -67228,19 +67335,19 @@ function radialIntervalsForSimpleFullRevolutionFootprint2(footprint) {
   const halfX = footprint.kind === "circle" ? footprint.footprint.radius : footprint.kind === "rect" ? footprint.footprint.halfWidth : roundedRectHalfExtentAlong2d(footprint.footprint, [1, 0]);
   const inner = footprint.footprint.center[0] - halfX;
   const outer = footprint.footprint.center[0] + halfX;
-  if (inner < -EPS10 || outer <= EPS10) return null;
+  if (inner < -EPS11 || outer <= EPS11) return null;
   return normalizeIntervals2([[Math.max(0, inner), outer]]);
 }
 function insetSimpleFullRevolutionProfileFootprint2(plan, distance5) {
   switch (plan.kind) {
     case "circle": {
       const circle2 = circleProfileFootprint(plan);
-      if (!circle2 || circle2.radius <= distance5 + EPS10) return null;
+      if (!circle2 || circle2.radius <= distance5 + EPS11) return null;
       return { kind: "circle", footprint: { center: circle2.center, radius: circle2.radius - distance5 } };
     }
     case "rect": {
       const rect2 = rectProfileFootprint(plan);
-      if (!rect2 || rect2.halfWidth <= distance5 + EPS10 || rect2.halfHeight <= distance5 + EPS10) return null;
+      if (!rect2 || rect2.halfWidth <= distance5 + EPS11 || rect2.halfHeight <= distance5 + EPS11) return null;
       return {
         kind: "rect",
         footprint: {
@@ -67252,7 +67359,7 @@ function insetSimpleFullRevolutionProfileFootprint2(plan, distance5) {
     }
     case "roundedRect": {
       const roundedRect2 = roundedRectProfileFootprint(plan);
-      if (!roundedRect2 || roundedRect2.halfWidth <= distance5 + EPS10 || roundedRect2.halfHeight <= distance5 + EPS10 || roundedRect2.radius <= distance5 + EPS10) {
+      if (!roundedRect2 || roundedRect2.halfWidth <= distance5 + EPS11 || roundedRect2.halfHeight <= distance5 + EPS11 || roundedRect2.radius <= distance5 + EPS11) {
         return null;
       }
       return {
@@ -67315,7 +67422,7 @@ function simpleFootprintStrictlyContains2(container, subject) {
             subject.footprint.center[0] - container.footprint.center[0],
             subject.footprint.center[1] - container.footprint.center[1]
           );
-          return distance5 + subject.footprint.radius < container.footprint.radius - EPS10;
+          return distance5 + subject.footprint.radius < container.footprint.radius - EPS11;
         }
         case "rect":
           return circleStrictlyContainsLoop2d(container.footprint, rectFootprintLoop(subject.footprint));
@@ -67353,9 +67460,9 @@ function simpleFootprintStrictlyContains2(container, subject) {
 function erodeSimpleFullRevolutionProfileFootprint2(footprint, distance5) {
   switch (footprint.kind) {
     case "circle":
-      return footprint.footprint.radius > distance5 + EPS10 ? { kind: "circle", footprint: { center: footprint.footprint.center, radius: footprint.footprint.radius - distance5 } } : null;
+      return footprint.footprint.radius > distance5 + EPS11 ? { kind: "circle", footprint: { center: footprint.footprint.center, radius: footprint.footprint.radius - distance5 } } : null;
     case "rect":
-      return footprint.footprint.halfWidth > distance5 + EPS10 && footprint.footprint.halfHeight > distance5 + EPS10 ? {
+      return footprint.footprint.halfWidth > distance5 + EPS11 && footprint.footprint.halfHeight > distance5 + EPS11 ? {
         kind: "rect",
         footprint: {
           center: footprint.footprint.center,
@@ -67364,7 +67471,7 @@ function erodeSimpleFullRevolutionProfileFootprint2(footprint, distance5) {
         }
       } : null;
     case "roundedRect":
-      return footprint.footprint.halfWidth > distance5 + EPS10 && footprint.footprint.halfHeight > distance5 + EPS10 && footprint.footprint.radius > distance5 + EPS10 ? {
+      return footprint.footprint.halfWidth > distance5 + EPS11 && footprint.footprint.halfHeight > distance5 + EPS11 && footprint.footprint.radius > distance5 + EPS11 ? {
         kind: "roundedRect",
         footprint: {
           center: footprint.footprint.center,
@@ -67392,7 +67499,7 @@ function simpleFootprintStrictlyContainsLoop2(container, loop) {
   }
 }
 function insetRadialIntervalsForFullRevolutionProfile2(plan, distance5) {
-  if (!Number.isFinite(distance5) || distance5 <= EPS10) return null;
+  if (!Number.isFinite(distance5) || distance5 <= EPS11) return null;
   switch (plan.kind) {
     case "circle":
     case "rect":
@@ -67533,7 +67640,7 @@ function pointSegmentDistance2d(point2, a, b) {
   const dx = b[0] - a[0];
   const dy = b[1] - a[1];
   const lenSq = dx * dx + dy * dy;
-  if (lenSq <= EPS10 * EPS10) return Math.hypot(point2[0] - a[0], point2[1] - a[1]);
+  if (lenSq <= EPS11 * EPS11) return Math.hypot(point2[0] - a[0], point2[1] - a[1]);
   const t = Math.max(0, Math.min(1, ((point2[0] - a[0]) * dx + (point2[1] - a[1]) * dy) / lenSq));
   return Math.hypot(point2[0] - (a[0] + t * dx), point2[1] - (a[1] + t * dy));
 }
@@ -67546,7 +67653,7 @@ function loopStrictlyContainsCircle2d(container, circle2) {
       pointSegmentDistance2d(circle2.center, container[idx], container[(idx + 1) % container.length])
     );
   }
-  return minBoundaryDistance > circle2.radius + EPS10;
+  return minBoundaryDistance > circle2.radius + EPS11;
 }
 function loopStrictlyContainsRoundedRect2d(container, roundedRect2) {
   const orientation3 = strictlyConvexPolygonOrientation(container);
@@ -67558,7 +67665,7 @@ function loopStrictlyContainsRoundedRect2d(container, roundedRect2) {
     if (!normal) return false;
     const edgeOffset = normal[0] * current[0] + normal[1] * current[1];
     const support = roundedRect2.center[0] * normal[0] + roundedRect2.center[1] * normal[1] + roundedRectHalfExtentAlong2d(roundedRect2, normal);
-    if (support >= edgeOffset - EPS10) return false;
+    if (support >= edgeOffset - EPS11) return false;
   }
   return true;
 }
@@ -67568,7 +67675,7 @@ function circleStrictlyContainsLoop2d(circle2, loop) {
     const a = loop[idx];
     const b = loop[(idx + 1) % loop.length];
     const midpoint7 = [(a[0] + b[0]) * 0.5, (a[1] + b[1]) * 0.5];
-    if (Math.hypot(a[0] - circle2.center[0], a[1] - circle2.center[1]) >= circle2.radius - EPS10 || Math.hypot(midpoint7[0] - circle2.center[0], midpoint7[1] - circle2.center[1]) >= circle2.radius - EPS10) {
+    if (Math.hypot(a[0] - circle2.center[0], a[1] - circle2.center[1]) >= circle2.radius - EPS11 || Math.hypot(midpoint7[0] - circle2.center[0], midpoint7[1] - circle2.center[1]) >= circle2.radius - EPS11) {
       return false;
     }
   }
@@ -67577,7 +67684,7 @@ function circleStrictlyContainsLoop2d(circle2, loop) {
 function rectStrictlyContainsRoundedRect2d(rect2, roundedRect2) {
   const halfX = roundedRectHalfExtentAlong2d(roundedRect2, [1, 0]);
   const halfY = roundedRectHalfExtentAlong2d(roundedRect2, [0, 1]);
-  return roundedRect2.center[0] - halfX > rect2.center[0] - rect2.halfWidth + EPS10 && roundedRect2.center[0] + halfX < rect2.center[0] + rect2.halfWidth - EPS10 && roundedRect2.center[1] - halfY > rect2.center[1] - rect2.halfHeight + EPS10 && roundedRect2.center[1] + halfY < rect2.center[1] + rect2.halfHeight - EPS10;
+  return roundedRect2.center[0] - halfX > rect2.center[0] - rect2.halfWidth + EPS11 && roundedRect2.center[0] + halfX < rect2.center[0] + rect2.halfWidth - EPS11 && roundedRect2.center[1] - halfY > rect2.center[1] - rect2.halfHeight + EPS11 && roundedRect2.center[1] + halfY < rect2.center[1] + rect2.halfHeight - EPS11;
 }
 function roundedRectHalfExtentAlong2d(footprint, direction2) {
   const coreHalfWidth = Math.max(0, footprint.halfWidth - footprint.radius);
@@ -67595,7 +67702,7 @@ function roundedRectAxesAreAligned2d(container, subject) {
   const sxOnCy = Math.abs(subject.xAxis[0] * container.yAxis[0] + subject.xAxis[1] * container.yAxis[1]);
   const syOnCx = Math.abs(subject.yAxis[0] * container.xAxis[0] + subject.yAxis[1] * container.xAxis[1]);
   const syOnCy = Math.abs(subject.yAxis[0] * container.yAxis[0] + subject.yAxis[1] * container.yAxis[1]);
-  return (sxOnCx <= EPS10 || sxOnCy <= EPS10) && (syOnCx <= EPS10 || syOnCy <= EPS10) && nearlyEqual(sxOnCx + sxOnCy, 1, 1e-6) && nearlyEqual(syOnCx + syOnCy, 1, 1e-6);
+  return (sxOnCx <= EPS11 || sxOnCy <= EPS11) && (syOnCx <= EPS11 || syOnCy <= EPS11) && nearlyEqual(sxOnCx + sxOnCy, 1, 1e-6) && nearlyEqual(syOnCx + syOnCy, 1, 1e-6);
 }
 function roundedRectToContainerLocal2d(container, subject) {
   if (!roundedRectAxesAreAligned2d(container, subject)) return null;
@@ -67621,7 +67728,7 @@ function roundedRectBoundaryMaxDistanceFromPoint2d(footprint, point2) {
   const includeLocal = (candidate) => {
     maxDistance = Math.max(maxDistance, Math.hypot(candidate[0] - localPoint[0], candidate[1] - localPoint[1]));
   };
-  if (footprint.radius <= EPS10) {
+  if (footprint.radius <= EPS11) {
     includeLocal([-footprint.halfWidth, -footprint.halfHeight]);
     includeLocal([footprint.halfWidth, -footprint.halfHeight]);
     includeLocal([footprint.halfWidth, footprint.halfHeight]);
@@ -67640,14 +67747,14 @@ function roundedRectBoundaryMaxDistanceFromPoint2d(footprint, point2) {
     includeLocal([center[0], center[1] + sy * footprint.radius]);
     const away = [center[0] - localPoint[0], center[1] - localPoint[1]];
     const awayLength = Math.hypot(away[0], away[1]);
-    if (awayLength > EPS10 && away[0] * sx >= -EPS10 && away[1] * sy >= -EPS10) {
+    if (awayLength > EPS11 && away[0] * sx >= -EPS11 && away[1] * sy >= -EPS11) {
       includeLocal([center[0] + away[0] / awayLength * footprint.radius, center[1] + away[1] / awayLength * footprint.radius]);
     }
   }
   return maxDistance;
 }
 function circleStrictlyContainsRoundedRect2d(circle2, roundedRect2) {
-  return roundedRectBoundaryMaxDistanceFromPoint2d(roundedRect2, circle2.center) < circle2.radius - EPS10;
+  return roundedRectBoundaryMaxDistanceFromPoint2d(roundedRect2, circle2.center) < circle2.radius - EPS11;
 }
 function roundedRectSignedDistance2d(footprint, point2) {
   const localPoint = roundedRectLocalPoint2d(footprint, point2);
@@ -67658,10 +67765,10 @@ function roundedRectSignedDistance2d(footprint, point2) {
   return Math.hypot(Math.max(qx, 0), Math.max(qy, 0)) + Math.min(Math.max(qx, qy), 0) - footprint.radius;
 }
 function roundedRectStrictlyContainsCircle2d(footprint, circle2) {
-  return roundedRectSignedDistance2d(footprint, circle2.center) + circle2.radius < -EPS10;
+  return roundedRectSignedDistance2d(footprint, circle2.center) + circle2.radius < -EPS11;
 }
 function roundedRectStrictlyContainsRoundedRect2d(container, subject) {
-  if (subject.radius > container.radius + EPS10) return false;
+  if (subject.radius > container.radius + EPS11) return false;
   const localSubject = roundedRectToContainerLocal2d(container, subject);
   if (!localSubject) return false;
   const eroded = {
@@ -67672,7 +67779,7 @@ function roundedRectStrictlyContainsRoundedRect2d(container, subject) {
     xAxis: [1, 0],
     yAxis: [0, 1]
   };
-  if (eroded.halfWidth <= EPS10 || eroded.halfHeight <= EPS10 || eroded.radius < -EPS10) return false;
+  if (eroded.halfWidth <= EPS11 || eroded.halfHeight <= EPS11 || eroded.radius < -EPS11) return false;
   const coreHalfWidth = Math.max(0, localSubject.halfWidth - localSubject.radius);
   const coreHalfHeight = Math.max(0, localSubject.halfHeight - localSubject.radius);
   const corners = [
@@ -67681,7 +67788,7 @@ function roundedRectStrictlyContainsRoundedRect2d(container, subject) {
     [localSubject.center[0] + coreHalfWidth, localSubject.center[1] + coreHalfHeight],
     [localSubject.center[0] - coreHalfWidth, localSubject.center[1] + coreHalfHeight]
   ];
-  return corners.every((corner) => roundedRectSignedDistance2d(eroded, corner) < -EPS10);
+  return corners.every((corner) => roundedRectSignedDistance2d(eroded, corner) < -EPS11);
 }
 function roundedRectStrictlyContainsLoop2d(footprint, loop) {
   if (loop.length < 3) return false;
@@ -67689,7 +67796,7 @@ function roundedRectStrictlyContainsLoop2d(footprint, loop) {
     const a = loop[idx];
     const b = loop[(idx + 1) % loop.length];
     const midpoint7 = [(a[0] + b[0]) * 0.5, (a[1] + b[1]) * 0.5];
-    if (roundedRectSignedDistance2d(footprint, a) >= -EPS10 || roundedRectSignedDistance2d(footprint, midpoint7) >= -EPS10) {
+    if (roundedRectSignedDistance2d(footprint, a) >= -EPS11 || roundedRectSignedDistance2d(footprint, midpoint7) >= -EPS11) {
       return false;
     }
   }
@@ -67701,7 +67808,7 @@ function simplePolygonReplayProfile(plan) {
     if (![plan.width, plan.height].every(Number.isFinite)) return null;
     const halfWidth = Math.abs(plan.width) * 0.5;
     const halfHeight = Math.abs(plan.height) * 0.5;
-    if (halfWidth <= EPS10 || halfHeight <= EPS10) return null;
+    if (halfWidth <= EPS11 || halfHeight <= EPS11) return null;
     return {
       kind: "polygon",
       points: [
@@ -67737,7 +67844,7 @@ function cleanPolyline(points) {
   for (const point2 of points) {
     if (!point2.every(Number.isFinite)) return null;
     const previous = clean[clean.length - 1];
-    if (!previous || Math.hypot(point2[0] - previous[0], point2[1] - previous[1], point2[2] - previous[2]) > EPS10) {
+    if (!previous || Math.hypot(point2[0] - previous[0], point2[1] - previous[1], point2[2] - previous[2]) > EPS11) {
       clean.push([point2[0], point2[1], point2[2]]);
     }
   }
@@ -67816,7 +67923,7 @@ function variableSweepProjectionReplayContext(plan) {
     return { ok: false, reason: "projection replay requires finite compatible variable-sweep sections." };
   }
   const sortedT = plan.sections.map((section) => section.t).sort((a, b) => a - b);
-  if (sortedT.some((t, idx) => idx > 0 && t <= sortedT[idx - 1] + EPS10)) {
+  if (sortedT.some((t, idx) => idx > 0 && t <= sortedT[idx - 1] + EPS11)) {
     return { ok: false, reason: "projection replay requires distinct variable-sweep section parameters." };
   }
   const profile = nestedPolygonProjectionProfile(plan.sections.map((section) => section.profile));
@@ -67833,7 +67940,7 @@ function variableSweepProjectionReplayContext(plan) {
 }
 function fromSlicesGroupPlaneFrame(normalInput) {
   const length7 = Math.hypot(normalInput[0], normalInput[1], normalInput[2]);
-  if (length7 <= EPS10) return null;
+  if (length7 <= EPS11) return null;
   const normal = normalize8(normalInput);
   const [nx, ny, nz] = normal;
   if (Math.abs(nz) > 1 - 1e-8) {
@@ -67866,7 +67973,7 @@ function fromSlicesProjectionReplayContext(plan) {
   if (sorted.some((slice) => !Number.isFinite(slice.offset))) {
     return { ok: false, reason: "projection replay requires finite Shape.fromSlices() offsets." };
   }
-  if (sorted.some((slice, idx) => idx > 0 && slice.offset <= sorted[idx - 1].offset + EPS10)) {
+  if (sorted.some((slice, idx) => idx > 0 && slice.offset <= sorted[idx - 1].offset + EPS11)) {
     return { ok: false, reason: "projection replay requires distinct Shape.fromSlices() offsets." };
   }
   if (sorted.length === 1) {
@@ -67894,7 +68001,7 @@ function matrixDistanceScale(matrix) {
   const sx = matrixColumnLength(matrix, 0);
   const sy = matrixColumnLength(matrix, 1);
   const sz = matrixColumnLength(matrix, 2);
-  if (sx <= EPS10 || !Number.isFinite(sx)) return null;
+  if (sx <= EPS11 || !Number.isFinite(sx)) return null;
   if (!nearlyEqual(sx, sy, 1e-9) || !nearlyEqual(sx, sz, 1e-9)) return null;
   if (Math.abs(matrixColumnDot(matrix, 0, 1)) > 1e-9 || Math.abs(matrixColumnDot(matrix, 0, 2)) > 1e-9 || Math.abs(matrixColumnDot(matrix, 1, 2)) > 1e-9) {
     return null;
@@ -67912,7 +68019,7 @@ function offsetSolidTransformDistanceScale2(step) {
       const sy = Math.abs(step.y);
       const sz = Math.abs(step.z);
       const scale8 = Math.max(sx, sy, sz);
-      if (scale8 <= EPS10 || !Number.isFinite(scale8) || !nearlyEqual(sx, scale8, 1e-9) || !nearlyEqual(sy, scale8, 1e-9) || !nearlyEqual(sz, scale8, 1e-9)) {
+      if (scale8 <= EPS11 || !Number.isFinite(scale8) || !nearlyEqual(sx, scale8, 1e-9) || !nearlyEqual(sy, scale8, 1e-9) || !nearlyEqual(sz, scale8, 1e-9)) {
         return null;
       }
       return scale8;
@@ -68154,12 +68261,12 @@ function offsetSolidFromSlicesLoftProjectionReplayContext(plan) {
   if (sorted.some((slice) => !Number.isFinite(slice.offset))) {
     return { ok: false, reason: "projection replay requires finite Shape.fromSlices() offsets before offsetSolid()." };
   }
-  if (sorted.some((slice, idx) => idx > 0 && slice.offset <= sorted[idx - 1].offset + EPS10)) {
+  if (sorted.some((slice, idx) => idx > 0 && slice.offset <= sorted[idx - 1].offset + EPS11)) {
     return { ok: false, reason: "projection replay requires distinct Shape.fromSlices() offsets before offsetSolid()." };
   }
   const zMin = sorted[0].offset - plan.thickness;
   const zMax = sorted[sorted.length - 1].offset + plan.thickness;
-  if (zMax <= zMin + EPS10) {
+  if (zMax <= zMin + EPS11) {
     return { ok: false, reason: "projection replay cannot derive a collapsed offsetSolid(Shape.fromSlices(...)) vertical span." };
   }
   const profile = nestedPolygonProjectionProfile(sorted.map((slice) => slice.profile));
@@ -68245,7 +68352,7 @@ function offsetSolidFullRevolutionProjectionReplayContext(plan) {
     };
   }
   const localThickness = plan.thickness / source.context.distanceScale;
-  const offsetIntervals = localThickness > EPS10 ? expandRadialIntervalsForOutwardOffset2(baseIntervals, localThickness) : insetRadialIntervalsForFullRevolutionProfile2(source.context.plan.profile, Math.abs(localThickness));
+  const offsetIntervals = localThickness > EPS11 ? expandRadialIntervalsForOutwardOffset2(baseIntervals, localThickness) : insetRadialIntervalsForFullRevolutionProfile2(source.context.plan.profile, Math.abs(localThickness));
   if (!offsetIntervals || offsetIntervals.length === 0) {
     return {
       ok: false,
@@ -68267,7 +68374,7 @@ function offsetSolidProjectionReplayContext(plan) {
   }
   const zMin = base.zMin - plan.thickness;
   const zMax = base.zMax + plan.thickness;
-  if (zMax <= zMin + EPS10) {
+  if (zMax <= zMin + EPS11) {
     return { ok: false, reason: "projection replay cannot derive a collapsed offsetSolid() vertical span." };
   }
   const distanceScale = offsetSolidBaseDistanceScale(plan.base);
@@ -70412,9 +70519,84 @@ var ConstraintSketch = class extends Sketch {
    * Select the single arrangement region that contains the given seed point.
    * Throws if no region contains the seed.
    */
-  detectArrangementRegion(seed) {
+  detectArrangementRegion(_seed) {
     throw new Error("Not implemented");
   }
+  /**
+   * Return the solved constrained path as a sampled 2D polyline.
+   *
+   * Use this when a construction rail was authored with `constrainedSketch()`
+   * and should feed another operation such as `Loft.pathOnXz(...)`.
+   * The sketch must contain exactly one profile path.
+   *
+   * @param samples - Samples per curved segment. Default 32.
+   * @returns The solved path as an open polyline.
+   */
+  toPolyline(samples = 32) {
+    if (!Number.isFinite(samples) || samples < 2) throw new Error("ConstraintSketch.toPolyline() samples must be at least 2");
+    const profileLoops = this.definition.loops.filter((loop) => loop.type === "profile");
+    if (profileLoops.length !== 1) {
+      throw new Error("ConstraintSketch.toPolyline() requires exactly one profile path");
+    }
+    const sampleCount = Math.max(2, Math.round(samples));
+    const pointMap = new Map(this.definition.points.map((point2) => [point2.id, point2]));
+    const lineMap = new Map(this.definition.lines.map((line2) => [line2.id, line2]));
+    const arcMap = new Map(this.definition.arcs.map((arc) => [arc.id, arc]));
+    const bezierMap = new Map(this.definition.beziers.map((bezier) => [bezier.id, bezier]));
+    const points = [];
+    const appendStart = (point2, label) => {
+      const previous = points[points.length - 1];
+      if (!previous) {
+        points.push(point2);
+        return;
+      }
+      if (Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-6) {
+        throw new Error(`ConstraintSketch.toPolyline() profile path is not continuous at ${label}`);
+      }
+    };
+    const appendPoint = (point2) => {
+      const previous = points[points.length - 1];
+      if (!previous || Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-9) points.push(point2);
+    };
+    const requirePoint = (id, label) => {
+      const point2 = pointMap.get(id);
+      if (!point2) throw new Error(`ConstraintSketch.toPolyline() missing ${label}`);
+      return [point2.x, point2.y];
+    };
+    for (const segment of profileLoops[0].segments) {
+      if (segment.kind === "line") {
+        const line2 = lineMap.get(segment.line);
+        if (!line2) throw new Error(`ConstraintSketch.toPolyline() missing line "${segment.line}"`);
+        appendStart(requirePoint(line2.a, `line "${segment.line}" start point`), `line "${segment.line}"`);
+        appendPoint(requirePoint(line2.b, `line "${segment.line}" end point`));
+      } else if (segment.kind === "arc") {
+        const arc = arcMap.get(segment.arc);
+        if (!arc) throw new Error(`ConstraintSketch.toPolyline() missing arc "${segment.arc}"`);
+        const center = requirePoint(arc.center, `arc "${segment.arc}" center point`);
+        const start = requirePoint(arc.start, `arc "${segment.arc}" start point`);
+        const end = requirePoint(arc.end, `arc "${segment.arc}" end point`);
+        appendStart(start, `arc "${segment.arc}"`);
+        const startAngle = Math.atan2(start[1] - center[1], start[0] - center[0]);
+        const endAngle = Math.atan2(end[1] - center[1], end[0] - center[0]);
+        for (const point2 of tessellateArc(center[0], center[1], arc.radius, startAngle, endAngle, arc.clockwise, sampleCount)) {
+          appendPoint(point2);
+        }
+      } else {
+        const bezier = bezierMap.get(segment.bezier);
+        if (!bezier) throw new Error(`ConstraintSketch.toPolyline() missing bezier "${segment.bezier}"`);
+        const p0 = requirePoint(bezier.p0, `bezier "${segment.bezier}" start point`);
+        const p1 = requirePoint(bezier.p1, `bezier "${segment.bezier}" first control point`);
+        const p2 = requirePoint(bezier.p2, `bezier "${segment.bezier}" second control point`);
+        const p3 = requirePoint(bezier.p3, `bezier "${segment.bezier}" end point`);
+        appendStart(p0, `bezier "${segment.bezier}"`);
+        for (const point2 of tessellateBezier(p0[0], p0[1], p1[0], p1[1], p2[0], p2[1], p3[0], p3[1], sampleCount)) {
+          appendPoint(point2);
+        }
+      }
+    }
+    if (points.length < 2) throw new Error("ConstraintSketch.toPolyline() needs at least 2 points");
+    return points;
+  }
   /**
    * Re-solve the sketch after changing the value of one existing constraint.
    *
@@ -73368,7 +73550,7 @@ function sampleCubic(p0, p1, p2, p3, tolerance) {
   }
   return out;
 }
-var EPS11 = 1e-10;
+var EPS12 = 1e-10;
 function signedArea7(points) {
   let area2 = 0;
   for (let i = 0; i < points.length; i++) {
@@ -73382,7 +73564,7 @@ function removeDuplicateClosing(points) {
   if (points.length < 2) return points;
   const first = points[0];
   const last = points[points.length - 1];
-  if (Math.abs(first[0] - last[0]) < EPS11 && Math.abs(first[1] - last[1]) < EPS11) {
+  if (Math.abs(first[0] - last[0]) < EPS12 && Math.abs(first[1] - last[1]) < EPS12) {
     return points.slice(0, -1);
   }
   return points;
@@ -73442,7 +73624,7 @@ function loopInfo(points) {
   return { points, area: area2, absArea: Math.abs(area2), sample };
 }
 function loopsToSketch(loops) {
-  const infos = loops.filter((l) => l.length >= 3 && Math.abs(signedArea7(l)) > EPS11).map(loopInfo);
+  const infos = loops.filter((l) => l.length >= 3 && Math.abs(signedArea7(l)) > EPS12).map(loopInfo);
   if (infos.length === 0) return null;
   const dominant = [...infos].sort((a, b) => b.absArea - a.absArea)[0];
   const dominantSign = dominant.area >= 0 ? 1 : -1;
@@ -73542,6 +73724,303 @@ function polygonVertices(sides, radius, options) {
   });
 }
 
+// src/forge/sketch/loftGuideTypes.ts
+var LOFT_GUIDE_EPS = 1e-8;
+
+// src/forge/sketch/loftGuideRailSampling.ts
+function orientLoftToAxis2(shape, axis) {
+  if (axis === "Z") return shape;
+  if (axis === "Y") return shape.rotateX(-90);
+  return shape.transform([0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1]);
+}
+function buildRailEvaluators(rails, axis, start, end, railSamples) {
+  const seen = /* @__PURE__ */ new Set();
+  return rails.map((rail2) => {
+    if (seen.has(rail2.side)) throw new Error(`Loft.withGuideRails() received more than one ${rail2.side} rail`);
+    seen.add(rail2.side);
+    const sampled = sampleRailPath(rail2.path, railSamples);
+    if (sampled.length < 2) throw new Error("Loft guide rails require at least two points");
+    const points = sampled.map((point2) => ({ position: axisPosition2(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 index = 0; index < points.length - 1; index += 1) {
+    const a = points[index];
+    const b = points[index + 1];
+    if (position >= a.position - LOFT_GUIDE_EPS && position <= b.position + LOFT_GUIDE_EPS) {
+      const t = (position - a.position) / (b.position - a.position);
+      return [lerp5(a.cross[0], b.cross[0], t), lerp5(a.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 index = 1; index < points.length; index += 1) {
+    if (points[index].position - points[index - 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(path4, samples) {
+  if (Array.isArray(path4)) return path4.map((point2, index) => requireVec34(point2, `Loft guide rail point ${index}`));
+  if (path4 instanceof Curve3D || path4 instanceof HermiteCurve3D || path4 instanceof QuinticHermiteCurve3D || path4 instanceof NurbsCurve3D) {
+    return path4.sample(Math.max(2, Math.round(samples))).map((point2, index) => requireVec34(point2, `Loft guide rail sample ${index}`));
+  }
+  throw new Error("Loft guide rail path must be a Vec3[] or ForgeCAD 3D curve");
+}
+function requireVec34(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 axisPosition2(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 lerp5(a, b, t) {
+  return a + (b - a) * t;
+}
+
+// src/forge/sketch/loftGuided.ts
+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 bounds2 = boundsForPosition(sortedStations, position);
+    return fitProfileToBounds(source, applyRailsToBounds(bounds2, railEvaluators, position));
+  });
+  const shape = loft(profiles2, positions, {
+    edgeLength: options.edgeLength,
+    boundsPadding: options.boundsPadding
+  });
+  return orientLoftToAxis2(shape, axis);
+}
+function sortedValidStations(stations) {
+  const sorted = [...stations].sort((a, b) => a.position - b.position);
+  for (let index = 0; index < sorted.length; index += 1) {
+    if (!Number.isFinite(sorted[index].position)) throw new Error("Loft.withGuideRails station position must be finite");
+    if (!(sorted[index].profile instanceof Sketch)) throw new Error("Loft.withGuideRails() stations must use Sketch profiles");
+    if (index > 0 && sorted[index].position - sorted[index - 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 index = 0; index < count; index += 1) addPosition(start + (end - start) * index / (count - 1));
+  for (const station of stations) addPosition(station.position);
+  return positions.sort((a, b) => a - b);
+}
+function profileForPosition(stations, position) {
+  for (let index = 0; index < stations.length - 1; index += 1) {
+    if (position <= stations[index + 1].position + LOFT_GUIDE_EPS) return stations[index].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 index = 0; index < stations.length - 1; index += 1) {
+    const a = stations[index];
+    const b = stations[index + 1];
+    if (position >= a.position - LOFT_GUIDE_EPS && position <= b.position + LOFT_GUIDE_EPS) {
+      return lerpBounds(sketchBounds(a.profile), sketchBounds(b.profile), (position - a.position) / (b.position - a.position));
+    }
+  }
+  return sketchBounds(last.profile);
+}
+function applyRailsToBounds(bounds2, rails, position) {
+  const centerRail = rails.find((rail2) => rail2.side === "center");
+  const center = centerRail ? railCrossAt(centerRail, position) : void 0;
+  const next = { ...bounds2 };
+  applyAxisRail(next, "X", sideValue(rails, "left", position, 0), sideValue(rails, "right", position, 0), center?.[0]);
+  applyAxisRail(next, "Y", sideValue(rails, "back", position, 1), sideValue(rails, "front", position, 1), 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(bounds2, axis, minRail, maxRail, center) {
+  const minKey = axis === "X" ? "minX" : "minY";
+  const maxKey = axis === "X" ? "maxX" : "maxY";
+  const width = bounds2[maxKey] - bounds2[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");
+    }
+    bounds2[minKey] = minRail;
+    bounds2[maxKey] = maxRail;
+  } else if (maxRail != null) {
+    bounds2[maxKey] = maxRail;
+    bounds2[minKey] = center != null ? 2 * center - maxRail : maxRail - width;
+  } else if (minRail != null) {
+    bounds2[minKey] = minRail;
+    bounds2[maxKey] = center != null ? 2 * center - minRail : minRail + width;
+  } else if (center != null) {
+    bounds2[minKey] = center - width / 2;
+    bounds2[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 bounds2 = profile.bounds();
+  return { minX: bounds2.min[0], maxX: bounds2.max[0], minY: bounds2.min[1], maxY: bounds2.max[1] };
+}
+function lerpBounds(a, b, t) {
+  return {
+    minX: lerp6(a.minX, b.minX, t),
+    maxX: lerp6(a.maxX, b.maxX, t),
+    minY: lerp6(a.minY, b.minY, t),
+    maxY: lerp6(a.maxY, b.maxY, t)
+  };
+}
+function lerp6(a, b, t) {
+  return a + (b - a) * t;
+}
+
+// src/forge/sketch/loftNamespace.ts
+function mapLoftPath2D(path4, label, mapper) {
+  const points = sampleLoftPath2D(path4, label);
+  return points.map((point2, index) => {
+    if (!Array.isArray(point2) || point2.length !== 2 || !point2.every(Number.isFinite)) {
+      throw new Error(`${label} point ${index} must be a finite [x, y] point`);
+    }
+    return mapper([point2[0], point2[1]]);
+  });
+}
+function sampleLoftPath2D(path4, label) {
+  if (Array.isArray(path4)) {
+    if (path4.length < 2) throw new Error(`${label} requires at least two [x, y] points`);
+    return path4;
+  }
+  if (!path4 || typeof path4 !== "object" || typeof path4.toPolyline !== "function") {
+    throw new Error(`${label} requires a 2D path, solved constrained path, or [x, y] point array`);
+  }
+  const points = path4.toPolyline();
+  if (!Array.isArray(points) || points.length < 2) throw new Error(`${label} path must produce at least two [x, y] points`);
+  return points;
+}
+var 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(path4) {
+    return { side: "left", path: path4 };
+  },
+  /** Create a guide rail that constrains the section-local positive-X side. */
+  rightRail(path4) {
+    return { side: "right", path: path4 };
+  },
+  /** Create a guide rail that constrains the section-local positive-Y side. */
+  frontRail(path4) {
+    return { side: "front", path: path4 };
+  },
+  /** Create a guide rail that constrains the section-local negative-Y side. */
+  backRail(path4) {
+    return { side: "back", path: path4 };
+  },
+  /** Create a guide rail that moves section centers along the loft. */
+  centerRail(path4) {
+    return { side: "center", path: path4 };
+  },
+  /**
+   * 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(path4, y = 0) {
+    if (!Number.isFinite(y)) throw new Error("Loft.pathOnXz y must be finite");
+    return mapLoftPath2D(path4, "Loft.pathOnXz", ([x, z]) => [x, y, z]);
+  },
+  /**
+   * 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(path4, x = 0) {
+    if (!Number.isFinite(x)) throw new Error("Loft.pathOnYz x must be finite");
+    return mapLoftPath2D(path4, "Loft.pathOnYz", ([y, z]) => [x, y, z]);
+  },
+  /**
+   * 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(path4, z = 0) {
+    if (!Number.isFinite(z)) throw new Error("Loft.pathOnXy z must be finite");
+    return mapLoftPath2D(path4, "Loft.pathOnXy", ([x, y]) => [x, y, z]);
+  },
+  /**
+   * 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);
+  }
+};
+
 // src/forge/sketch/highlights.ts
 var collectedHighlights = [];
 function resetHighlights() {
@@ -73819,7 +74298,7 @@ Sketch.prototype.onFace = function(parentOrFace, faceOrOpts, maybeOpts = {}) {
 };
 
 // src/forge/sketch/regions.ts
-var EPS12 = 1e-9;
+var EPS13 = 1e-9;
 var MIN_POINT_DIST = 1e-7;
 function dist22(a, b) {
   return Math.hypot(a[0] - b[0], a[1] - b[1]);
@@ -73833,7 +74312,7 @@ function signedArea8(pts) {
   }
   return area2 * 0.5;
 }
-function polygonCentroid(pts) {
+function polygonCentroid2(pts) {
   let cx = 0;
   let cy = 0;
   let a2 = 0;
@@ -73845,7 +74324,7 @@ function polygonCentroid(pts) {
     cx += (x1 + x2) * cross13;
     cy += (y1 + y2) * cross13;
   }
-  if (Math.abs(a2) < EPS12) {
+  if (Math.abs(a2) < EPS13) {
     let sx = 0;
     let sy = 0;
     for (const [x, y] of pts) {
@@ -73880,8 +74359,8 @@ function extractRegionCandidates(sketch) {
   const rawLoops = sketch.toPolygons();
   const loops = rawLoops.map((loop) => loop.map(([x, y]) => [x, y])).map((pts) => removeDuplicateClose(pts)).filter((pts) => pts.length >= 3).map((pts) => {
     const area2 = signedArea8(pts);
-    return { points: pts, area: area2, absArea: Math.abs(area2), sample: polygonCentroid(pts) };
-  }).filter((loop) => loop.absArea > EPS12);
+    return { points: pts, area: area2, absArea: Math.abs(area2), sample: polygonCentroid2(pts) };
+  }).filter((loop) => loop.absArea > EPS13);
   if (loops.length === 0) return [];
   const outers = loops.filter((l) => l.area > 0);
   const holes = loops.filter((l) => l.area < 0);
@@ -74935,7 +75414,7 @@ function surfacePatch(curves, options = {}) {
 
 // src/forge/sketch/svgImport.ts
 var MIN_POINT_DIST2 = 1e-7;
-var EPS13 = 1e-9;
+var EPS14 = 1e-9;
 var DEFAULT_STYLE = {
   fill: "black",
   stroke: "none",
@@ -74985,7 +75464,7 @@ function centroidFallback(points) {
   }
   return [sx / points.length, sy / points.length];
 }
-function polygonCentroid2(points) {
+function polygonCentroid3(points) {
   let cx = 0;
   let cy = 0;
   let a2 = 0;
@@ -74997,7 +75476,7 @@ function polygonCentroid2(points) {
     cx += (x1 + x2) * cross13;
     cy += (y1 + y2) * cross13;
   }
-  if (Math.abs(a2) < EPS13) return centroidFallback(points);
+  if (Math.abs(a2) < EPS14) return centroidFallback(points);
   const factor = 1 / (3 * a2);
   return [cx * factor, cy * factor];
 }
@@ -75240,7 +75719,7 @@ function vectorAngle(ux, uy, vx, vy) {
 function sampleArc2(x1, y1, rxInput, ryInput, xAxisRotation, largeArcFlag, sweepFlag, x2, y2, tolerance, arcSegmentsMin) {
   let rx = Math.abs(rxInput);
   let ry = Math.abs(ryInput);
-  if (rx < EPS13 || ry < EPS13) return [[x2, y2]];
+  if (rx < EPS14 || ry < EPS14) return [[x2, y2]];
   const phi = xAxisRotation * Math.PI / 180;
   const cosPhi = Math.cos(phi);
   const sinPhi = Math.sin(phi);
@@ -75260,7 +75739,7 @@ function sampleArc2(x1, y1, rxInput, ryInput, xAxisRotation, largeArcFlag, sweep
   const y1p2 = sqr(y1p);
   let factorNum = rx2 * ry2 - rx2 * y1p2 - ry2 * x1p2;
   let factorDen = rx2 * y1p2 + ry2 * x1p2;
-  if (factorDen < EPS13) factorDen = EPS13;
+  if (factorDen < EPS14) factorDen = EPS14;
   factorNum = Math.max(0, factorNum);
   const factor = (largeArcFlag === sweepFlag ? -1 : 1) * Math.sqrt(factorNum / factorDen);
   const cxp = factor * (rx * y1p / ry);
@@ -75541,7 +76020,7 @@ function parsePathData(d, tolerance, arcSegments) {
   return out;
 }
 function buildCircleSubpath(cx, cy, rx, ry, tolerance) {
-  if (!(rx > EPS13) || !(ry > EPS13)) return [];
+  if (!(rx > EPS14) || !(ry > EPS14)) return [];
   const circumference = 2 * Math.PI * Math.max(rx, ry);
   const segments = clamp11(Math.ceil(circumference / Math.max(tolerance, 1e-4)), 16, 720);
   const points = [];
@@ -75562,10 +76041,10 @@ function appendArcSegment(points, cx, cy, rx, ry, startAngle, endAngle, toleranc
 function buildRoundedRectSubpath(x, y, width, height, rxInput, ryInput, tolerance) {
   const w = width;
   const h = height;
-  if (!(w > EPS13) || !(h > EPS13)) return [];
+  if (!(w > EPS14) || !(h > EPS14)) return [];
   const rx = clamp11(rxInput, 0, w / 2);
   const ry = clamp11(ryInput, 0, h / 2);
-  if (rx < EPS13 || ry < EPS13) {
+  if (rx < EPS14 || ry < EPS14) {
     return [
       {
         points: [
@@ -75610,7 +76089,7 @@ function geometryFromElement(tag, attrs, tolerance, arcSegments) {
     const y = parseLength(attrs.y, 0);
     const width = parseLength(attrs.width, NaN);
     const height = parseLength(attrs.height, NaN);
-    if (!(width > EPS13) || !(height > EPS13)) return [];
+    if (!(width > EPS14) || !(height > EPS14)) return [];
     let rx = parseLength(attrs.rx, NaN);
     let ry = parseLength(attrs.ry, NaN);
     if (!Number.isFinite(rx) && Number.isFinite(ry)) rx = ry;
@@ -75623,7 +76102,7 @@ function geometryFromElement(tag, attrs, tolerance, arcSegments) {
     const cx = parseLength(attrs.cx, 0);
     const cy = parseLength(attrs.cy, 0);
     const r = parseLength(attrs.r, NaN);
-    if (!(r > EPS13)) return [];
+    if (!(r > EPS14)) return [];
     return buildCircleSubpath(cx, cy, r, r, tolerance);
   }
   if (t === "ellipse") {
@@ -75631,7 +76110,7 @@ function geometryFromElement(tag, attrs, tolerance, arcSegments) {
     const cy = parseLength(attrs.cy, 0);
     const rx = parseLength(attrs.rx, NaN);
     const ry = parseLength(attrs.ry, NaN);
-    if (!(rx > EPS13) || !(ry > EPS13)) return [];
+    if (!(rx > EPS14) || !(ry > EPS14)) return [];
     return buildCircleSubpath(cx, cy, rx, ry, tolerance);
   }
   if (t === "line") {
@@ -75666,7 +76145,7 @@ function sanitizeSubpaths(subpaths) {
   for (const subpath of subpaths) {
     const points = removeDuplicateClosingPoint(subpath.points);
     if (subpath.closed) {
-      if (points.length >= 3 && Math.abs(signedArea9(points)) > EPS13) {
+      if (points.length >= 3 && Math.abs(signedArea9(points)) > EPS14) {
         out.push({ points, closed: true });
       }
     } else if (points.length >= 2) {
@@ -75676,10 +76155,10 @@ function sanitizeSubpaths(subpaths) {
   return out;
 }
 function styleHasFill(style) {
-  return style.fill !== "none" && style.fill !== "transparent" && style.opacity > EPS13 && style.fillOpacity > EPS13;
+  return style.fill !== "none" && style.fill !== "transparent" && style.opacity > EPS14 && style.fillOpacity > EPS14;
 }
 function styleHasStroke(style) {
-  return style.stroke !== "none" && style.stroke !== "transparent" && style.strokeWidth > EPS13 && style.opacity > EPS13 && style.strokeOpacity > EPS13;
+  return style.stroke !== "none" && style.stroke !== "transparent" && style.strokeWidth > EPS14 && style.opacity > EPS14 && style.strokeOpacity > EPS14;
 }
 function loopInfosFromClosedSubpaths(subpaths) {
   const loops = [];
@@ -75689,12 +76168,12 @@ function loopInfosFromClosedSubpaths(subpaths) {
     if (points.length < 3) continue;
     const area2 = signedArea9(points);
     const absArea = Math.abs(area2);
-    if (absArea <= EPS13) continue;
+    if (absArea <= EPS14) continue;
     loops.push({
       points,
       area: area2,
       absArea,
-      sample: polygonCentroid2(points)
+      sample: polygonCentroid3(points)
     });
   }
   return loops;
@@ -75710,7 +76189,7 @@ function buildFilledSketch(subpaths, fillRule) {
       let depth = 0;
       for (const other of loops) {
         if (other === loop) continue;
-        if (other.absArea <= loop.absArea + EPS13) continue;
+        if (other.absArea <= loop.absArea + EPS14) continue;
         if (pointInPolygon3(loop.sample, other.points)) depth += 1;
       }
       const loopSketch = polygon(loop.points);
@@ -75748,7 +76227,7 @@ function buildClosedStroke(loopPoints, width, join14) {
   return ring.isEmpty() ? null : ring;
 }
 function buildStrokeSketch(subpaths, width, join14) {
-  if (!(width > EPS13)) return null;
+  if (!(width > EPS14)) return null;
   const joinMode = strokeJoinToSketchJoin(join14);
   const parts = [];
   for (const subpath of subpaths) {
@@ -75770,8 +76249,8 @@ function buildRegionSketches(sketch) {
   const rawLoops = sketch.toPolygons();
   const loops = rawLoops.map((loop) => loop.map(([x, y]) => [x, y])).map((points) => removeDuplicateClosingPoint(points)).filter((points) => points.length >= 3).map((points) => {
     const area2 = signedArea9(points);
-    return { points, area: area2, absArea: Math.abs(area2), sample: polygonCentroid2(points) };
-  }).filter((loop) => loop.absArea > EPS13);
+    return { points, area: area2, absArea: Math.abs(area2), sample: polygonCentroid3(points) };
+  }).filter((loop) => loop.absArea > EPS14);
   if (loops.length === 0) return [];
   const outers = loops.filter((loop) => loop.area > 0);
   const holes = loops.filter((loop) => loop.area < 0);
@@ -75811,7 +76290,7 @@ function filterRegions(sketch, options) {
   if (regions.length === 0) return sketch;
   const largestArea = regions[0].area;
   const minArea = Math.max(options.minRegionArea, largestArea * options.minRegionAreaRatio);
-  let kept = regions.filter((region) => region.area + EPS13 >= minArea);
+  let kept = regions.filter((region) => region.area + EPS14 >= minArea);
   if (kept.length === 0) kept = [regions[0]];
   if (options.regionSelection === "largest") {
     kept = [kept[0]];
@@ -75833,13 +76312,13 @@ function fitSketchToMaxDimensions(sketch, options) {
   const width = Math.max(0, (max4[0] ?? 0) - (min2[0] ?? 0));
   const height = Math.max(0, (max4[1] ?? 0) - (min2[1] ?? 0));
   let fitScale = Number.POSITIVE_INFINITY;
-  if (constrainWidth && width > EPS13) {
+  if (constrainWidth && width > EPS14) {
     fitScale = Math.min(fitScale, options.maxWidth / width);
   }
-  if (constrainHeight && height > EPS13) {
+  if (constrainHeight && height > EPS14) {
     fitScale = Math.min(fitScale, options.maxHeight / height);
   }
-  if (!Number.isFinite(fitScale) || fitScale <= 0 || fitScale >= 1 - EPS13) {
+  if (!Number.isFinite(fitScale) || fitScale <= 0 || fitScale >= 1 - EPS14) {
     return sketch;
   }
   return sketch.scale(fitScale);
@@ -75851,7 +76330,7 @@ function centerSketchOnOrigin(sketch, options) {
   const max4 = bounds2.max;
   const cx = ((min2[0] ?? 0) + (max4[0] ?? 0)) * 0.5;
   const cy = ((min2[1] ?? 0) + (max4[1] ?? 0)) * 0.5;
-  if (Math.abs(cx) <= EPS13 && Math.abs(cy) <= EPS13) return sketch;
+  if (Math.abs(cx) <= EPS14 && Math.abs(cy) <= EPS14) return sketch;
   return sketch.translate(-cx, -cy);
 }
 function computeRootNormalizeMatrix(attrs, options) {
@@ -75862,7 +76341,7 @@ function computeRootNormalizeMatrix(attrs, options) {
     const flipY = viewBox.length >= 4 ? viewBox[1] + viewBox[3] : Number.isFinite(fallbackHeight) ? fallbackHeight : 0;
     matrix = multiplyMatrix(matrixTranslate(0, flipY), matrixScale(1, -1));
   }
-  if (Math.abs(options.scale - 1) > EPS13) {
+  if (Math.abs(options.scale - 1) > EPS14) {
     matrix = multiplyMatrix(matrixScale(options.scale, options.scale), matrix);
   }
   return matrix;
@@ -75913,7 +76392,7 @@ function parseSvgGeometry(svgText, options) {
       topLevelSvgSeen = true;
       combinedTransform = multiplyMatrix(computeRootNormalizeMatrix(attrs, options), combinedTransform);
     }
-    const hidden = parent.hidden || mergedStyle.display === "none" || mergedStyle.visibility === "hidden" || mergedStyle.opacity <= EPS13;
+    const hidden = parent.hidden || mergedStyle.display === "none" || mergedStyle.visibility === "hidden" || mergedStyle.opacity <= EPS14;
     const inDefs = parent.inDefs || tag === "defs" || tag === "symbol" || tag === "clipPath" || tag === "mask" || tag === "pattern";
     const ctx = {
       transform: combinedTransform,
@@ -77544,8 +78023,8 @@ function computeSheetCutSequence(sheet) {
   const result = [];
   function decompose(rx, ry, rw, rh, pieces) {
     if (pieces.length <= 1) return;
-    const EPS18 = 0.01;
-    const bestCut = findBestCut(rx, ry, rw, rh, pieces, EPS18);
+    const EPS19 = 0.01;
+    const bestCut = findBestCut(rx, ry, rw, rh, pieces, EPS19);
     if (!bestCut) return;
     const { axis, pos, groupA, groupB } = bestCut;
     if (axis === "V") {
@@ -80921,6 +81400,7 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       nurbsSurface,
       spline2d,
       spline3d,
+      Loft,
       loft,
       loftAlongSpine,
       sweep,
@@ -81462,8 +81942,8 @@ function findRuntime() {
 }
 
 // cli/check-api-contracts.ts
-var EPS14 = 1e-6;
-function approx(a, b, eps = EPS14) {
+var EPS15 = 1e-6;
+function approx(a, b, eps = EPS15) {
   return Math.abs(a - b) <= eps;
 }
 function expectClose(actual, expected, label) {
@@ -84760,14 +85240,14 @@ function formatMetrics(metrics) {
 }
 
 // cli/check-constraints.ts
-var EPS15 = 0.01;
+var EPS16 = 0.01;
 var ANGLE_EPS = 0.1;
 var _verbose = false;
 var _update = false;
-function approx2(a, b, eps = EPS15) {
+function approx2(a, b, eps = EPS16) {
   return Math.abs(a - b) <= eps;
 }
-function assertApprox(actual, expected, label, eps = EPS15) {
+function assertApprox(actual, expected, label, eps = EPS16) {
   assert4(
     approx2(actual, expected, eps),
     `${label}: expected ${expected.toFixed(4)}, got ${actual.toFixed(4)} (diff=${Math.abs(actual - expected).toFixed(6)})`
@@ -85030,7 +85510,7 @@ function testPointOnLine() {
   assertConverged(result, "pointOnLine");
   const pt = getPoint(result.definition, p2);
   assertApprox(pt.y, 0, "pointOnLine: y should be 0");
-  assert4(pt.x >= -EPS15 && pt.x <= 10 + EPS15, `pointOnLine: x=${pt.x} should be in [0, 10]`);
+  assert4(pt.x >= -EPS16 && pt.x <= 10 + EPS16, `pointOnLine: x=${pt.x} should be in [0, 10]`);
 }
 function testRightTriangle() {
   const s = constrainedSketch();
@@ -88451,6 +88931,7 @@ function buildInspectManifest({ options, result, scriptPath, projectRoot, emitte
       maxRootDistance: result.distance?.maxRootDistance ?? 0,
       components: result.distance?.components ?? [],
       objects: result.distance?.objects ?? [],
+      gapEdgeCount: result.distance?.gapEdgeCount ?? 0,
       gapEdges: result.distance?.gapEdges ?? [],
       connectivity: result.distance?.connectivity,
       warnings: result.distance?.warnings ?? [],
@@ -88465,6 +88946,7 @@ function buildInspectManifest({ options, result, scriptPath, projectRoot, emitte
       decode: "source objects are translucent ghost geometry; boolean intersection volumes use per-finding collisions[].color palette entries",
       method: result.collisions?.method,
       options: result.collisions?.options,
+      broadphase: result.collisions?.broadphase,
       style: result.collisions?.style,
       objectCount: result.collisions?.objectCount ?? 0,
       collisionCount: result.collisions?.collisionCount ?? 0,
@@ -91819,11 +92301,11 @@ import { execSync as execSync2 } from "child_process";
 
 // cli/check-text.ts
 import assert8 from "assert/strict";
-var EPS16 = 1e-3;
-function approx4(a, b, eps = EPS16) {
+var EPS17 = 1e-3;
+function approx4(a, b, eps = EPS17) {
   return Math.abs(a - b) <= eps;
 }
-function expectClose3(actual, expected, label, eps = EPS16) {
+function expectClose3(actual, expected, label, eps = EPS17) {
   assert8(approx4(actual, expected, eps), `${label}: expected ${expected}, got ${actual}`);
 }
 function bounds(sk) {
@@ -91878,7 +92360,7 @@ function checkTextWidth() {
     Math.abs(reported - w) < tolerance,
     `textWidth ${reported.toFixed(3)} should be close to sketch width ${w.toFixed(3)} within ${tolerance.toFixed(3)}`
   );
-  assert8(reported >= w - EPS16, `textWidth ${reported.toFixed(3)} should be >= sketch width ${w.toFixed(3)}`);
+  assert8(reported >= w - EPS17, `textWidth ${reported.toFixed(3)} should be >= sketch width ${w.toFixed(3)}`);
 }
 function checkHorizontalAlignment() {
   const left = text2d("CAD", { size: 10, align: "left" });
@@ -92516,8 +92998,8 @@ function formatAssemblyAuditMarkdown(report) {
 }
 
 // cli/check-transforms.ts
-var EPS17 = 1e-6;
-function approx5(a, b, eps = EPS17) {
+var EPS18 = 1e-6;
+function approx5(a, b, eps = EPS18) {
   return Math.abs(a - b) <= eps;
 }
 function assertVec(actual, expected, label) {
@@ -92943,7 +93425,7 @@ function testBevelGearTopSectionCircularity() {
   const topSlice = gear.slice(bb.max[2] - 1e-4).bounds();
   const spanX = topSlice.max[0] - topSlice.min[0];
   const spanY = topSlice.max[1] - topSlice.min[1];
-  assert9(spanX > EPS17 && spanY > EPS17, `Expected non-degenerate top slice, got spanX=${spanX}, spanY=${spanY}`);
+  assert9(spanX > EPS18 && spanY > EPS18, `Expected non-degenerate top slice, got spanX=${spanX}, spanY=${spanY}`);
   const aspect = spanY / spanX;
   assert9(aspect > 0.85 && aspect < 1.15, `Expected near-circular top slice, got spanX=${spanX}, spanY=${spanY}, aspect=${aspect}`);
 }
@@ -103020,7 +103502,7 @@ Available: ${available}`);
   return { visible, hidden, summary };
 }
 
-// cli/collision-inspection.ts
+// src/forge/inspection/collision.ts
 var DEFAULT_COLLISION_INSPECTION_OPTIONS = {
   minOverlapVolume: 0.1
 };
@@ -103084,6 +103566,51 @@ function bboxOverlaps(a, b) {
 function collisionId(a, b) {
   return `${a.id}__${b.id}`;
 }
+function estimateSweepPairCount(entries, axis) {
+  const ordered = entries.map((entry) => ({ min: entry.min[axis], max: entry.max[axis] })).sort((a, b) => a.min - b.min || a.max - b.max);
+  const endValues = ordered.map((entry) => entry.max).sort((a, b) => a - b);
+  let expired = 0;
+  let count = 0;
+  for (let seen = 0; seen < ordered.length; seen += 1) {
+    const currentMin = ordered[seen].min;
+    while (expired < seen && endValues[expired] <= currentMin) expired += 1;
+    count += seen - expired;
+  }
+  return count;
+}
+function chooseSweepAxis(entries) {
+  let bestAxis = 0;
+  let bestCount = estimateSweepPairCount(entries, bestAxis);
+  for (const axis of [1, 2]) {
+    const count = estimateSweepPairCount(entries, axis);
+    if (count < bestCount) {
+      bestAxis = axis;
+      bestCount = count;
+    }
+  }
+  return bestAxis;
+}
+function collectCandidatePairs(entries) {
+  if (entries.length < 2) return { pairs: [], bboxPairChecks: 0 };
+  const axis = chooseSweepAxis(entries);
+  const ordered = entries.map((entry, index) => ({ entry, index })).sort((a, b) => a.entry.min[axis] - b.entry.min[axis] || a.entry.max[axis] - b.entry.max[axis] || a.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((a, b) => a.sourceIndex - b.sourceIndex || a.targetIndex - b.targetIndex);
+  return { pairs, bboxPairChecks };
+}
 function serializeCollisionFinding(finding2) {
   return {
     index: finding2.index,
@@ -103104,32 +103631,30 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
   const warnings = [];
   const collisions = [];
   const preparedEntries = entries.map((entry) => prepareEntry2(entry));
-  for (let i = 0; i < preparedEntries.length; i += 1) {
-    for (let j = i + 1; j < preparedEntries.length; j += 1) {
-      const a = preparedEntries[i];
-      const b = preparedEntries[j];
-      if (!bboxOverlaps(a, b)) continue;
-      try {
-        const hit = a.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(a, b),
-          sourceIndex: i,
-          targetIndex: j,
-          sourceId: a.id,
-          targetId: b.id,
-          sourceName: a.name,
-          targetName: b.name,
-          overlapVolume,
-          shape: hit
-        });
-      } catch (err2) {
-        const message = err2 instanceof Error ? err2.message : String(err2);
-        warnings.push(`Could not boolean-test ${a.name} against ${b.name}: ${message}`);
-      }
+  const { pairs: candidatePairs, bboxPairChecks } = collectCandidatePairs(preparedEntries);
+  for (const pair of candidatePairs) {
+    const a = preparedEntries[pair.sourceIndex];
+    const b = preparedEntries[pair.targetIndex];
+    try {
+      const hit = a.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(a, b),
+        sourceIndex: pair.sourceIndex,
+        targetIndex: pair.targetIndex,
+        sourceId: a.id,
+        targetId: b.id,
+        sourceName: a.name,
+        targetName: b.name,
+        overlapVolume,
+        shape: hit
+      });
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : String(err2);
+      warnings.push(`Could not boolean-test ${a.name} against ${b.name}: ${message}`);
     }
   }
   const objects = preparedEntries.map((entry, index) => ({
@@ -103147,6 +103672,12 @@ function analyzeCollisionIntersections(entries, rawOptions = {}) {
   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,
@@ -103357,7 +103888,7 @@ function sampleWallThickness(mesh, triangleSamples, rawOptions) {
   };
 }
 
-// cli/physical-connectivity.ts
+// src/forge/inspection/physical-connectivity.ts
 var DEFAULT_PHYSICAL_CONNECTIVITY_OPTIONS = {
   contactTolerance: 0.05,
   minOverlapVolume: 0.1,
@@ -103443,7 +103974,7 @@ function bboxOverlapVolume(a, b) {
   }
   return volume;
 }
-function estimateSweepPairCount(entries, axis, tolerance) {
+function estimateSweepPairCount2(entries, axis, tolerance) {
   const ordered = entries.map((entry) => ({ min: entry.min[axis], max: entry.max[axis] })).sort((a, b) => a.min - b.min || a.max - b.max);
   const endValues = ordered.map((entry) => entry.max + tolerance).sort((a, b) => a - b);
   let expired = 0;
@@ -103455,11 +103986,11 @@ function estimateSweepPairCount(entries, axis, tolerance) {
   }
   return count;
 }
-function chooseSweepAxis(entries, tolerance) {
+function chooseSweepAxis2(entries, tolerance) {
   let bestAxis = 0;
-  let bestCount = estimateSweepPairCount(entries, bestAxis, tolerance);
+  let bestCount = estimateSweepPairCount2(entries, bestAxis, tolerance);
   for (const axis of [1, 2]) {
-    const count = estimateSweepPairCount(entries, axis, tolerance);
+    const count = estimateSweepPairCount2(entries, axis, tolerance);
     if (count < bestCount) {
       bestAxis = axis;
       bestCount = count;
@@ -103467,9 +103998,9 @@ function chooseSweepAxis(entries, tolerance) {
   }
   return bestAxis;
 }
-function collectCandidatePairs(entries, tolerance) {
+function collectCandidatePairs2(entries, tolerance) {
   if (entries.length < 2) return [];
-  const axis = chooseSweepAxis(entries, tolerance);
+  const axis = chooseSweepAxis2(entries, tolerance);
   const ordered = entries.map((entry, index) => ({ entry, index })).sort((a, b) => a.entry.min[axis] - b.entry.min[axis] || a.entry.max[axis] - b.entry.max[axis] || a.index - b.index);
   let active = [];
   const pairs = [];
@@ -103544,7 +104075,7 @@ function analyzePhysicalConnectivity2(entries, rawOptions = {}) {
   const warnings = [];
   const edges = [];
   const unionFind = new UnionFind2(entries.length);
-  for (const pair of collectCandidatePairs(entries, options.contactTolerance)) {
+  for (const pair of collectCandidatePairs2(entries, options.contactTolerance)) {
     const i = pair.sourceIndex;
     const j = pair.targetIndex;
     const a = entries[i];