forgecad 0.9.5 → 0.9.6

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

@@ -721,7 +721,7 @@ function cloneSdfNode(node) {
   }
 }
 const SHEET_METAL_EDGES = ["top", "right", "bottom", "left"];
-const EPS$c = 1e-9;
+const EPS$d = 1e-9;
 function isFinitePositive$3(value) {
   return Number.isFinite(value) && value > 0;
 }
@@ -762,7 +762,7 @@ function edgeDisplayName(edge) {
   return `sheetMetal().flange("${edge}", ...)`;
 }
 function normalizeAngle(angleDeg) {
-  return Math.abs(angleDeg) <= EPS$c ? 0 : angleDeg;
+  return Math.abs(angleDeg) <= EPS$d ? 0 : angleDeg;
 }
 function validateSheetMetalModel(model) {
   if (!isFinitePositive$3(model.panel.width) || !isFinitePositive$3(model.panel.height)) {
@@ -774,7 +774,7 @@ function validateSheetMetalModel(model) {
   if (!isFiniteNonNegative(model.bendRadius)) {
     return "sheetMetal() requires a finite non-negative bendRadius.";
   }
-  if (model.bendRadius <= EPS$c) {
+  if (model.bendRadius <= EPS$d) {
     return "sheetMetal() v1 requires a positive bendRadius so the bend region stays explicit instead of collapsing into a sharp fold.";
   }
   if (model.bendAllowance.kind !== "k-factor") {
@@ -836,7 +836,7 @@ function deriveSheetMetalModel(model) {
     const trimEnd = flanges.has(adjacent.end) ? model.cornerRelief.size : 0;
     const fullLength = edge === "top" || edge === "bottom" ? model.panel.width : model.panel.height;
     const span = fullLength - trimStart - trimEnd;
-    if (!(span > EPS$c)) {
+    if (!(span > EPS$d)) {
       throw new Error(
         `${edgeDisplayName(edge)} loses all usable span after applying the defended rectangular corner relief size ${model.cornerRelief.size}.`
       );
@@ -894,7 +894,7 @@ function transformPlacement(origin, u2, v, normal) {
   };
 }
 function translatePlan(plan, x2, y2, z2) {
-  if (Math.abs(x2) <= EPS$c && Math.abs(y2) <= EPS$c && Math.abs(z2) <= EPS$c) return cloneShapeCompilePlan(plan);
+  if (Math.abs(x2) <= EPS$d && Math.abs(y2) <= EPS$d && Math.abs(z2) <= EPS$d) return cloneShapeCompilePlan(plan);
   return appendShapeCompileTransform(cloneShapeCompilePlan(plan), {
     kind: "translate",
     x: x2,
@@ -1338,7 +1338,7 @@ function cloneShapeWorkplanePlacement(placement) {
     placement: cloneSketchPlacementModel(placement.placement)
   };
 }
-const EPS$b = 1e-10;
+const EPS$c = 1e-10;
 function subVec3(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
@@ -1364,7 +1364,7 @@ function projectRadial(v, axis) {
 function signedAngleAroundAxis(from, to, axis) {
   const fromLen = lengthVec3$1(from);
   const toLen = lengthVec3$1(to);
-  if (fromLen < EPS$b || toLen < EPS$b) return 0;
+  if (fromLen < EPS$c || toLen < EPS$c) return 0;
   const fn = scaleVec3(from, 1 / fromLen);
   const tn = scaleVec3(to, 1 / toLen);
   const sin2 = dotVec3$4(axis, crossVec3$2(fn, tn));
@@ -1385,19 +1385,19 @@ function solveRotateAroundAngle(axis, pivot, movingPoint, targetPoint, options =
   const targetDecomp = projectRadial(target, unitAxis);
   const movingRadialLen = lengthVec3$1(movingDecomp.radial);
   const targetRadialLen = lengthVec3$1(targetDecomp.radial);
-  if (movingRadialLen < EPS$b) {
-    if (mode === "line" && targetRadialLen >= EPS$b) {
+  if (movingRadialLen < EPS$c) {
+    if (mode === "line" && targetRadialLen >= EPS$c) {
       throw new Error("rotateAroundTo(...): moving point lies on the rotation axis, so line alignment is impossible");
     }
     return 0;
   }
   if (mode === "plane") {
-    if (targetRadialLen < EPS$b) {
+    if (targetRadialLen < EPS$c) {
       throw new Error("rotateAroundTo(...): target point lies on the rotation axis, so the target plane is undefined");
     }
     return signedAngleAroundAxis(movingDecomp.radial, targetDecomp.radial, unitAxis);
   }
-  if (targetRadialLen < EPS$b) {
+  if (targetRadialLen < EPS$c) {
     throw new Error("rotateAroundTo(...): target line lies on the rotation axis, but the moving point does not");
   }
   const axialTol = 1e-8 * Math.max(1, Math.abs(movingDecomp.axial), Math.abs(targetDecomp.axial));
@@ -1437,7 +1437,7 @@ function multiplyMat4(a2, b) {
 }
 function normalizeVec3$5(v) {
   const len2 = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-  if (len2 < EPS$b) throw new Error("Axis must be non-zero");
+  if (len2 < EPS$c) throw new Error("Axis must be non-zero");
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function transformPoint$1(m2, p2, w2) {
@@ -1467,7 +1467,7 @@ function invertMat4(m2) {
   const b10 = a21 * a33 - a23 * a31;
   const b11 = a22 * a33 - a23 * a32;
   const det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
-  if (Math.abs(det) < EPS$b) throw new Error("Transform matrix is not invertible");
+  if (Math.abs(det) < EPS$c) throw new Error("Transform matrix is not invertible");
   const invDet = 1 / det;
   out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * invDet;
   out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * invDet;
@@ -3224,14 +3224,14 @@ function sweepPathToPolylineAdaptive(path2, baseSamples = 48) {
   pts.push(evalPathAt(path2, 1));
   return pts;
 }
-const EPS$a = 1e-8;
+const EPS$b = 1e-8;
 const SUPPORTED_VERTICAL_EDGE_NAMES = ["vert-bl", "vert-br", "vert-tr", "vert-tl"];
 function midpoint$4(start, end) {
   return [(start[0] + end[0]) * 0.5, (start[1] + end[1]) * 0.5, (start[2] + end[2]) * 0.5];
 }
 function normalize$7(v) {
   const len2 = Math.hypot(v[0], v[1], v[2]);
-  if (len2 <= EPS$a) throw new Error("Edge feature selection requires a non-zero direction vector");
+  if (len2 <= EPS$b) throw new Error("Edge feature selection requires a non-zero direction vector");
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function subtract(a2, b) {
@@ -3313,7 +3313,7 @@ function rigidTransformForEdgeStep(step) {
     case "mirror": {
       const [nx0, ny0, nz0] = [step.normalX, step.normalY, step.normalZ];
       const len2 = Math.hypot(nx0, ny0, nz0);
-      if (len2 <= EPS$a) return Transform.identity();
+      if (len2 <= EPS$b) return Transform.identity();
       const nx = nx0 / len2;
       const ny = ny0 / len2;
       const nz = nz0 / len2;
@@ -3624,7 +3624,7 @@ function isRectangleProfile(points) {
     return [next[0] - point2[0], next[1] - point2[1]];
   });
   const lengths2 = vectors.map(([x2, y2]) => Math.hypot(x2, y2));
-  if (lengths2.some((length4) => length4 <= EPS$a)) return false;
+  if (lengths2.some((length4) => length4 <= EPS$b)) return false;
   const dot01 = vectors[0][0] * vectors[1][0] + vectors[0][1] * vectors[1][1];
   const dot12 = vectors[1][0] * vectors[2][0] + vectors[1][1] * vectors[2][1];
   const dot23 = vectors[2][0] * vectors[3][0] + vectors[2][1] * vectors[3][1];
@@ -5691,13 +5691,13 @@ function parseMeshFile(data, format) {
       return parse3mf(data);
   }
 }
-const EPS$9 = 1e-8;
+const EPS$a = 1e-8;
 function length$3(v) {
   return Math.hypot(v[0], v[1], v[2]);
 }
 function normalize$6(v) {
   const len2 = length$3(v);
-  if (len2 < EPS$9) throw new Error("Plane normal must be non-zero");
+  if (len2 < EPS$a) throw new Error("Plane normal must be non-zero");
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function resolvePlaneOriginNormal(plane) {
@@ -5719,12 +5719,12 @@ function resolvePlaneOriginNormal(plane) {
 function rotationToPlaneSpace(normal) {
   const n = normalize$6(normal);
   const dot2 = n[2];
-  if (dot2 > 1 - EPS$9) {
+  if (dot2 > 1 - EPS$a) {
     return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
   }
   let axis;
   let angle;
-  if (dot2 < -1 + EPS$9) {
+  if (dot2 < -1 + EPS$a) {
     axis = [1, 0, 0];
     angle = Math.PI;
   } else {
@@ -8286,7 +8286,7 @@ function scale$6(v, s) {
 function sub$7(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
-function cross$7(a2, b) {
+function cross$8(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
 function makeEdge(name, start, end, faceName, curve) {
@@ -8322,7 +8322,7 @@ function buildSurfaceSheetTopology(boundaries, options = {}) {
   const center = options.center ?? average$1(corners);
   const uAxis = normalizeAxis$1(sub$7(midpoint$3(u1Start, u1End), midpoint$3(u0Start, u0End)));
   const vAxis = normalizeAxis$1(sub$7(midpoint$3(v1Start, v1End), midpoint$3(v0Start, v0End)));
-  const normal = normalizeAxis$1(options.normal ?? cross$7(uAxis, vAxis));
+  const normal = normalizeAxis$1(options.normal ?? cross$8(uAxis, vAxis));
   const faces = /* @__PURE__ */ new Map();
   faces.set(faceName, {
     name: faceName,
@@ -10224,6 +10224,7 @@ function buildSweepLevelSetInput(profilePolygons, pathInput, options) {
     edgeLength: options.edgeLength
   };
 }
+const EPS$9 = 1e-9;
 function resamplePolygon(poly, targetCount) {
   if (poly.length < 2) return poly;
   if (targetCount <= 0) return [];
@@ -10261,6 +10262,78 @@ function resamplePolygon(poly, targetCount) {
   }
   return out;
 }
+function resamplePolygonByAngle(poly, targetCount, center = polygonCentroid$2(poly)) {
+  if (poly.length < 3 || targetCount <= 0) return null;
+  if (!isConvexPolygon(poly)) return null;
+  const out = [];
+  for (let index2 = 0; index2 < targetCount; index2 += 1) {
+    const angle = index2 / targetCount * Math.PI * 2;
+    const point2 = rayPolygonIntersection(center, [Math.cos(angle), Math.sin(angle)], poly);
+    if (!point2) return null;
+    out.push(point2);
+  }
+  return out;
+}
+function rayPolygonIntersection(origin, direction2, poly) {
+  let bestT = Infinity;
+  let best = null;
+  for (let index2 = 0; index2 < poly.length; index2 += 1) {
+    const a2 = poly[index2];
+    const b = poly[(index2 + 1) % poly.length];
+    const edge = [b[0] - a2[0], b[1] - a2[1]];
+    const denom = cross$7(direction2, edge);
+    if (Math.abs(denom) < EPS$9) continue;
+    const delta = [a2[0] - origin[0], a2[1] - origin[1]];
+    const rayT = cross$7(delta, edge) / denom;
+    const edgeT = cross$7(delta, direction2) / denom;
+    if (rayT >= -EPS$9 && edgeT >= -EPS$9 && edgeT <= 1 + EPS$9 && rayT < bestT) {
+      bestT = rayT;
+      best = [origin[0] + direction2[0] * rayT, origin[1] + direction2[1] * rayT];
+    }
+  }
+  return best;
+}
+function polygonCentroid$2(poly) {
+  let area2 = 0;
+  let cx = 0;
+  let cy = 0;
+  for (let index2 = 0; index2 < poly.length; index2 += 1) {
+    const a2 = poly[index2];
+    const b = poly[(index2 + 1) % poly.length];
+    const crossValue = cross$7(a2, b);
+    area2 += crossValue;
+    cx += (a2[0] + b[0]) * crossValue;
+    cy += (a2[1] + b[1]) * crossValue;
+  }
+  if (Math.abs(area2) < EPS$9) return averagePoint(poly);
+  return [cx / (3 * area2), cy / (3 * area2)];
+}
+function averagePoint(poly) {
+  let x2 = 0;
+  let y2 = 0;
+  for (const point2 of poly) {
+    x2 += point2[0];
+    y2 += point2[1];
+  }
+  return [x2 / poly.length, y2 / poly.length];
+}
+function isConvexPolygon(poly) {
+  let sign2 = 0;
+  for (let index2 = 0; index2 < poly.length; index2 += 1) {
+    const a2 = poly[index2];
+    const b = poly[(index2 + 1) % poly.length];
+    const c2 = poly[(index2 + 2) % poly.length];
+    const turn = cross$7([b[0] - a2[0], b[1] - a2[1]], [c2[0] - b[0], c2[1] - b[1]]);
+    if (Math.abs(turn) < EPS$9) continue;
+    const currentSign = Math.sign(turn);
+    if (sign2 !== 0 && currentSign !== sign2) return false;
+    sign2 = currentSign;
+  }
+  return sign2 !== 0;
+}
+function cross$7(a2, b) {
+  return a2[0] * b[1] - a2[1] * b[0];
+}
 function loftStitched(profiles2, heights, wasm) {
   if (profiles2.length < 2) return null;
   const classified = profiles2.map((loops) => classifyLoops(loops));
@@ -10389,8 +10462,10 @@ function stitchSingleLoopLoft(loops, heights, wasm) {
     maxPoints = Math.max(maxPoints, loop.length);
   }
   const N = Math.max(maxPoints, 24);
+  const angularSamples = normalizedLoops.map((loop) => resamplePolygonByAngle(loop, N));
+  const useAngularSamples = angularSamples.every((samples) => samples != null);
   const resampled = normalizedLoops.map((loop, i) => {
-    const pts2d = resamplePolygon(loop, N);
+    const pts2d = useAngularSamples ? angularSamples[i] : resamplePolygon(loop, N);
     const z2 = heights[i];
     return pts2d.map(([x2, y2]) => [x2, y2, z2]);
   });
@@ -10451,7 +10526,7 @@ let _wasm$1 = null;
 async function initManifoldWasm() {
   if (_wasm$1) return _wasm$1;
   performance.mark("manifold:start");
-  const Module = (await import("./manifold-Cjk7WhRs.js")).default;
+  const Module = (await import("./manifold-B9QSr-qP.js")).default;
   performance.mark("manifold:imported");
   const wasm = await Module();
   wasm.setup();
@@ -47289,10 +47364,8 @@ class PathBuilder {
     if (radius <= 0) throw new Error("fillet: radius must be positive");
     const n = this.segs.length;
     if (n < 2) throw new Error("fillet: need at least 2 segments before a fillet");
-    const prev = this.segs[n - 2];
     const curr = this.segs[n - 1];
-    curr.kind === "line" || curr.kind === "move" ? prev.kind === "line" || prev.kind === "move" ? 0 : 0 : 0;
-    const { trimA, trimB, arcSeg } = this.computeFilletGeom(radius);
+    const { trimA, arcSeg } = this.computeFilletGeom(radius);
     if (!arcSeg) throw new Error("fillet: cannot fillet these segments (parallel or degenerate)");
     this.trimLastSegEnd(n - 2, trimA[0], trimA[1]);
     const trimmedSeg = { ...curr };
@@ -47364,7 +47437,6 @@ class PathBuilder {
   }
   getSegDirAt(seg, which) {
     if (seg.kind === "line" || seg.kind === "move") {
-      this.segs.length;
       const idx = this.segs.indexOf(seg);
       if (seg.kind === "line") {
         let sx, sy;
@@ -47606,6 +47678,41 @@ class PathBuilder {
     }
     return pts;
   }
+  /**
+   * Return the open path as a sampled 2D polyline.
+   *
+   * This is for construction geometry such as guide rails, measured centerlines,
+   * and curve-driven helpers where the authored path should stay open instead of
+   * becoming a filled sketch or stroked profile.
+   *
+   * **Example**
+   *
+   * ```ts
+   * const rail = path()
+   *   .moveTo(24, 0)
+   *   .bezierTo(32, 44, 28, 92, 18, 120)
+   *   .toPolyline();
+   * ```
+   *
+   * @returns A sampled open polyline.
+   * @category Path Builder
+   */
+  toPolyline() {
+    const moveCount = this.segs.filter((seg) => seg.kind === "move").length;
+    if (moveCount > 1) {
+      throw new Error("path().toPolyline() supports one continuous open path. Use separate path() builders for separate rails.");
+    }
+    const pts = [];
+    for (const point2 of this.tessellate()) {
+      if (!point2.every(Number.isFinite)) throw new Error("path().toPolyline() produced a non-finite point");
+      const previous = pts[pts.length - 1];
+      if (!previous || Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-9) {
+        pts.push(point2);
+      }
+    }
+    if (pts.length < 2) throw new Error("path().toPolyline() needs at least 2 points");
+    return pts;
+  }
   // ── Output ────────────────────────────────────────────────────────────────
   /**
    * Close the path and return a filled `Sketch`.
@@ -52378,7 +52485,7 @@ function requireFinite$7(value, label) {
   }
   return value;
 }
-function requireVec3$2(value, label) {
+function requireVec3$3(value, label) {
   if (!Array.isArray(value) || value.length !== 3) {
     throw new Error(`${label} must be [x, y, z]`);
   }
@@ -52422,7 +52529,7 @@ function normalizeOptions(options) {
     out.size = requireFinite$7(options.size, "Viewport.label options.size");
     if (out.size <= 0) throw new Error("Viewport.label options.size must be positive");
   }
-  if (options.offset !== void 0) out.offset = requireVec3$2(options.offset, "Viewport.label options.offset");
+  if (options.offset !== void 0) out.offset = requireVec3$3(options.offset, "Viewport.label options.offset");
   if (options.anchor !== void 0) {
     if (!VALID_ANCHORS.has(options.anchor)) {
       throw new Error(`Viewport.label options.anchor must be one of: ${Array.from(VALID_ANCHORS).join(", ")}`);
@@ -52439,7 +52546,7 @@ function collectRenderLabel(text, at, options) {
   if (typeof text !== "string" || text.trim().length === 0) {
     throw new Error("Viewport.label text must be a non-empty string");
   }
-  const normalizedAt = requireVec3$2(at, "Viewport.label at");
+  const normalizedAt = requireVec3$3(at, "Viewport.label at");
   const normalizedOptions = normalizeOptions(options);
   _collected$4.push({
     id: `render-label-${_nextId++}`,
@@ -52634,7 +52741,7 @@ function requireFinite$6(value, label) {
   }
   return value;
 }
-function requireVec3$1(value, label) {
+function requireVec3$2(value, label) {
   if (!Array.isArray(value) || value.length !== 3) {
     throw new Error(`${label} must be [x, y, z]`);
   }
@@ -52662,9 +52769,9 @@ const VALID_ENVIRONMENT_PRESETS = /* @__PURE__ */ new Set([
 ]);
 function validateCamera(cam, label) {
   const out = {};
-  if (cam.position !== void 0) out.position = requireVec3$1(cam.position, `${label}.position`);
-  if (cam.target !== void 0) out.target = requireVec3$1(cam.target, `${label}.target`);
-  if (cam.up !== void 0) out.up = requireVec3$1(cam.up, `${label}.up`);
+  if (cam.position !== void 0) out.position = requireVec3$2(cam.position, `${label}.position`);
+  if (cam.target !== void 0) out.target = requireVec3$2(cam.target, `${label}.target`);
+  if (cam.up !== void 0) out.up = requireVec3$2(cam.up, `${label}.up`);
   if (cam.fov !== void 0) {
     out.fov = requireFinite$6(cam.fov, `${label}.fov`);
     if (out.fov <= 0 || out.fov >= 180) throw new Error(`${label}.fov must be between 0 and 180`);
@@ -52799,8 +52906,8 @@ function validateLight(light, label) {
   const out = { type: light.type };
   if (light.color !== void 0) out.color = requireColor(light.color, `${label}.color`);
   if (light.intensity !== void 0) out.intensity = requireFinite$6(light.intensity, `${label}.intensity`);
-  if (light.position !== void 0) out.position = requireVec3$1(light.position, `${label}.position`);
-  if (light.target !== void 0) out.target = requireVec3$1(light.target, `${label}.target`);
+  if (light.position !== void 0) out.position = requireVec3$2(light.position, `${label}.position`);
+  if (light.target !== void 0) out.target = requireVec3$2(light.target, `${label}.target`);
   if (light.groundColor !== void 0) out.groundColor = requireColor(light.groundColor, `${label}.groundColor`);
   if (light.skyColor !== void 0) out.skyColor = requireColor(light.skyColor, `${label}.skyColor`);
   if (light.angle !== void 0) out.angle = requireFinite$6(light.angle, `${label}.angle`);
@@ -54332,7 +54439,7 @@ function scale$1(v, s) {
 function dot$2(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
-function lerp$2(a2, b, t) {
+function lerp$4(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function frameMatrix$1(x2, y2, z2, p2) {
@@ -54343,7 +54450,7 @@ function axisVector(axis, sign2 = 1) {
   if (axis === "Y") return [0, sign2, 0];
   return [0, 0, sign2];
 }
-function axisPosition(axis, point2) {
+function axisPosition$1(axis, point2) {
   return point2[AXIS_INDEX[axis]];
 }
 function crossPointForStation(axis, point2) {
@@ -54351,7 +54458,7 @@ function crossPointForStation(axis, point2) {
   if (axis === "Y") return [point2[0], -point2[2]];
   return [point2[1], point2[2]];
 }
-function orientLoftToAxis(shape, axis) {
+function orientLoftToAxis$1(shape, axis) {
   if (axis === "Z") return shape;
   if (axis === "Y") return shape.rotateX(-90);
   return shape.transform([0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1]);
@@ -54408,9 +54515,9 @@ function interpolateQuery(a2, b, t) {
   }
   return {
     side: sideA,
-    u: lerp$2(a2.u ?? 0.5, b.u ?? 0.5, t),
-    v: lerp$2(a2.v ?? 0.5, b.v ?? 0.5, t),
-    offset: lerp$2(a2.offset ?? 0, b.offset ?? 0, t)
+    u: lerp$4(a2.u ?? 0.5, b.u ?? 0.5, t),
+    v: lerp$4(a2.v ?? 0.5, b.v ?? 0.5, t),
+    offset: lerp$4(a2.offset ?? 0, b.offset ?? 0, t)
   };
 }
 function resolvePathQueries(points) {
@@ -54477,8 +54584,8 @@ class ProductSkin {
     this.stations = stations;
     this.rails = rails;
     for (const [name2, query] of Object.entries(refs)) this.refQueries.set(name2, cloneQuery(query));
-    this.axisMin = Math.min(...stations.map((station) => axisPosition(axis, station.center)));
-    this.axisMax = Math.max(...stations.map((station) => axisPosition(axis, station.center)));
+    this.axisMin = Math.min(...stations.map((station) => axisPosition$1(axis, station.center)));
+    this.axisMax = Math.max(...stations.map((station) => axisPosition$1(axis, station.center)));
     this.diagnosticsValue = {
       ...diagnostics,
       stationNames: stations.map((station) => station.name),
@@ -54535,24 +54642,24 @@ class ProductSkin {
   }
   /** Interpolate center, width, and depth at a normalized v or absolute axis value. */
   stationAt(vOrAxis) {
-    const axisValue = vOrAxis >= 0 && vOrAxis <= 1 ? lerp$2(this.axisMin, this.axisMax, vOrAxis) : clamp$5(vOrAxis, this.axisMin, this.axisMax);
+    const axisValue = vOrAxis >= 0 && vOrAxis <= 1 ? lerp$4(this.axisMin, this.axisMax, vOrAxis) : clamp$5(vOrAxis, this.axisMin, this.axisMax);
     const sorted = this.stations;
     for (let index2 = 0; index2 < sorted.length - 1; index2 += 1) {
       const a2 = sorted[index2];
       const b = sorted[index2 + 1];
-      const aAxis = axisPosition(this.axis, a2.center);
-      const bAxis = axisPosition(this.axis, b.center);
+      const aAxis = axisPosition$1(this.axis, a2.center);
+      const bAxis = axisPosition$1(this.axis, b.center);
       if (axisValue < aAxis - EPS$5 || axisValue > bAxis + EPS$5) continue;
       const span = Math.max(EPS$5, bAxis - aAxis);
       const t = clamp$5((axisValue - aAxis) / span, 0, 1);
       return {
         axisValue,
-        center: [lerp$2(a2.center[0], b.center[0], t), lerp$2(a2.center[1], b.center[1], t), lerp$2(a2.center[2], b.center[2], t)],
-        width: lerp$2(a2.profile.width, b.profile.width, t),
-        depth: lerp$2(a2.profile.depth, b.profile.depth, t),
+        center: [lerp$4(a2.center[0], b.center[0], t), lerp$4(a2.center[1], b.center[1], t), lerp$4(a2.center[2], b.center[2], t)],
+        width: lerp$4(a2.profile.width, b.profile.width, t),
+        depth: lerp$4(a2.profile.depth, b.profile.depth, t),
         dWidth: (b.profile.width - a2.profile.width) / span,
         dDepth: (b.profile.depth - a2.profile.depth) / span,
-        exponent: lerp$2(profileExponent(a2), profileExponent(b), t),
+        exponent: lerp$4(profileExponent(a2), profileExponent(b), t),
         kind: a2.profile.kind === b.profile.kind ? a2.profile.kind : "custom"
       };
     }
@@ -54674,7 +54781,7 @@ class ProductSkinBuilder {
   }
   /** Set named cross-section stations for the product skin. */
   stations(stations) {
-    this.stationsValue = stations.map(toStationSpec).sort((a2, b) => axisPosition(this.axisValue, a2.center) - axisPosition(this.axisValue, b.center));
+    this.stationsValue = stations.map(toStationSpec).sort((a2, b) => axisPosition$1(this.axisValue, a2.center) - axisPosition$1(this.axisValue, b.center));
     return this;
   }
   /** Attach named guide rails for product-skin construction and downstream surface references. */
@@ -54724,9 +54831,9 @@ class ProductSkinBuilder {
       const [x2, y2] = crossPointForStation(this.axisValue, station.center);
       return station.profile.sketch.translate(x2, y2);
     });
-    const heights = this.stationsValue.map((station) => axisPosition(this.axisValue, station.center));
+    const heights = this.stationsValue.map((station) => axisPosition$1(this.axisValue, station.center));
     let shape = loft(localProfiles, heights, { edgeLength: this.edgeLengthValue });
-    shape = orientLoftToAxis(shape, this.axisValue);
+    shape = orientLoftToAxis$1(shape, this.axisValue);
     if (this.colorValue) shape = shape.color(this.colorValue);
     shape = applyMaterial(shape, this.materialValue).as(this.name);
     const warnings = [];
@@ -55385,7 +55492,7 @@ function requirePositive$3(value, label) {
 function clamp$4(value, min2, max2) {
   return Math.max(min2, Math.min(max2, value));
 }
-function lerp$1(a2, b, t) {
+function lerp$3(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function add(a2, b) {
@@ -55435,19 +55542,19 @@ function transformLocal(point2, tangentAcross, normal, tangentAlong, x2, y2, z2
 function interpolateCylinder(a2, b, t, mode) {
   let delta = b.angle - a2.angle;
   if (mode === "shortest" && Math.abs(delta) > 180) delta -= Math.sign(delta) * 360;
-  return { kind: "cylinder", angle: a2.angle + delta * t, z: lerp$1(a2.z, b.z, t), offset: lerp$1(a2.offset ?? 0, b.offset ?? 0, t) };
+  return { kind: "cylinder", angle: a2.angle + delta * t, z: lerp$3(a2.z, b.z, t), offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t) };
 }
 function interpolatePlane(a2, b, t) {
-  return { kind: "plane", x: lerp$1(a2.x, b.x, t), y: lerp$1(a2.y, b.y, t), offset: lerp$1(a2.offset ?? 0, b.offset ?? 0, t) };
+  return { kind: "plane", x: lerp$3(a2.x, b.x, t), y: lerp$3(a2.y, b.y, t), offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t) };
 }
 function interpolateProductSkin(a2, b, t) {
   if ((a2.side ?? b.side) !== (b.side ?? a2.side)) throw new Error("SurfacePath on ProductSkin currently supports one side per path; split side transitions into separate members.");
   return {
     kind: "productSkin",
     side: a2.side ?? b.side,
-    u: lerp$1(a2.u ?? 0.5, b.u ?? 0.5, t),
-    v: lerp$1(a2.v ?? 0.5, b.v ?? 0.5, t),
-    offset: lerp$1(a2.offset ?? 0, b.offset ?? 0, t)
+    u: lerp$3(a2.u ?? 0.5, b.u ?? 0.5, t),
+    v: lerp$3(a2.v ?? 0.5, b.v ?? 0.5, t),
+    offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t)
   };
 }
 class SurfacePath {
@@ -55770,11 +55877,11 @@ function coordinateOnSide(coordinate, side, label) {
   return { ...coordinate, kind: "productSkin", side };
 }
 class ProductSkinCarrier {
-  constructor(skin, name = skin.name, sideValue, offsetValue = 0) {
+  constructor(skin, name = skin.name, sideValue2, offsetValue = 0) {
     __publicField(this, "kind", "productSkin");
     this.skin = skin;
     this.name = name;
-    this.sideValue = sideValue;
+    this.sideValue = sideValue2;
     this.offsetValue = offsetValue;
   }
   surface(side) {
@@ -56545,7 +56652,7 @@ function counterboresForPlate(spec2, width, height, thickness, diagnostics) {
 function minWidthAcrossAlongRange(widthAtT, length4, minAlong, maxAlong) {
   let minWidth = Number.POSITIVE_INFINITY;
   for (let index2 = 0; index2 <= 8; index2 += 1) {
-    const along = lerp$1(minAlong, maxAlong, index2 / 8);
+    const along = lerp$3(minAlong, maxAlong, index2 / 8);
     const t = Math.max(0, Math.min(1, (along + length4 / 2) / Math.max(length4, 1e-8)));
     minWidth = Math.min(minWidth, widthAtT(t));
   }
@@ -56845,7 +56952,7 @@ function pathParameterAtDistance(samples, distance2) {
     const segmentLength = Math.hypot(b.point[0] - a2.point[0], b.point[1] - a2.point[1], b.point[2] - a2.point[2]);
     if (traveled + segmentLength >= distance2) {
       const localT = segmentLength <= 1e-8 ? 0 : (distance2 - traveled) / segmentLength;
-      return lerp$1(a2.t, b.t, localT);
+      return lerp$3(a2.t, b.t, localT);
     }
     traveled += segmentLength;
   }
@@ -56898,7 +57005,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex <= acrossSegments; acrossIndex += 1) {
-      const across = lerp$1(-width / 2, width / 2, acrossIndex / acrossSegments);
+      const across = lerp$3(-width / 2, width / 2, acrossIndex / acrossSegments);
       mesh.vertices.push(pointAtProfile([across, along], false));
     }
   }
@@ -56908,7 +57015,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex <= acrossSegments; acrossIndex += 1) {
-      const across = lerp$1(-width / 2, width / 2, acrossIndex / acrossSegments);
+      const across = lerp$3(-width / 2, width / 2, acrossIndex / acrossSegments);
       mesh.vertices.push(pointAtProfile([across, along], true));
     }
   }
@@ -56920,7 +57027,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex < acrossSegments; acrossIndex += 1) {
-      const across = lerp$1(-width / 2, width / 2, (acrossIndex + 0.5) / acrossSegments);
+      const across = lerp$3(-width / 2, width / 2, (acrossIndex + 0.5) / acrossSegments);
       filled[alongIndex][acrossIndex] = !holes.some((hole2) => pointInProfileLoop([across, along], hole2));
     }
   }
@@ -59002,7 +59109,7 @@ const Constraint = {
     return builder.constrain({ type: "length", line: resolveLineId(builder, line2), value });
   }
 };
-function requireVec3(v, label) {
+function requireVec3$1(v, label) {
   if (!Array.isArray(v) || v.length !== 3 || !Number.isFinite(v[0]) || !Number.isFinite(v[1]) || !Number.isFinite(v[2])) {
     throw new Error(`${label} must be a [number, number, number] with finite values, got ${JSON.stringify(v)}`);
   }
@@ -59015,24 +59122,24 @@ function requireFiniteNumber(n, label) {
   return n;
 }
 function distance$1(a2, b) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   return Math.hypot(b[0] - a2[0], b[1] - a2[1], b[2] - a2[2]);
 }
 function midpoint$1(a2, b) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   return [(a2[0] + b[0]) / 2, (a2[1] + b[1]) / 2, (a2[2] + b[2]) / 2];
 }
-function lerp(a2, b, t) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+function lerp$2(a2, b, t) {
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   requireFiniteNumber(t, "t");
   return [a2[0] + (b[0] - a2[0]) * t, a2[1] + (b[1] - a2[1]) * t, a2[2] + (b[2] - a2[2]) * t];
 }
 function direction(a2, b) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   const dx = b[0] - a2[0];
   const dy = b[1] - a2[1];
   const dz = b[2] - a2[2];
@@ -59043,8 +59150,8 @@ function direction(a2, b) {
   return [dx / len2, dy / len2, dz / len2];
 }
 function offset(point2, dir, amount) {
-  requireVec3(point2, "point");
-  requireVec3(dir, "dir");
+  requireVec3$1(point2, "point");
+  requireVec3$1(dir, "dir");
   requireFiniteNumber(amount, "amount");
   return [point2[0] + dir[0] * amount, point2[1] + dir[1] * amount, point2[2] + dir[2] * amount];
 }
@@ -59054,7 +59161,7 @@ const Points = {
   /** Center point between two 3D points. */
   midpoint: midpoint$1,
   /** Linearly interpolate between two 3D points. t=0 returns a, t=1 returns b. */
-  lerp,
+  lerp: lerp$2,
   /** Unit direction vector from a to b. Throws if a and b are the same point. */
   direction,
   /** Move a point along a direction vector by a given amount. */
@@ -64186,9 +64293,84 @@ class ConstraintSketch extends Sketch {
    * Select the single arrangement region that contains the given seed point.
    * Throws if no region contains the seed.
    */
-  detectArrangementRegion(seed) {
+  detectArrangementRegion(_seed) {
     throw new Error("Not implemented");
   }
+  /**
+   * Return the solved constrained path as a sampled 2D polyline.
+   *
+   * Use this when a construction rail was authored with `constrainedSketch()`
+   * and should feed another operation such as `Loft.pathOnXz(...)`.
+   * The sketch must contain exactly one profile path.
+   *
+   * @param samples - Samples per curved segment. Default 32.
+   * @returns The solved path as an open polyline.
+   */
+  toPolyline(samples = 32) {
+    if (!Number.isFinite(samples) || samples < 2) throw new Error("ConstraintSketch.toPolyline() samples must be at least 2");
+    const profileLoops = this.definition.loops.filter((loop) => loop.type === "profile");
+    if (profileLoops.length !== 1) {
+      throw new Error("ConstraintSketch.toPolyline() requires exactly one profile path");
+    }
+    const sampleCount = Math.max(2, Math.round(samples));
+    const pointMap = new Map(this.definition.points.map((point2) => [point2.id, point2]));
+    const lineMap = new Map(this.definition.lines.map((line2) => [line2.id, line2]));
+    const arcMap = new Map(this.definition.arcs.map((arc) => [arc.id, arc]));
+    const bezierMap = new Map(this.definition.beziers.map((bezier) => [bezier.id, bezier]));
+    const points = [];
+    const appendStart = (point2, label) => {
+      const previous = points[points.length - 1];
+      if (!previous) {
+        points.push(point2);
+        return;
+      }
+      if (Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-6) {
+        throw new Error(`ConstraintSketch.toPolyline() profile path is not continuous at ${label}`);
+      }
+    };
+    const appendPoint = (point2) => {
+      const previous = points[points.length - 1];
+      if (!previous || Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-9) points.push(point2);
+    };
+    const requirePoint = (id, label) => {
+      const point2 = pointMap.get(id);
+      if (!point2) throw new Error(`ConstraintSketch.toPolyline() missing ${label}`);
+      return [point2.x, point2.y];
+    };
+    for (const segment of profileLoops[0].segments) {
+      if (segment.kind === "line") {
+        const line2 = lineMap.get(segment.line);
+        if (!line2) throw new Error(`ConstraintSketch.toPolyline() missing line "${segment.line}"`);
+        appendStart(requirePoint(line2.a, `line "${segment.line}" start point`), `line "${segment.line}"`);
+        appendPoint(requirePoint(line2.b, `line "${segment.line}" end point`));
+      } else if (segment.kind === "arc") {
+        const arc = arcMap.get(segment.arc);
+        if (!arc) throw new Error(`ConstraintSketch.toPolyline() missing arc "${segment.arc}"`);
+        const center = requirePoint(arc.center, `arc "${segment.arc}" center point`);
+        const start = requirePoint(arc.start, `arc "${segment.arc}" start point`);
+        const end = requirePoint(arc.end, `arc "${segment.arc}" end point`);
+        appendStart(start, `arc "${segment.arc}"`);
+        const startAngle = Math.atan2(start[1] - center[1], start[0] - center[0]);
+        const endAngle = Math.atan2(end[1] - center[1], end[0] - center[0]);
+        for (const point2 of tessellateArc(center[0], center[1], arc.radius, startAngle, endAngle, arc.clockwise, sampleCount)) {
+          appendPoint(point2);
+        }
+      } else {
+        const bezier = bezierMap.get(segment.bezier);
+        if (!bezier) throw new Error(`ConstraintSketch.toPolyline() missing bezier "${segment.bezier}"`);
+        const p0 = requirePoint(bezier.p0, `bezier "${segment.bezier}" start point`);
+        const p1 = requirePoint(bezier.p1, `bezier "${segment.bezier}" first control point`);
+        const p2 = requirePoint(bezier.p2, `bezier "${segment.bezier}" second control point`);
+        const p3 = requirePoint(bezier.p3, `bezier "${segment.bezier}" end point`);
+        appendStart(p0, `bezier "${segment.bezier}"`);
+        for (const point2 of tessellateBezier(p0[0], p0[1], p1[0], p1[1], p2[0], p2[1], p3[0], p3[1], sampleCount)) {
+          appendPoint(point2);
+        }
+      }
+    }
+    if (points.length < 2) throw new Error("ConstraintSketch.toPolyline() needs at least 2 points");
+    return points;
+  }
   /**
    * Re-solve the sketch after changing the value of one existing constraint.
    *
@@ -79473,6 +79655,295 @@ function polygonVertices(sides, radius, options) {
     centerY: options == null ? void 0 : options.centerY
   });
 }
+const LOFT_GUIDE_EPS = 1e-8;
+function orientLoftToAxis(shape, axis) {
+  if (axis === "Z") return shape;
+  if (axis === "Y") return shape.rotateX(-90);
+  return shape.transform([0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1]);
+}
+function buildRailEvaluators(rails, axis, start, end, railSamples) {
+  const seen = /* @__PURE__ */ new Set();
+  return rails.map((rail2) => {
+    if (seen.has(rail2.side)) throw new Error(`Loft.withGuideRails() received more than one ${rail2.side} rail`);
+    seen.add(rail2.side);
+    const sampled = sampleRailPath(rail2.path, railSamples);
+    if (sampled.length < 2) throw new Error("Loft guide rails require at least two points");
+    const points = sampled.map((point2) => ({ position: axisPosition(axis, point2), cross: crossPointForAxis(axis, point2) }));
+    const ordered = points[points.length - 1].position >= points[0].position ? points : [...points].reverse();
+    validateRailCoverage(ordered, start, end);
+    return { side: rail2.side, points: ordered };
+  });
+}
+function railCrossAt(rail2, position) {
+  const points = rail2.points;
+  if (position <= points[0].position + LOFT_GUIDE_EPS) return points[0].cross;
+  const last = points[points.length - 1];
+  if (position >= last.position - LOFT_GUIDE_EPS) return last.cross;
+  for (let index2 = 0; index2 < points.length - 1; index2 += 1) {
+    const a2 = points[index2];
+    const b = points[index2 + 1];
+    if (position >= a2.position - LOFT_GUIDE_EPS && position <= b.position + LOFT_GUIDE_EPS) {
+      const t = (position - a2.position) / (b.position - a2.position);
+      return [lerp$1(a2.cross[0], b.cross[0], t), lerp$1(a2.cross[1], b.cross[1], t)];
+    }
+  }
+  throw new Error("Loft guide rail does not cover requested station position");
+}
+function validateRailCoverage(points, start, end) {
+  for (let index2 = 1; index2 < points.length; index2 += 1) {
+    if (points[index2].position - points[index2 - 1].position < LOFT_GUIDE_EPS) {
+      throw new Error("Loft guide rails must be monotone along the loft axis");
+    }
+  }
+  if (points[0].position - start > LOFT_GUIDE_EPS || end - points[points.length - 1].position > LOFT_GUIDE_EPS) {
+    throw new Error("Loft guide rails must cover the full station range");
+  }
+}
+function sampleRailPath(path2, samples) {
+  if (Array.isArray(path2)) return path2.map((point2, index2) => requireVec3(point2, `Loft guide rail point ${index2}`));
+  if (path2 instanceof Curve3D || path2 instanceof HermiteCurve3D || path2 instanceof QuinticHermiteCurve3D || path2 instanceof NurbsCurve3D) {
+    return path2.sample(Math.max(2, Math.round(samples))).map((point2, index2) => requireVec3(point2, `Loft guide rail sample ${index2}`));
+  }
+  throw new Error("Loft guide rail path must be a Vec3[] or ForgeCAD 3D curve");
+}
+function requireVec3(point2, label) {
+  if (!Array.isArray(point2) || point2.length !== 3 || !point2.every(Number.isFinite)) {
+    throw new Error(`${label} must be a finite [x, y, z] point`);
+  }
+  return [point2[0], point2[1], point2[2]];
+}
+function axisPosition(axis, point2) {
+  if (axis === "X") return point2[0];
+  if (axis === "Y") return point2[1];
+  return point2[2];
+}
+function crossPointForAxis(axis, point2) {
+  if (axis === "X") return [point2[1], point2[2]];
+  if (axis === "Y") return [point2[0], -point2[2]];
+  return [point2[0], point2[1]];
+}
+function lerp$1(a2, b, t) {
+  return a2 + (b - a2) * t;
+}
+function loftWithGuideRails(stations, rails, options = {}) {
+  if (stations.length < 2) throw new Error("Loft.withGuideRails() requires at least two stations");
+  if (rails.length === 0) throw new Error("Loft.withGuideRails() requires at least one guide rail");
+  const sortedStations = sortedValidStations(stations);
+  const axis = options.axis ?? "Z";
+  const start = sortedStations[0].position;
+  const end = sortedStations[sortedStations.length - 1].position;
+  const railEvaluators = buildRailEvaluators(rails, axis, start, end, options.railSamples ?? 64);
+  const positions = generatedPositions(sortedStations, options.samples);
+  const profiles2 = positions.map((position) => {
+    const source = profileForPosition(sortedStations, position);
+    const bounds = boundsForPosition(sortedStations, position);
+    return fitProfileToBounds(source, applyRailsToBounds(bounds, railEvaluators, position));
+  });
+  const shape = loft(profiles2, positions, {
+    edgeLength: options.edgeLength,
+    boundsPadding: options.boundsPadding
+  });
+  return orientLoftToAxis(shape, axis);
+}
+function sortedValidStations(stations) {
+  const sorted = [...stations].sort((a2, b) => a2.position - b.position);
+  for (let index2 = 0; index2 < sorted.length; index2 += 1) {
+    if (!Number.isFinite(sorted[index2].position)) throw new Error("Loft.withGuideRails station position must be finite");
+    if (!(sorted[index2].profile instanceof Sketch)) throw new Error("Loft.withGuideRails() stations must use Sketch profiles");
+    if (index2 > 0 && sorted[index2].position - sorted[index2 - 1].position < LOFT_GUIDE_EPS) {
+      throw new Error("Loft.withGuideRails() requires unique, strictly increasing station positions");
+    }
+  }
+  return sorted;
+}
+function generatedPositions(stations, samples) {
+  const count = Math.max(2, Math.round(samples ?? Math.max(9, (stations.length - 1) * 8 + 1)));
+  const start = stations[0].position;
+  const end = stations[stations.length - 1].position;
+  const values = /* @__PURE__ */ new Set();
+  const positions = [];
+  const addPosition = (position) => {
+    const key = position.toFixed(9);
+    if (!values.has(key)) {
+      values.add(key);
+      positions.push(position);
+    }
+  };
+  for (let index2 = 0; index2 < count; index2 += 1) addPosition(start + (end - start) * index2 / (count - 1));
+  for (const station of stations) addPosition(station.position);
+  return positions.sort((a2, b) => a2 - b);
+}
+function profileForPosition(stations, position) {
+  for (let index2 = 0; index2 < stations.length - 1; index2 += 1) {
+    if (position <= stations[index2 + 1].position + LOFT_GUIDE_EPS) return stations[index2].profile;
+  }
+  return stations[stations.length - 1].profile;
+}
+function boundsForPosition(stations, position) {
+  if (position <= stations[0].position + LOFT_GUIDE_EPS) return sketchBounds(stations[0].profile);
+  const last = stations[stations.length - 1];
+  if (position >= last.position - LOFT_GUIDE_EPS) return sketchBounds(last.profile);
+  for (let index2 = 0; index2 < stations.length - 1; index2 += 1) {
+    const a2 = stations[index2];
+    const b = stations[index2 + 1];
+    if (position >= a2.position - LOFT_GUIDE_EPS && position <= b.position + LOFT_GUIDE_EPS) {
+      return lerpBounds(sketchBounds(a2.profile), sketchBounds(b.profile), (position - a2.position) / (b.position - a2.position));
+    }
+  }
+  return sketchBounds(last.profile);
+}
+function applyRailsToBounds(bounds, rails, position) {
+  const centerRail = rails.find((rail2) => rail2.side === "center");
+  const center = centerRail ? railCrossAt(centerRail, position) : void 0;
+  const next = { ...bounds };
+  applyAxisRail(next, "X", sideValue(rails, "left", position, 0), sideValue(rails, "right", position, 0), center == null ? void 0 : center[0]);
+  applyAxisRail(next, "Y", sideValue(rails, "back", position, 1), sideValue(rails, "front", position, 1), center == null ? void 0 : center[1]);
+  if (next.maxX - next.minX < LOFT_GUIDE_EPS || next.maxY - next.minY < LOFT_GUIDE_EPS) {
+    throw new Error("Loft.withGuideRails() guide rails produced a non-positive section size");
+  }
+  return next;
+}
+function sideValue(rails, side, position, crossIndex) {
+  const rail2 = rails.find((entry) => entry.side === side);
+  return rail2 ? railCrossAt(rail2, position)[crossIndex] : void 0;
+}
+function applyAxisRail(bounds, axis, minRail, maxRail, center) {
+  const minKey = axis === "X" ? "minX" : "minY";
+  const maxKey = axis === "X" ? "maxX" : "maxY";
+  const width = bounds[maxKey] - bounds[minKey];
+  if (minRail != null && maxRail != null) {
+    if (maxRail - minRail < LOFT_GUIDE_EPS) throw new Error("Loft.withGuideRails() opposite guide rails crossed");
+    if (center != null && Math.abs((minRail + maxRail) / 2 - center) > 1e-5) {
+      throw new Error("Loft.withGuideRails() center rail conflicts with opposite side rails");
+    }
+    bounds[minKey] = minRail;
+    bounds[maxKey] = maxRail;
+  } else if (maxRail != null) {
+    bounds[maxKey] = maxRail;
+    bounds[minKey] = center != null ? 2 * center - maxRail : maxRail - width;
+  } else if (minRail != null) {
+    bounds[minKey] = minRail;
+    bounds[maxKey] = center != null ? 2 * center - minRail : minRail + width;
+  } else if (center != null) {
+    bounds[minKey] = center - width / 2;
+    bounds[maxKey] = center + width / 2;
+  }
+}
+function fitProfileToBounds(profile, target) {
+  const source = sketchBounds(profile);
+  const sourceWidth = source.maxX - source.minX;
+  const sourceDepth = source.maxY - source.minY;
+  if (sourceWidth < LOFT_GUIDE_EPS || sourceDepth < LOFT_GUIDE_EPS) {
+    throw new Error("Loft.withGuideRails() station profiles must have positive bounds");
+  }
+  const sourceCenter = [(source.minX + source.maxX) / 2, (source.minY + source.maxY) / 2];
+  const targetCenter = [(target.minX + target.maxX) / 2, (target.minY + target.maxY) / 2];
+  return profile.scaleAround(sourceCenter, [(target.maxX - target.minX) / sourceWidth, (target.maxY - target.minY) / sourceDepth]).translate(targetCenter[0] - sourceCenter[0], targetCenter[1] - sourceCenter[1]);
+}
+function sketchBounds(profile) {
+  const bounds = profile.bounds();
+  return { minX: bounds.min[0], maxX: bounds.max[0], minY: bounds.min[1], maxY: bounds.max[1] };
+}
+function lerpBounds(a2, b, t) {
+  return {
+    minX: lerp(a2.minX, b.minX, t),
+    maxX: lerp(a2.maxX, b.maxX, t),
+    minY: lerp(a2.minY, b.minY, t),
+    maxY: lerp(a2.maxY, b.maxY, t)
+  };
+}
+function lerp(a2, b, t) {
+  return a2 + (b - a2) * t;
+}
+function mapLoftPath2D(path2, label, mapper) {
+  const points = sampleLoftPath2D(path2, label);
+  return points.map((point2, index2) => {
+    if (!Array.isArray(point2) || point2.length !== 2 || !point2.every(Number.isFinite)) {
+      throw new Error(`${label} point ${index2} must be a finite [x, y] point`);
+    }
+    return mapper([point2[0], point2[1]]);
+  });
+}
+function sampleLoftPath2D(path2, label) {
+  if (Array.isArray(path2)) {
+    if (path2.length < 2) throw new Error(`${label} requires at least two [x, y] points`);
+    return path2;
+  }
+  if (!path2 || typeof path2 !== "object" || typeof path2.toPolyline !== "function") {
+    throw new Error(`${label} requires a 2D path, solved constrained path, or [x, y] point array`);
+  }
+  const points = path2.toPolyline();
+  if (!Array.isArray(points) || points.length < 2) throw new Error(`${label} path must produce at least two [x, y] points`);
+  return points;
+}
+const Loft = {
+  /** Create a loft station from a 2D profile and an axis position. */
+  station(profile, position) {
+    if (!Number.isFinite(position)) throw new Error("Loft.station position must be finite");
+    return { profile, position };
+  },
+  /** Create a guide rail that constrains the section-local negative-X side. */
+  leftRail(path2) {
+    return { side: "left", path: path2 };
+  },
+  /** Create a guide rail that constrains the section-local positive-X side. */
+  rightRail(path2) {
+    return { side: "right", path: path2 };
+  },
+  /** Create a guide rail that constrains the section-local positive-Y side. */
+  frontRail(path2) {
+    return { side: "front", path: path2 };
+  },
+  /** Create a guide rail that constrains the section-local negative-Y side. */
+  backRail(path2) {
+    return { side: "back", path: path2 };
+  },
+  /** Create a guide rail that moves section centers along the loft. */
+  centerRail(path2) {
+    return { side: "center", path: path2 };
+  },
+  /**
+   * Place a 2D guide path onto the XZ plane.
+   *
+   * The path's first coordinate becomes X and its second coordinate becomes Z.
+   * Use this for left/right silhouette rails authored with `path()` or `constrainedSketch()`.
+   */
+  pathOnXz(path2, y2 = 0) {
+    if (!Number.isFinite(y2)) throw new Error("Loft.pathOnXz y must be finite");
+    return mapLoftPath2D(path2, "Loft.pathOnXz", ([x2, z2]) => [x2, y2, z2]);
+  },
+  /**
+   * Place a 2D guide path onto the YZ plane.
+   *
+   * The path's first coordinate becomes Y and its second coordinate becomes Z.
+   * Use this for front/back crown rails authored with `path()` or `constrainedSketch()`.
+   */
+  pathOnYz(path2, x2 = 0) {
+    if (!Number.isFinite(x2)) throw new Error("Loft.pathOnYz x must be finite");
+    return mapLoftPath2D(path2, "Loft.pathOnYz", ([y2, z2]) => [x2, y2, z2]);
+  },
+  /**
+   * Place a 2D guide path onto the XY plane.
+   *
+   * The path's first coordinate becomes X and its second coordinate becomes Y.
+   * Use this when lofting along X or Y and a rail lives in a horizontal sketch plane.
+   */
+  pathOnXy(path2, z2 = 0) {
+    if (!Number.isFinite(z2)) throw new Error("Loft.pathOnXy z must be finite");
+    return mapLoftPath2D(path2, "Loft.pathOnXy", ([x2, y2]) => [x2, y2, z2]);
+  },
+  /**
+   * Loft through profile stations while forcing generated sections to follow guide rails.
+   *
+   * Stations define the cross-section family. Guide rails define the side or center
+   * paths the loft must pass through. With opposite side rails, the section is scaled
+   * to touch both rails. With one side rail, the section keeps its interpolated size
+   * unless a center rail is also present.
+   */
+  withGuideRails(stations, rails, options = {}) {
+    return loftWithGuideRails(stations, rails, options);
+  }
+};
 let collectedHighlights = [];
 function resetHighlights() {
   collectedHighlights = [];
@@ -296941,6 +297412,7 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       nurbsSurface,
       spline2d,
       spline3d,
+      Loft,
       loft,
       loftAlongSpine,
       sweep,