forgecad 0.10.4 → 0.10.5

package/dist/assets/{constructionHistoryWorker-cTHWRJEi.js → constructionHistoryWorker-uEe_Q7Kg.js}

@@ -118,7 +118,7 @@ function denormalize(value, array) {
       throw new Error("Invalid component type.");
   }
 }
-function normalize$4(value, array) {
+function normalize$5(value, array) {
   switch (array.constructor) {
     case Float32Array:
       return value;
@@ -1692,9 +1692,9 @@ class Quaternion {
       let s = 1 - t;
       const cos2 = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1, dir = cos2 >= 0 ? 1 : -1, sqrSin = 1 - cos2 * cos2;
       if (sqrSin > Number.EPSILON) {
-        const sin2 = Math.sqrt(sqrSin), len = Math.atan2(sin2, cos2 * dir);
-        s = Math.sin(s * len) / sin2;
-        t = Math.sin(t * len) / sin2;
+        const sin2 = Math.sqrt(sqrSin), len2 = Math.atan2(sin2, cos2 * dir);
+        s = Math.sin(s * len2) / sin2;
+        t = Math.sin(t * len2) / sin2;
       }
       const tDir = t * dir;
       x0 = x0 * s + x1 * tDir;
@@ -6531,7 +6531,7 @@ class BufferAttribute {
    * @return {BufferAttribute} A reference to this instance.
    */
   setComponent(index2, component, value) {
-    if (this.normalized) value = normalize$4(value, this.array);
+    if (this.normalized) value = normalize$5(value, this.array);
     this.array[index2 * this.itemSize + component] = value;
     return this;
   }
@@ -6554,7 +6554,7 @@ class BufferAttribute {
    * @return {BufferAttribute} A reference to this instance.
    */
   setX(index2, x2) {
-    if (this.normalized) x2 = normalize$4(x2, this.array);
+    if (this.normalized) x2 = normalize$5(x2, this.array);
     this.array[index2 * this.itemSize] = x2;
     return this;
   }
@@ -6577,7 +6577,7 @@ class BufferAttribute {
    * @return {BufferAttribute} A reference to this instance.
    */
   setY(index2, y2) {
-    if (this.normalized) y2 = normalize$4(y2, this.array);
+    if (this.normalized) y2 = normalize$5(y2, this.array);
     this.array[index2 * this.itemSize + 1] = y2;
     return this;
   }
@@ -6600,7 +6600,7 @@ class BufferAttribute {
    * @return {BufferAttribute} A reference to this instance.
    */
   setZ(index2, z2) {
-    if (this.normalized) z2 = normalize$4(z2, this.array);
+    if (this.normalized) z2 = normalize$5(z2, this.array);
     this.array[index2 * this.itemSize + 2] = z2;
     return this;
   }
@@ -6623,7 +6623,7 @@ class BufferAttribute {
    * @return {BufferAttribute} A reference to this instance.
    */
   setW(index2, w2) {
-    if (this.normalized) w2 = normalize$4(w2, this.array);
+    if (this.normalized) w2 = normalize$5(w2, this.array);
     this.array[index2 * this.itemSize + 3] = w2;
     return this;
   }
@@ -6638,8 +6638,8 @@ class BufferAttribute {
   setXY(index2, x2, y2) {
     index2 *= this.itemSize;
     if (this.normalized) {
-      x2 = normalize$4(x2, this.array);
-      y2 = normalize$4(y2, this.array);
+      x2 = normalize$5(x2, this.array);
+      y2 = normalize$5(y2, this.array);
     }
     this.array[index2 + 0] = x2;
     this.array[index2 + 1] = y2;
@@ -6657,9 +6657,9 @@ class BufferAttribute {
   setXYZ(index2, x2, y2, z2) {
     index2 *= this.itemSize;
     if (this.normalized) {
-      x2 = normalize$4(x2, this.array);
-      y2 = normalize$4(y2, this.array);
-      z2 = normalize$4(z2, this.array);
+      x2 = normalize$5(x2, this.array);
+      y2 = normalize$5(y2, this.array);
+      z2 = normalize$5(z2, this.array);
     }
     this.array[index2 + 0] = x2;
     this.array[index2 + 1] = y2;
@@ -6679,10 +6679,10 @@ class BufferAttribute {
   setXYZW(index2, x2, y2, z2, w2) {
     index2 *= this.itemSize;
     if (this.normalized) {
-      x2 = normalize$4(x2, this.array);
-      y2 = normalize$4(y2, this.array);
-      z2 = normalize$4(z2, this.array);
-      w2 = normalize$4(w2, this.array);
+      x2 = normalize$5(x2, this.array);
+      y2 = normalize$5(y2, this.array);
+      z2 = normalize$5(z2, this.array);
+      w2 = normalize$5(w2, this.array);
     }
     this.array[index2 + 0] = x2;
     this.array[index2 + 1] = y2;
@@ -7688,9 +7688,9 @@ function splitEarcut(start, triangles, dim, minX, minY, invSize) {
 }
 function eliminateHoles(data, holeIndices, outerNode, dim) {
   const queue = [];
-  for (let i = 0, len = holeIndices.length; i < len; i++) {
+  for (let i = 0, len2 = holeIndices.length; i < len2; i++) {
     const start = holeIndices[i] * dim;
-    const end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+    const end = i < len2 - 1 ? holeIndices[i + 1] * dim : data.length;
     const list = linkedList(data, start, end, dim, false);
     if (list === list.next) list.steiner = true;
     queue.push(getLeftmost(list));
@@ -8200,9 +8200,9 @@ function multiplyMat4(a2, b) {
   return out;
 }
 function normalizeVec3$3(v) {
-  const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-  if (len < EPS$6) throw new Error("Axis must be non-zero");
-  return [v[0] / len, v[1] / len, v[2] / len];
+  const len2 = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+  if (len2 < EPS$6) throw new Error("Axis must be non-zero");
+  return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function transformPoint$2(m2, p2, w2) {
   const x2 = p2[0], y2 = p2[1], z2 = p2[2];
@@ -10285,6 +10285,8 @@ function findShapePrimaryQueryOwner(plan) {
     case "chamfer":
     case "filletEdges":
     case "cornerYBlend":
+    case "faceFillet":
+    case "fullRound":
     case "chamferEdges":
     case "draft":
     case "offsetSolid":
@@ -10309,6 +10311,7 @@ function findShapePrimaryQueryOwner(plan) {
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "fromSectionFrames":
     case "analyticSurface":
     case "nurbsSurface":
     case "surfaceRuled":
@@ -10331,6 +10334,8 @@ function visitBaseShape(plan, visit) {
     case "chamfer":
     case "filletEdges":
     case "cornerYBlend":
+    case "faceFillet":
+    case "fullRound":
     case "chamferEdges":
     case "draft":
     case "offsetSolid":
@@ -10356,6 +10361,7 @@ function visitBaseShape(plan, visit) {
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "fromSectionFrames":
     case "analyticSurface":
     case "nurbsSurface":
     case "surfaceRuled":
@@ -10509,6 +10515,13 @@ function cloneAnalyticSurfaceCompilePlan(surface) {
       return assertExhaustive(surface);
   }
 }
+function cloneVariableRadiusSpec(spec) {
+  if (!spec) return void 0;
+  if ("stations" in spec) {
+    return { kind: "stations", stations: spec.stations.map((s) => ({ at: canonicalNumber(s.at), radius: canonicalNumber(s.radius) })) };
+  }
+  return { kind: "linear", start: canonicalNumber(spec.start), end: canonicalNumber(spec.end) };
+}
 function cloneProfileTransform(step) {
   switch (step.kind) {
     case "translate":
@@ -10576,6 +10589,12 @@ function cloneSurfaceBoundaryCompilePlan(plan) {
     support: plan.support ? cloneSurfaceSupportCompilePlan(plan.support) : void 0
   };
 }
+function cloneSurfaceInteriorConstraintCompilePlan(plan) {
+  return {
+    curve: cloneSweepPathCompilePlan(plan.curve),
+    continuity: plan.continuity
+  };
+}
 function cloneHoleCounterboreCompilePlan(plan) {
   return {
     radius: canonicalNumber(plan.radius),
@@ -10899,7 +10918,7 @@ function cloneProfileEdge(edge) {
   }
 }
 function cloneShapeCompilePlan(plan) {
-  var _a3, _b3, _c2;
+  var _a3, _b3, _c2, _d2, _e2;
   if (!plan) return null;
   let result;
   switch (plan.kind) {
@@ -11078,6 +11097,7 @@ function cloneShapeCompilePlan(plan) {
         kind: "filletEdges",
         base: cloneShapeCompilePlan(plan.base),
         radius: plan.radius,
+        variableRadius: cloneVariableRadiusSpec(plan.variableRadius),
         segments: plan.segments,
         continuity: plan.continuity,
         edgeTargets: (_a3 = plan.edgeTargets) == null ? void 0 : _a3.map(cloneEdgeFeatureTarget),
@@ -11085,6 +11105,32 @@ function cloneShapeCompilePlan(plan) {
         edgeSelection: plan.edgeSelection
       };
       break;
+    case "faceFillet":
+      result = {
+        kind: "faceFillet",
+        base: cloneShapeCompilePlan(plan.base),
+        radius: plan.radius,
+        variableRadius: cloneVariableRadiusSpec(plan.variableRadius),
+        segments: plan.segments,
+        continuity: plan.continuity,
+        faceA: cloneFaceQueryRef(plan.faceA),
+        faceB: cloneFaceQueryRef(plan.faceB),
+        edgeTargets: plan.edgeTargets.map(cloneEdgeFeatureTarget)
+      };
+      break;
+    case "fullRound":
+      result = {
+        kind: "fullRound",
+        base: cloneShapeCompilePlan(plan.base),
+        radius: plan.radius,
+        segments: plan.segments,
+        continuity: plan.continuity,
+        centerFace: cloneFaceQueryRef(plan.centerFace),
+        sideFaceA: cloneFaceQueryRef(plan.sideFaceA),
+        sideFaceB: cloneFaceQueryRef(plan.sideFaceB),
+        edgeTargets: plan.edgeTargets.map(cloneEdgeFeatureTarget)
+      };
+      break;
     case "cornerYBlend":
       result = {
         kind: "cornerYBlend",
@@ -11156,6 +11202,20 @@ function cloneShapeCompilePlan(plan) {
         boundsPadding: canonicalNumber(plan.boundsPadding)
       };
       break;
+    case "fromSectionFrames":
+      result = {
+        kind: "fromSectionFrames",
+        slices: plan.slices.map((s) => ({
+          origin: s.origin.map(canonicalNumber),
+          normal: s.normal.map(canonicalNumber),
+          tangentU: s.tangentU.map(canonicalNumber),
+          tangentV: s.tangentV.map(canonicalNumber),
+          profile: cloneProfileCompilePlan(s.profile)
+        })),
+        edgeLength: canonicalNumber(plan.edgeLength),
+        boundsPadding: canonicalNumber(plan.boundsPadding)
+      };
+      break;
     case "importedStep":
       result = { kind: "importedStep", filePath: plan.filePath, fileData: plan.fileData };
       break;
@@ -11217,7 +11277,9 @@ function cloneShapeCompilePlan(plan) {
         boundaries: plan.boundaries.map(cloneSurfaceBoundaryCompilePlan),
         style: plan.style,
         resolution: plan.resolution,
-        allowApproximation: plan.allowApproximation
+        allowApproximation: plan.allowApproximation,
+        interiorCurves: (_d2 = plan.interiorCurves) == null ? void 0 : _d2.map(cloneSurfaceInteriorConstraintCompilePlan),
+        interiorPoints: (_e2 = plan.interiorPoints) == null ? void 0 : _e2.map(canonicalVec3)
       };
       break;
     case "surfaceSew":
@@ -11344,12 +11406,12 @@ function profilePlanFromCrossSection(cross4) {
   return { kind: "boolean", op: "union", profiles: plans, transforms: [] };
 }
 function buildTrimByPlaneShapeCompilePlan(base, normal2, originOffset) {
-  const len = Math.sqrt(normal2[0] * normal2[0] + normal2[1] * normal2[1] + normal2[2] * normal2[2]);
-  if (len === 0) throw new Error("trimByPlane: normal vector must not be zero");
-  const nx = normal2[0] / len;
-  const ny = normal2[1] / len;
-  const nz = normal2[2] / len;
-  const adjustedOffset = originOffset / len;
+  const len2 = Math.sqrt(normal2[0] * normal2[0] + normal2[1] * normal2[1] + normal2[2] * normal2[2]);
+  if (len2 === 0) throw new Error("trimByPlane: normal vector must not be zero");
+  const nx = normal2[0] / len2;
+  const ny = normal2[1] / len2;
+  const nz = normal2[2] / len2;
+  const adjustedOffset = originOffset / len2;
   return {
     kind: "trimByPlane",
     base: cloneShapeCompilePlan(base),
@@ -11378,6 +11440,10 @@ function buildSurfaceThickenShapeCompilePlan(base, thickness) {
     thickness: canonicalNumber(thickness)
   };
 }
+function maxVariableRadius(spec) {
+  if ("stations" in spec) return Math.max(...spec.stations.map((s) => s.radius));
+  return Math.max(spec.start, spec.end);
+}
 function generateClampedKnots(n, degree) {
   const m2 = n + degree + 1;
   const knots = new Array(m2);
@@ -11531,32 +11597,32 @@ function remapToKnotDomain(t, n, degree, knots) {
   return uMin + Math.max(0, Math.min(1, t)) * (uMax - uMin);
 }
 const EPSILON$1 = 1e-9;
-function add$2(a2, b) {
+function add$3(a2, b) {
   return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
 }
 function scale$2(v, factor) {
   return [v[0] * factor, v[1] * factor, v[2] * factor];
 }
-function sub$3(a2, b) {
+function sub$4(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
-function dot$3(a2, b) {
+function dot$4(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
-function cross$3(a2, b) {
+function cross$4(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 rotateAroundAxis$1(v, axis, angleRad) {
   const c2 = Math.cos(angleRad);
   const s = Math.sin(angleRad);
   const term1 = scale$2(v, c2);
-  const term2 = scale$2(cross$3(axis, v), s);
-  const term3 = scale$2(axis, dot$3(axis, v) * (1 - c2));
-  return add$2(add$2(term1, term2), term3);
+  const term2 = scale$2(cross$4(axis, v), s);
+  const term3 = scale$2(axis, dot$4(axis, v) * (1 - c2));
+  return add$3(add$3(term1, term2), term3);
 }
 function arcPointAt(segment, t) {
   const sweepRad = segment.sweepDeg * Math.PI / 180 * t;
-  return add$2(segment.center, rotateAroundAxis$1(sub$3(segment.start, segment.center), segment.axis, sweepRad));
+  return add$3(segment.center, rotateAroundAxis$1(sub$4(segment.start, segment.center), segment.axis, sweepRad));
 }
 function pushUnique(points, point2) {
   const prev = points[points.length - 1];
@@ -11579,7 +11645,7 @@ function routePointAt(plan, t) {
     const next = station + segment.length;
     if (target <= next || segment === plan.segments[plan.segments.length - 1]) {
       const localT = segment.length <= EPSILON$1 ? 1 : Math.max(0, Math.min(1, (target - station) / segment.length));
-      if (segment.kind === "line") return add$2(segment.from, scale$2(sub$3(segment.to, segment.from), localT));
+      if (segment.kind === "line") return add$3(segment.from, scale$2(sub$4(segment.to, segment.from), localT));
       return arcPointAt(segment, localT);
     }
     station = next;
@@ -11599,7 +11665,7 @@ function sampleRoute3DCompilePlan(plan, options) {
     pushUnique(points, start);
     for (let i = 1; i <= intervals; i += 1) {
       if (segment.kind === "line") {
-        pushUnique(points, add$2(segment.from, scale$2(sub$3(segment.to, segment.from), i / intervals)));
+        pushUnique(points, add$3(segment.from, scale$2(sub$4(segment.to, segment.from), i / intervals)));
       } else {
         pushUnique(points, arcPointAt(segment, i / intervals));
       }
@@ -11830,10 +11896,10 @@ const EPS$4 = 1e-8;
 function midpoint$1(start, end) {
   return [(start[0] + end[0]) * 0.5, (start[1] + end[1]) * 0.5, (start[2] + end[2]) * 0.5];
 }
-function normalize$3(v) {
-  const len = Math.hypot(v[0], v[1], v[2]);
-  if (len <= EPS$4) throw new Error("Edge feature selection requires a non-zero direction vector");
-  return [v[0] / len, v[1] / len, v[2] / len];
+function normalize$4(v) {
+  const len2 = Math.hypot(v[0], v[1], v[2]);
+  if (len2 <= EPS$4) 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) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
@@ -11910,11 +11976,11 @@ function rigidTransformForEdgeStep(step) {
       return Transform.rotationAxis([step.axisX, step.axisY, step.axisZ], step.degrees, [step.pivotX, step.pivotY, step.pivotZ]);
     case "mirror": {
       const [nx0, ny0, nz0] = [step.normalX, step.normalY, step.normalZ];
-      const len = Math.hypot(nx0, ny0, nz0);
-      if (len <= EPS$4) return Transform.identity();
-      const nx = nx0 / len;
-      const ny = ny0 / len;
-      const nz = nz0 / len;
+      const len2 = Math.hypot(nx0, ny0, nz0);
+      if (len2 <= EPS$4) return Transform.identity();
+      const nx = nx0 / len2;
+      const ny = ny0 / len2;
+      const nz = nz0 / len2;
       return Transform.from([
         1 - 2 * nx * nx,
         -2 * ny * nx,
@@ -11994,6 +12060,8 @@ function searchOwnerMatch(plan, owner) {
     }
     case "filletEdges":
     case "cornerYBlend":
+    case "faceFillet":
+    case "fullRound":
     case "chamferEdges":
     case "draft":
     case "offsetSolid":
@@ -12027,6 +12095,7 @@ function searchOwnerMatch(plan, owner) {
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "fromSectionFrames":
     case "analyticSurface":
     case "nurbsSurface":
     case "surfaceRuled":
@@ -12116,7 +12185,7 @@ function propagateCandidateAcrossRewrite(plan, candidate) {
   return edgeSuccess(candidate.selection, preservedEntry.query);
 }
 function resolvePropagatedEdgeQueryAtOwnerBase(ownerBase, ref) {
-  if (ownerBase.kind === "box" || ownerBase.kind === "cylinder" || ownerBase.kind === "sphere" || ownerBase.kind === "extrude" || ownerBase.kind === "sheetMetal" || ownerBase.kind === "revolve" || ownerBase.kind === "loft" || ownerBase.kind === "sweep" || ownerBase.kind === "variableSweep" || ownerBase.kind === "transform" || ownerBase.kind === "queryOwner" || ownerBase.kind === "filletEdges" || ownerBase.kind === "cornerYBlend" || ownerBase.kind === "chamferEdges" || ownerBase.kind === "importedMesh" || ownerBase.kind === "sdf" || ownerBase.kind === "fromSlices" || ownerBase.kind === "analyticSurface" || ownerBase.kind === "nurbsSurface" || ownerBase.kind === "surfaceRuled" || ownerBase.kind === "surfaceFill" || ownerBase.kind === "surfaceSew" || ownerBase.kind === "surfaceExtend" || ownerBase.kind === "surfaceThicken" || ownerBase.kind === "surfaceSolid" || ownerBase.kind === "importedStep" || ownerBase.kind === "torus" || ownerBase.kind === "draft" || ownerBase.kind === "offsetSolid") {
+  if (ownerBase.kind === "box" || ownerBase.kind === "cylinder" || ownerBase.kind === "sphere" || ownerBase.kind === "extrude" || ownerBase.kind === "sheetMetal" || ownerBase.kind === "revolve" || ownerBase.kind === "loft" || ownerBase.kind === "sweep" || ownerBase.kind === "variableSweep" || ownerBase.kind === "transform" || ownerBase.kind === "queryOwner" || ownerBase.kind === "filletEdges" || ownerBase.kind === "cornerYBlend" || ownerBase.kind === "faceFillet" || ownerBase.kind === "fullRound" || ownerBase.kind === "chamferEdges" || ownerBase.kind === "importedMesh" || ownerBase.kind === "sdf" || ownerBase.kind === "fromSlices" || ownerBase.kind === "fromSectionFrames" || ownerBase.kind === "analyticSurface" || ownerBase.kind === "nurbsSurface" || ownerBase.kind === "surfaceRuled" || ownerBase.kind === "surfaceFill" || ownerBase.kind === "surfaceSew" || ownerBase.kind === "surfaceExtend" || ownerBase.kind === "surfaceThicken" || ownerBase.kind === "surfaceSolid" || ownerBase.kind === "importedStep" || ownerBase.kind === "torus" || ownerBase.kind === "draft" || ownerBase.kind === "offsetSolid") {
     return edgeIssue(
       "edge-query-propagation-mismatch",
       "The selected propagated edge query does not point at a topology-rewrite result on this target shape."
@@ -12249,8 +12318,8 @@ function extrudeEdgeSelection(plan, edgeName) {
   }
   const points = plan.profile.points;
   const [bl, br, _tr, tl] = points;
-  const u2 = normalize$3([br[0] - bl[0], br[1] - bl[1], 0]);
-  const v = normalize$3([tl[0] - bl[0], tl[1] - bl[1], 0]);
+  const u2 = normalize$4([br[0] - bl[0], br[1] - bl[1], 0]);
+  const v = normalize$4([tl[0] - bl[0], tl[1] - bl[1], 0]);
   const vertex2 = points[index2];
   const quadrant = index2 === 0 ? [1, -1] : index2 === 1 ? [-1, -1] : index2 === 2 ? [-1, 1] : [1, 1];
   return {
@@ -12271,9 +12340,9 @@ function extrudeEdgeSelection(plan, edgeName) {
 function applySelectionTransform(selection, transform) {
   const start = transform.point(selection.start);
   const end = transform.point(selection.end);
-  const basisX = normalize$3(transform.vector(selection.basisX));
-  const basisY = normalize$3(transform.vector(selection.basisY));
-  const axis = normalize$3(subtract(end, start));
+  const basisX = normalize$4(transform.vector(selection.basisX));
+  const basisY = normalize$4(transform.vector(selection.basisY));
+  const axis = normalize$4(subtract(end, start));
   return {
     kind: "line-segment",
     edgeName: selection.edgeName,
@@ -12308,6 +12377,8 @@ function resolveSelectionFromOwnerBase(plan, edgeName) {
     case "chamfer":
     case "filletEdges":
     case "cornerYBlend":
+    case "faceFillet":
+    case "fullRound":
     case "chamferEdges":
     case "draft":
     case "offsetSolid":
@@ -12327,6 +12398,7 @@ function resolveSelectionFromOwnerBase(plan, edgeName) {
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "fromSectionFrames":
     case "analyticSurface":
     case "nurbsSurface":
     case "surfaceRuled":
@@ -12370,7 +12442,7 @@ function resolveSupportedEdgeFeatureSelection(plan, ref) {
   return edgeIssue("edge-query-unsupported-after-rewrite", descendant.reason);
 }
 function resolveEdgeChainAtOwnerBase(ownerBase, ref) {
-  if (ownerBase.kind === "box" || ownerBase.kind === "cylinder" || ownerBase.kind === "sphere" || ownerBase.kind === "extrude" || ownerBase.kind === "sheetMetal" || ownerBase.kind === "revolve" || ownerBase.kind === "loft" || ownerBase.kind === "sweep" || ownerBase.kind === "variableSweep" || ownerBase.kind === "transform" || ownerBase.kind === "queryOwner" || ownerBase.kind === "filletEdges" || ownerBase.kind === "cornerYBlend" || ownerBase.kind === "chamferEdges" || ownerBase.kind === "importedMesh" || ownerBase.kind === "sdf" || ownerBase.kind === "fromSlices" || ownerBase.kind === "analyticSurface" || ownerBase.kind === "nurbsSurface" || ownerBase.kind === "surfaceRuled" || ownerBase.kind === "surfaceFill" || ownerBase.kind === "surfaceSew" || ownerBase.kind === "surfaceExtend" || ownerBase.kind === "surfaceThicken" || ownerBase.kind === "surfaceSolid" || ownerBase.kind === "importedStep" || ownerBase.kind === "torus" || ownerBase.kind === "draft" || ownerBase.kind === "offsetSolid") {
+  if (ownerBase.kind === "box" || ownerBase.kind === "cylinder" || ownerBase.kind === "sphere" || ownerBase.kind === "extrude" || ownerBase.kind === "sheetMetal" || ownerBase.kind === "revolve" || ownerBase.kind === "loft" || ownerBase.kind === "sweep" || ownerBase.kind === "variableSweep" || ownerBase.kind === "transform" || ownerBase.kind === "queryOwner" || ownerBase.kind === "filletEdges" || ownerBase.kind === "cornerYBlend" || ownerBase.kind === "faceFillet" || ownerBase.kind === "fullRound" || ownerBase.kind === "chamferEdges" || ownerBase.kind === "importedMesh" || ownerBase.kind === "sdf" || ownerBase.kind === "fromSlices" || ownerBase.kind === "fromSectionFrames" || ownerBase.kind === "analyticSurface" || ownerBase.kind === "nurbsSurface" || ownerBase.kind === "surfaceRuled" || ownerBase.kind === "surfaceFill" || ownerBase.kind === "surfaceSew" || ownerBase.kind === "surfaceExtend" || ownerBase.kind === "surfaceThicken" || ownerBase.kind === "surfaceSolid" || ownerBase.kind === "importedStep" || ownerBase.kind === "torus" || ownerBase.kind === "draft" || ownerBase.kind === "offsetSolid") {
     return {
       kind: "unsupported",
       query: cloneEdgeQueryRef(ref),
@@ -12403,7 +12475,7 @@ function resolveEdgeChainAtOwnerBase(ownerBase, ref) {
   };
 }
 function resolveCreatedEdgeChainAtOwnerBase(ownerBase, ref) {
-  if (ownerBase.kind === "box" || ownerBase.kind === "cylinder" || ownerBase.kind === "sphere" || ownerBase.kind === "extrude" || ownerBase.kind === "sheetMetal" || ownerBase.kind === "revolve" || ownerBase.kind === "loft" || ownerBase.kind === "sweep" || ownerBase.kind === "variableSweep" || ownerBase.kind === "transform" || ownerBase.kind === "queryOwner" || ownerBase.kind === "filletEdges" || ownerBase.kind === "cornerYBlend" || ownerBase.kind === "chamferEdges" || ownerBase.kind === "importedMesh" || ownerBase.kind === "sdf" || ownerBase.kind === "fromSlices" || ownerBase.kind === "analyticSurface" || ownerBase.kind === "nurbsSurface" || ownerBase.kind === "surfaceRuled" || ownerBase.kind === "surfaceFill" || ownerBase.kind === "surfaceSew" || ownerBase.kind === "surfaceExtend" || ownerBase.kind === "surfaceThicken" || ownerBase.kind === "surfaceSolid" || ownerBase.kind === "importedStep" || ownerBase.kind === "torus" || ownerBase.kind === "draft" || ownerBase.kind === "offsetSolid") {
+  if (ownerBase.kind === "box" || ownerBase.kind === "cylinder" || ownerBase.kind === "sphere" || ownerBase.kind === "extrude" || ownerBase.kind === "sheetMetal" || ownerBase.kind === "revolve" || ownerBase.kind === "loft" || ownerBase.kind === "sweep" || ownerBase.kind === "variableSweep" || ownerBase.kind === "transform" || ownerBase.kind === "queryOwner" || ownerBase.kind === "filletEdges" || ownerBase.kind === "cornerYBlend" || ownerBase.kind === "faceFillet" || ownerBase.kind === "fullRound" || ownerBase.kind === "chamferEdges" || ownerBase.kind === "importedMesh" || ownerBase.kind === "sdf" || ownerBase.kind === "fromSlices" || ownerBase.kind === "fromSectionFrames" || ownerBase.kind === "analyticSurface" || ownerBase.kind === "nurbsSurface" || ownerBase.kind === "surfaceRuled" || ownerBase.kind === "surfaceFill" || ownerBase.kind === "surfaceSew" || ownerBase.kind === "surfaceExtend" || ownerBase.kind === "surfaceThicken" || ownerBase.kind === "surfaceSolid" || ownerBase.kind === "importedStep" || ownerBase.kind === "torus" || ownerBase.kind === "draft" || ownerBase.kind === "offsetSolid") {
     return {
       kind: "unsupported",
       query: cloneEdgeQueryRef(ref),
@@ -12936,16 +13008,16 @@ function extractEdgeSegments(mesh) {
     let nx = e1y * e2z - e1z * e2y;
     let ny = e1z * e2x - e1x * e2z;
     let nz = e1x * e2y - e1y * e2x;
-    const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
-    nx /= len;
-    ny /= len;
-    nz /= len;
+    const len2 = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+    nx /= len2;
+    ny /= len2;
+    nz /= len2;
     faceNx[t] = nx;
     faceNy[t] = ny;
     faceNz[t] = nz;
   }
   const numVerts = vertProperties.length / numProp;
-  const canon = buildCanonicalMap$2(numVerts, mesh.mergeFromVert, mesh.mergeToVert);
+  const canon = buildCanonicalMap$3(numVerts, mesh.mergeFromVert, mesh.mergeToVert);
   const MAX_NUMERIC = 1 << 21;
   let maxCanon = 0;
   for (let i = 0; i < numVerts; i++) {
@@ -13034,7 +13106,7 @@ function buildEdgeSegment(index2, origVa, origVb, vertProperties, numProp, triA,
     boundary
   };
 }
-function buildCanonicalMap$2(numVerts, mergeFromVert, mergeToVert) {
+function buildCanonicalMap$3(numVerts, mergeFromVert, mergeToVert) {
   const canon = new Uint32Array(numVerts);
   for (let i = 0; i < numVerts; i++) canon[i] = i;
   if (mergeFromVert && mergeToVert) {
@@ -14040,10 +14112,10 @@ function distSq$1(a2, b) {
 function vecLength$2(v) {
   return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
 }
-function normalize$2(v) {
-  const len = vecLength$2(v);
-  if (len < 1e-12) return [0, 0, 0];
-  return [v[0] / len, v[1] / len, v[2] / len];
+function normalize$3(v) {
+  const len2 = vecLength$2(v);
+  if (len2 < 1e-12) return [0, 0, 0];
+  return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function absDot$1(a2, b) {
   return Math.abs(a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2]);
@@ -14076,11 +14148,11 @@ function applyEdgeQueryFilters(edges, query) {
     result = result.filter((e) => e.length <= max2);
   }
   if (query.parallel) {
-    const dir = normalize$2(query.parallel);
+    const dir = normalize$3(query.parallel);
     result = result.filter((e) => absDot$1(e.direction, dir) >= cosAngleTol);
   }
   if (query.perpendicular) {
-    const dir = normalize$2(query.perpendicular);
+    const dir = normalize$3(query.perpendicular);
     const sinAngleTol = Math.sin(angleTol * Math.PI / 180);
     result = result.filter((e) => absDot$1(e.direction, dir) <= sinAngleTol);
   }
@@ -14328,6 +14400,8 @@ function lowerBaseShellPlanToConcretePlan(plan, thickness, openFaces) {
     case "chamfer":
     case "filletEdges":
     case "cornerYBlend":
+    case "faceFillet":
+    case "fullRound":
     case "chamferEdges":
     case "draft":
     case "offsetSolid":
@@ -14352,6 +14426,7 @@ function lowerBaseShellPlanToConcretePlan(plan, thickness, openFaces) {
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "fromSectionFrames":
     case "analyticSurface":
     case "nurbsSurface":
     case "surfaceRuled":
@@ -14683,6 +14758,8 @@ function planComplexityScore(value) {
     case "fillet":
     case "filletEdges":
     case "cornerYBlend":
+    case "faceFillet":
+    case "fullRound":
     case "chamfer":
     case "chamferEdges":
       return 5 + childScore(record.base);
@@ -15482,8 +15559,8 @@ function clampUnit(v) {
 }
 function sphereUVLocal(lx, ly, lz, radius) {
   const u2 = atan2(ly, lx) * radius;
-  const len = sqrt$3(lx * lx + ly * ly + lz * lz);
-  const v = acos(clampUnit(lz / (len || 1))) * radius;
+  const len2 = sqrt$3(lx * lx + ly * ly + lz * lz);
+  const v = acos(clampUnit(lz / (len2 || 1))) * radius;
   return [u2, v];
 }
 function cylinderUVLocal(lx, ly, lz, radius) {
@@ -16939,7 +17016,7 @@ async function initTruckGeometryWasm() {
   if (_initPromise$1) return _initPromise$1;
   _initPromise$1 = (async () => {
     try {
-      const geometryModule = await import("./forgecad_geometry-CZ_IfuvA.js");
+      const geometryModule = await import("./forgecad_geometry-D8rWX7nQ.js");
       const isNode = isNodeRuntime();
       if (isNode) {
         const { readFileSync, existsSync } = await import("./__vite-browser-external-Dhvy_jtL.js");
@@ -17302,6 +17379,9 @@ function topologyToPlacementReferences(topo) {
   }
   return { surfaces, edges };
 }
+function towardInterior(t, delta) {
+  return t <= 0.5 ? Math.min(t + delta, 0.5) : Math.max(t - delta, 0.5);
+}
 function requireFinite(v, label) {
   if (!Number.isFinite(v)) throw new Error(`nurbsSurface: ${label} must be finite, got ${v}`);
 }
@@ -17412,13 +17492,32 @@ class NurbsSurface {
    * and Sv positively and cancel under normalization, so they are omitted.
    */
   normalAt(u2, v) {
+    const direct = this.crossNormalAt(u2, v);
+    if (direct) return direct;
+    let delta = 2e-4;
+    while (delta < 0.5) {
+      const limit = this.crossNormalAt(towardInterior(u2, delta), towardInterior(v, delta));
+      if (limit) return limit;
+      delta *= 2;
+    }
+    return [0, 0, 1];
+  }
+  /**
+   * Unit normal from the analytic partials, or null when the parameterization is
+   * degenerate at (u, v) (a partial collapses, so the cross product is tiny
+   * relative to the tangent spans — a pole, not a real normal).
+   */
+  crossNormalAt(u2, v) {
     const { Su, Sv } = this.derivativesAt(u2, v);
+    const spanU = Math.hypot(Su[0], Su[1], Su[2]);
+    const spanV = Math.hypot(Sv[0], Sv[1], Sv[2]);
+    if (spanU <= 1e-6 * spanV || spanV <= 1e-6 * spanU) return null;
     const nx = Su[1] * Sv[2] - Su[2] * Sv[1];
     const ny = Su[2] * Sv[0] - Su[0] * Sv[2];
     const nz = Su[0] * Sv[1] - Su[1] * Sv[0];
-    const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
-    if (len < 1e-12) return [0, 0, 1];
-    return [nx / len, ny / len, nz / len];
+    const len2 = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    if (len2 <= 1e-6 * spanU * spanV) return null;
+    return [nx / len2, ny / len2, nz / len2];
   }
   /** Analytic first partial derivatives S_u, S_v (rational quotient rule). */
   derivativesAt(u2, v) {
@@ -17891,9 +17990,9 @@ function vec3Lerp(a2, b, t) {
   return [a2[0] + (b[0] - a2[0]) * t, a2[1] + (b[1] - a2[1]) * t, a2[2] + (b[2] - a2[2]) * t];
 }
 function vec3Norm(v) {
-  const len = vec3Len(v);
-  if (len < 1e-9) return [0, 0, 1];
-  return [v[0] / len, v[1] / len, v[2] / len];
+  const len2 = vec3Len(v);
+  if (len2 < 1e-9) return [0, 0, 1];
+  return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function signedArea2D(loop) {
   let area2 = 0;
@@ -18077,22 +18176,22 @@ function buildSweepSegments(pathPoints, preferredUp) {
     const a2 = clean[index2];
     const b = clean[index2 + 1];
     const delta = vec3Sub(b, a2);
-    const len = vec3Len(delta);
-    if (len < 1e-6) continue;
-    const tangent = vec3Scale(delta, 1 / len);
+    const len2 = vec3Len(delta);
+    if (len2 < 1e-6) continue;
+    const tangent = vec3Scale(delta, 1 / len2);
     segments.push({
       a: a2,
       b,
       t: tangent,
       x: frames[index2].x,
       y: frames[index2].y,
-      len,
+      len: len2,
       arcStart: totalLen,
-      arcEnd: totalLen + len,
+      arcEnd: totalLen + len2,
       frameA: frames[index2],
       frameB: frames[index2 + 1]
     });
-    totalLen += len;
+    totalLen += len2;
   }
   if (segments.length === 0) {
     throw new Error("sweep path has no non-zero segments");
@@ -18579,6 +18678,58 @@ function loftStitched(profiles, heights, wasm, options = {}) {
   }
   return result;
 }
+function loftStitchedOnFrames(profiles, frames, wasm, options = {}) {
+  if (profiles.length < 2 || profiles.length !== frames.length) return null;
+  const classified = profiles.map((loops) => classifyLoops(loops));
+  const outerCount = classified[0].outers.length;
+  const holeCount = classified[0].holes.length;
+  if (outerCount === 0) return null;
+  for (let i = 1; i < classified.length; i++) {
+    if (classified[i].outers.length !== outerCount || classified[i].holes.length !== holeCount) return null;
+  }
+  const outerGroups = matchLoopsAcrossProfiles(classified.map((c2) => c2.outers));
+  const holeGroups = holeCount > 0 ? matchLoopsAcrossProfiles(classified.map((c2) => c2.holes)) : [];
+  const outerSolids = [];
+  for (const group of outerGroups) {
+    const solid = stitchSingleLoopLoftOnFrames(group, frames, wasm, options);
+    if (!solid) {
+      for (const s of outerSolids) s.delete();
+      return null;
+    }
+    outerSolids.push(solid);
+  }
+  let result;
+  if (outerSolids.length === 1) {
+    result = outerSolids[0];
+  } else {
+    result = wasm.Manifold.union(outerSolids);
+    for (const s of outerSolids) s.delete();
+  }
+  if (holeGroups.length > 0) {
+    const holeSolids = [];
+    for (const group of holeGroups) {
+      const solid = stitchSingleLoopLoftOnFrames(group, frames, wasm, options);
+      if (!solid) {
+        result.delete();
+        for (const s of holeSolids) s.delete();
+        return null;
+      }
+      holeSolids.push(solid);
+    }
+    let holeUnion;
+    if (holeSolids.length === 1) {
+      holeUnion = holeSolids[0];
+    } else {
+      holeUnion = wasm.Manifold.union(holeSolids);
+      for (const s of holeSolids) s.delete();
+    }
+    const subtracted = wasm.Manifold.difference([result, holeUnion]);
+    result.delete();
+    holeUnion.delete();
+    result = subtracted;
+  }
+  return result;
+}
 function classifyLoops(loops) {
   const outers = [];
   const holes = [];
@@ -18737,9 +18888,9 @@ function maxQuadDeviation(rings, heights, colA, colB) {
     const c2 = [rings[i + 1][colB][0], rings[i + 1][colB][1], heights[i + 1]];
     const d2 = [rings[i + 1][colA][0], rings[i + 1][colA][1], heights[i + 1]];
     const n = cross3$6(sub3$4(b, a2), sub3$4(d2, a2));
-    const len = Math.hypot(n[0], n[1], n[2]);
-    if (len < 1e-12) continue;
-    const deviation = Math.abs((n[0] * (c2[0] - a2[0]) + n[1] * (c2[1] - a2[1]) + n[2] * (c2[2] - a2[2])) / len);
+    const len2 = Math.hypot(n[0], n[1], n[2]);
+    if (len2 < 1e-12) continue;
+    const deviation = Math.abs((n[0] * (c2[0] - a2[0]) + n[1] * (c2[1] - a2[1]) + n[2] * (c2[2] - a2[2])) / len2);
     if (deviation > worst) worst = deviation;
   }
   return worst;
@@ -18795,18 +18946,18 @@ function buildCornerAnchoredRings(loops, heights, cornerSets, edgeLength2) {
       const start = dists[from];
       let end = dists[to];
       if (to <= from) end += total;
-      const len = end - start;
-      if (len < 1e-9) return null;
+      const len2 = end - start;
+      if (len2 < 1e-9) return null;
       const interior = [];
       const n = loop.length;
       for (let v = (from + 1) % n; v !== to; v = (v + 1) % n) {
         let d2 = dists[v];
         if (d2 < start) d2 += total;
-        const p2 = (d2 - start) / len;
+        const p2 = (d2 - start) / len2;
         if (p2 > 1e-9 && p2 < 1 - 1e-9) interior.push(p2);
       }
       stationSegs.push(interior);
-      stationLens.push(len);
+      stationLens.push(len2);
     }
     segParams.push(stationSegs);
     segLengths.push(stationLens);
@@ -18832,12 +18983,12 @@ function buildCornerAnchoredRings(loops, heights, cornerSets, edgeLength2) {
         const start = dists[from];
         let end = dists[to];
         if (to <= from) end += total;
-        const len = end - start;
+        const len2 = end - start;
         for (const p2 of paramsBySegment[s]) {
           if (p2 === 0) {
             ring.push([loop[from][0], loop[from][1]]);
           } else {
-            ring.push(pointAtArcLength(loop, dists, total, start + p2 * len));
+            ring.push(pointAtArcLength(loop, dists, total, start + p2 * len2));
           }
         }
       }
@@ -18965,9 +19116,11 @@ function buildSeamAlignedRings(loops, _heights, edgeLength2) {
   return { rings, cornerColumns: [] };
 }
 function buildSpanRows(rings, heights) {
-  const R = rings.length;
-  const N = rings[0].length;
-  const stations = rings.map((ring, i) => ring.map(([x2, y2]) => [x2, y2, heights[i]]));
+  return buildSpanRowsFromStations(rings.map((ring, i) => ring.map(([x2, y2]) => [x2, y2, heights[i]])));
+}
+function buildSpanRowsFromStations(stations) {
+  const R = stations.length;
+  const N = stations[0].length;
   const t = [0];
   for (let i = 0; i < R - 1; i++) {
     let sum2 = 0;
@@ -19132,15 +19285,117 @@ function stitchSingleLoopLoft(loops, heights, wasm, options) {
     return null;
   }
 }
+function stitchSingleLoopLoftOnFrames(loops, frames, wasm, options) {
+  const normalizedLoops = loops.map((loop) => {
+    const area2 = signedArea$3(loop);
+    return area2 < 0 ? [...loop].reverse() : loop;
+  });
+  const stationDistances = cumulativeFrameDistances(frames);
+  const compatible = buildCompatibleRings(normalizedLoops, stationDistances, options.edgeLength);
+  if (!compatible) return null;
+  const { rings, cornerColumns } = compatible;
+  const N = rings[0].length;
+  if (N < 3) return null;
+  const stations = rings.map((ring, i) => ring.map(([x2, y2]) => pointOnFrame(frames[i], x2, y2)));
+  const rows = buildSpanRowsFromStations(stations);
+  const R = rows.length;
+  const cornerSet = new Set(cornerColumns);
+  const vertProps = [];
+  let vertCount = 0;
+  const fwdIdx = [];
+  const bwdIdx = [];
+  const pushVert = (p2, n) => {
+    vertProps.push(p2[0], p2[1], p2[2], n[0], n[1], n[2]);
+    return vertCount++;
+  };
+  for (let r = 0; r < R; r++) {
+    const { points, tangents } = rows[r];
+    const fwd = new Array(N);
+    const bwd = new Array(N);
+    for (let j = 0; j < N; j++) {
+      const prev = points[(j - 1 + N) % N];
+      const curr = points[j];
+      const next = points[(j + 1) % N];
+      if (cornerSet.has(j)) {
+        const nFwd = surfaceNormal(sub3$4(next, curr), tangents[j]);
+        const nBwd = surfaceNormal(sub3$4(curr, prev), tangents[j]);
+        fwd[j] = pushVert(curr, nFwd);
+        bwd[j] = pushVert(curr, nBwd);
+      } else {
+        const idx = pushVert(curr, surfaceNormal(sub3$4(next, prev), tangents[j]));
+        fwd[j] = idx;
+        bwd[j] = idx;
+      }
+    }
+    fwdIdx.push(fwd);
+    bwdIdx.push(bwd);
+  }
+  const triangles = [];
+  for (let r = 0; r < R - 1; r++) {
+    for (let j = 0; j < N; j++) {
+      const j1 = (j + 1) % N;
+      const v0 = fwdIdx[r][j];
+      const v3 = bwdIdx[r][j1];
+      const v2 = bwdIdx[r + 1][j1];
+      const v1 = fwdIdx[r + 1][j];
+      triangles.push(v0, v3, v2);
+      triangles.push(v0, v2, v1);
+    }
+  }
+  const bottomTris = wasm.triangulate([rings[0]]);
+  const bottomBase = vertCount;
+  const bottomNormal = scale3$2(frames[0].normal, -1);
+  for (const p2 of rows[0].points) pushVert(p2, bottomNormal);
+  for (const tri of bottomTris) {
+    const [v0, v1, v2] = Array.isArray(tri) ? tri : [tri[0], tri[1], tri[2]];
+    triangles.push(bottomBase + v0, bottomBase + v2, bottomBase + v1);
+  }
+  const topTris = wasm.triangulate([rings[rings.length - 1]]);
+  const topBase = vertCount;
+  const topNormal = frames[frames.length - 1].normal;
+  for (const p2 of rows[R - 1].points) pushVert(p2, topNormal);
+  for (const tri of topTris) {
+    const [v0, v1, v2] = Array.isArray(tri) ? tri : [tri[0], tri[1], tri[2]];
+    triangles.push(topBase + v0, topBase + v1, topBase + v2);
+  }
+  const mesh = new wasm.Mesh({
+    numProp: 6,
+    vertProperties: new Float32Array(vertProps),
+    triVerts: new Uint32Array(triangles)
+  });
+  try {
+    mesh.merge();
+    return new wasm.Manifold(mesh);
+  } catch (_e2) {
+    return null;
+  }
+}
+function pointOnFrame(frame, x2, y2) {
+  return [
+    frame.origin[0] + frame.xAxis[0] * x2 + frame.yAxis[0] * y2,
+    frame.origin[1] + frame.xAxis[1] * x2 + frame.yAxis[1] * y2,
+    frame.origin[2] + frame.xAxis[2] * x2 + frame.yAxis[2] * y2
+  ];
+}
+function cumulativeFrameDistances(frames) {
+  const distances = [0];
+  for (let i = 1; i < frames.length; i++) {
+    distances.push(distances[i - 1] + dist3(frames[i].origin, frames[i - 1].origin));
+  }
+  if (distances[distances.length - 1] < 1e-9) {
+    for (let i = 0; i < frames.length; i++) distances[i] = i;
+  }
+  return distances;
+}
 function surfaceNormal(chord, span2) {
   const n = cross3$6(chord, span2);
-  const len = Math.hypot(n[0], n[1], n[2]);
-  if (len < 1e-12) {
+  const len2 = Math.hypot(n[0], n[1], n[2]);
+  if (len2 < 1e-12) {
     const radial = Math.hypot(chord[0], chord[1]);
     if (radial > 1e-12) return [chord[1] / radial, -chord[0] / radial, 0];
     return [0, 0, 1];
   }
-  return [n[0] / len, n[1] / len, n[2] / len];
+  return [n[0] / len2, n[1] / len2, n[2] / len2];
 }
 function sub3$4(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
@@ -19428,32 +19683,32 @@ function sweepStitched(profilePolygons, pathPoints, up, wasm) {
 function computeParallelTransportFrames(path, preferredUp) {
   const n = path.length;
   const frames = [];
-  const firstTangent = normalize$1(sub$2(path[1], path[0]));
+  const firstTangent = normalize$2(sub$3(path[1], path[0]));
   if (!firstTangent) return null;
-  let x2 = normalize$1(cross$2(preferredUp, firstTangent));
+  let x2 = normalize$2(cross$3(preferredUp, firstTangent));
   if (!x2 || length$1(x2) < 1e-8) {
     const fallback = Math.abs(firstTangent[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
-    x2 = normalize$1(cross$2(fallback, firstTangent));
+    x2 = normalize$2(cross$3(fallback, firstTangent));
     if (!x2) return null;
   }
-  let y2 = normalize$1(cross$2(firstTangent, x2));
+  let y2 = normalize$2(cross$3(firstTangent, x2));
   frames.push({ origin: path[0], x: x2, y: y2, t: firstTangent });
   for (let i = 1; i < n; i++) {
     const prevT = frames[i - 1].t;
     let nextT;
     if (i < n - 1) {
-      const t1 = normalize$1(sub$2(path[i], path[i - 1]));
-      const t2 = normalize$1(sub$2(path[i + 1], path[i]));
+      const t1 = normalize$2(sub$3(path[i], path[i - 1]));
+      const t2 = normalize$2(sub$3(path[i + 1], path[i]));
       if (!t1 || !t2) return null;
-      nextT = normalize$1(add$1(t1, t2)) || t1;
+      nextT = normalize$2(add$2(t1, t2)) || t1;
     } else {
-      const nt = normalize$1(sub$2(path[i], path[i - 1]));
+      const nt = normalize$2(sub$3(path[i], path[i - 1]));
       if (!nt) return null;
       nextT = nt;
     }
-    const v = cross$2(prevT, nextT);
+    const v = cross$3(prevT, nextT);
     const vLen = length$1(v);
-    const c2 = dot$2(prevT, nextT);
+    const c2 = dot$3(prevT, nextT);
     if (vLen > 1e-10) {
       const axis = scale$1(v, 1 / vLen);
       x2 = rotateVector(frames[i - 1].x, axis, c2, vLen);
@@ -19527,32 +19782,32 @@ function signedArea$2(loop) {
   }
   return area2 * 0.5;
 }
-function sub$2(a2, b) {
+function sub$3(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
-function add$1(a2, b) {
+function add$2(a2, b) {
   return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
 }
 function scale$1(v, s) {
   return [v[0] * s, v[1] * s, v[2] * s];
 }
-function dot$2(a2, b) {
+function dot$3(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
-function cross$2(a2, b) {
+function cross$3(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 length$1(v) {
   return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
 }
-function normalize$1(v) {
-  const len = length$1(v);
-  if (len < 1e-12) return null;
-  return [v[0] / len, v[1] / len, v[2] / len];
+function normalize$2(v) {
+  const len2 = length$1(v);
+  if (len2 < 1e-12) return null;
+  return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function rotateVector(v, axis, c2, s) {
-  const kDotV = dot$2(axis, v);
-  const kCrossV = cross$2(axis, v);
+  const kDotV = dot$3(axis, v);
+  const kCrossV = cross$3(axis, v);
   return [
     v[0] * c2 + kCrossV[0] * s + axis[0] * kDotV * (1 - c2),
     v[1] * c2 + kCrossV[1] * s + axis[1] * kDotV * (1 - c2),
@@ -19896,24 +20151,7 @@ function fromSlicesPlaneFrameForManifold(normalInput) {
 }
 function fromSlicesLocalToWorldMatrixForManifold(normal2) {
   const frame = fromSlicesPlaneFrameForManifold(normal2);
-  return [
-    frame.u[0],
-    frame.u[1],
-    frame.u[2],
-    0,
-    frame.v[0],
-    frame.v[1],
-    frame.v[2],
-    0,
-    frame.normal[0],
-    frame.normal[1],
-    frame.normal[2],
-    0,
-    0,
-    0,
-    0,
-    1
-  ];
+  return Transform.from(planeFrameToWorldToPlaneMatrix({ origin: [0, 0, 0], u: frame.u, v: frame.v, normal: frame.normal })).inverse().toArray();
 }
 function transformZAlignedFromSlicesPlanForManifold(base, normal2) {
   const matrix = fromSlicesLocalToWorldMatrixForManifold(normal2);
@@ -20502,35 +20740,41 @@ function lowerFromSlicesToManifold(plan, wasm) {
       solid = lowerSdfToManifold(levelSetFieldToStandardSdf3(input.sdf), input.bounds, input.edgeLength, wasm);
     }
   }
-  if (Math.abs(nx) > 1e-10 || Math.abs(ny) > 1e-10 || nz < 0) {
-    if (Math.abs(nx) < 1e-10 && Math.abs(ny) < 1e-10 && nz < 0) {
-      const prev = solid;
-      solid = solid.rotate([180, 0, 0]);
-      if (solid !== prev) disposeWasmObject(prev);
-    } else {
-      const ax = -ny;
-      const ay = nx;
-      const len = Math.sqrt(ax * ax + ay * ay);
-      const c2 = nz;
-      const s = len;
-      const ux = ax / len;
-      const uy = ay / len;
-      const m00 = c2 + ux * ux * (1 - c2);
-      const m01 = ux * uy * (1 - c2);
-      const m02 = uy * s;
-      const m10 = uy * ux * (1 - c2);
-      const m11 = c2 + uy * uy * (1 - c2);
-      const m12 = -ux * s;
-      const m20 = -uy * s;
-      const m21 = ux * s;
-      const m22 = c2;
-      const prev = solid;
-      solid = solid.transform([m00, m01, m02, 0, m10, m11, m12, 0, m20, m21, m22, 0, 0, 0, 0, 1]);
-      if (solid !== prev) disposeWasmObject(prev);
-    }
+  if (Math.abs(nx) > 1e-10 || Math.abs(ny) > 1e-10 || Math.abs(nz - 1) > 1e-10) {
+    const prev = solid;
+    solid = solid.transform(fromSlicesLocalToWorldMatrixForManifold(group.normal));
+    if (solid !== prev) disposeWasmObject(prev);
   }
   return solid;
 }
+function finiteVec3(value, context) {
+  if (value.some((component) => !Number.isFinite(component))) throw new Error(`${context} must contain finite numbers.`);
+  return [value[0], value[1], value[2]];
+}
+function lowerFromSectionFramesToManifold(plan, wasm) {
+  if (plan.slices.length < 2) throw new Error("Shape.fromSlices: framed section loft requires at least two slices.");
+  const profiles = plan.slices.map((s) => {
+    const crossSection = lowerProfileCompilePlanToCrossSection(s.profile, wasm);
+    try {
+      return crossSection.toPolygons();
+    } finally {
+      disposeWasmObject(crossSection);
+    }
+  });
+  const frames = plan.slices.map((s, index2) => ({
+    origin: finiteVec3(s.origin, `Shape.fromSlices framed slice ${index2} origin`),
+    normal: normalizeVec3$2(s.normal, `Shape.fromSlices framed slice ${index2} normal`),
+    xAxis: normalizeVec3$2(s.tangentU, `Shape.fromSlices framed slice ${index2} tangentU`),
+    yAxis: normalizeVec3$2(s.tangentV, `Shape.fromSlices framed slice ${index2} tangentV`)
+  }));
+  const stitched = loftStitchedOnFrames(profiles, frames, wasm, { edgeLength: plan.edgeLength });
+  if (!stitched) {
+    throw new Error(
+      "Shape.fromSlices: framed section loft could not be stitched into a manifold mesh. Check that every section has compatible closed profile topology and that adjacent frames do not self-intersect."
+    );
+  }
+  return stitched;
+}
 function lowerShapeVariableSweepCompilePlan(plan, wasm) {
   const sectionPolygons = plan.sections.map((s) => {
     const crossSection = lowerProfileCompilePlanToCrossSection(s.profile, wasm);
@@ -20725,6 +20969,9 @@ function selectEdgeSegmentsForFeature(segments, plan) {
   return matched;
 }
 function lowerFilletEdgesCompilePlan(plan, wasm) {
+  if (plan.variableRadius) {
+    throw new Error(`Variable-radius fillet requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
+  }
   let manifold = lowerShapeCompilePlanToManifold(plan.base, wasm);
   const mesh = manifold.getMesh();
   const segments = extractEdgeSegments({
@@ -20861,6 +21108,10 @@ function lowerShapeCompilePlanToManifold(plan, wasm) {
       return lowerFilletEdgesCompilePlan(plan, wasm);
     case "cornerYBlend":
       throw new Error(`Blend.CornerY() requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
+    case "faceFillet":
+      throw new Error(`Blend.Face() requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
+    case "fullRound":
+      throw new Error(`Blend.FullRound() requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
     case "chamferEdges":
       return lowerChamferEdgesCompilePlan(plan, wasm);
     case "draft": {
@@ -20890,6 +21141,8 @@ function lowerShapeCompilePlanToManifold(plan, wasm) {
     }
     case "fromSlices":
       return lowerFromSlicesToManifold(plan, wasm);
+    case "fromSectionFrames":
+      return lowerFromSectionFramesToManifold(plan, wasm);
     case "nurbsSurface":
       return lowerNurbsSurfaceToManifold(plan, wasm);
     case "analyticSurface":
@@ -22117,6 +22370,27 @@ function occtEdgeTouchesPoint(oc, edge, target, tolerance) {
   const end = curve.get().Value(last.current);
   return Math.min(occtPointDistance(start, target), occtPointDistance(end, target)) <= tolerance;
 }
+function occtEdgeLength(oc, edge) {
+  const adaptor = new oc.BRepAdaptor_Curve_2(edge);
+  return oc.GCPnts_AbscissaPoint.Length_1(adaptor);
+}
+function addFilletEdge(oc, mkFillet, edge, radius, variableRadius) {
+  if (!variableRadius) {
+    mkFillet.Add_2(radius, edge);
+    return;
+  }
+  if ("stations" in variableRadius) {
+    const length4 = occtEdgeLength(oc, edge);
+    const stations = variableRadius.stations;
+    const arr = new oc.TColgp_Array1OfPnt2d_2(1, stations.length);
+    for (let i = 0; i < stations.length; i++) {
+      arr.SetValue(i + 1, new oc.gp_Pnt2d_3(stations[i].at * length4, stations[i].radius));
+    }
+    mkFillet.Add_5(arr, edge);
+    return;
+  }
+  mkFillet.Add_3(variableRadius.start, variableRadius.end, edge);
+}
 function lowerFilletEdgesPlan$1(oc, plan) {
   const base = lowerShapeCompilePlanToOCCT(plan.base, oc);
   const mkFillet = new oc.BRepFilletAPI_MakeFillet(base, oc.ChFi3d_FilletShape.ChFi3d_Rational);
@@ -22127,7 +22401,7 @@ function lowerFilletEdgesPlan$1(oc, plan) {
   for (const target of selectOCCTEdgeFeatureTargets(base, plan)) {
     const matchedEdge = findOCCTEdgeByMidpoint(oc, base, target.midpoint);
     if (matchedEdge) {
-      mkFillet.Add_2(plan.radius, matchedEdge);
+      addFilletEdge(oc, mkFillet, matchedEdge, plan.radius, plan.variableRadius);
       addedCount++;
     }
   }
@@ -22136,7 +22410,55 @@ function lowerFilletEdgesPlan$1(oc, plan) {
   }
   mkFillet.Build(new oc.Message_ProgressRange_1());
   if (!mkFillet.IsDone()) {
-    throw new Error(`filletEdges(): OCCT fillet operation failed (radius=${plan.radius}, ${addedCount} edges).`);
+    const radiusDesc = plan.variableRadius ? `variableRadius(max=${maxVariableRadius(plan.variableRadius)})` : `radius=${plan.radius}`;
+    throw new Error(`filletEdges(): OCCT fillet operation failed (${radiusDesc}, ${addedCount} edges).`);
+  }
+  return mkFillet.Shape();
+}
+function lowerFaceFilletPlan(oc, plan) {
+  const base = lowerShapeCompilePlanToOCCT(plan.base, oc);
+  const mkFillet = new oc.BRepFilletAPI_MakeFillet(base, oc.ChFi3d_FilletShape.ChFi3d_Rational);
+  if (plan.continuity) {
+    mkFillet.SetContinuity(mapSurfaceContinuityToOcct(oc, plan.continuity), 2 * Math.PI / 180);
+  }
+  let addedCount = 0;
+  const touchedEdges = /* @__PURE__ */ new Set();
+  for (const target of plan.edgeTargets) {
+    const matchedEdge = findOCCTEdgeByMidpoint(oc, base, target.midpoint);
+    if (!matchedEdge || touchedEdges.has(matchedEdge)) continue;
+    addFilletEdge(oc, mkFillet, matchedEdge, plan.radius, plan.variableRadius);
+    touchedEdges.add(matchedEdge);
+    addedCount++;
+  }
+  if (addedCount === 0) {
+    throw new Error("Blend.Face(): no matching OCCT edges found shared by the face pair.");
+  }
+  mkFillet.Build(new oc.Message_ProgressRange_1());
+  if (!mkFillet.IsDone()) {
+    const radiusDesc = plan.variableRadius ? `variableRadius(max=${maxVariableRadius(plan.variableRadius)})` : `radius=${plan.radius}`;
+    throw new Error(`Blend.Face(): OCCT face fillet failed (${radiusDesc}, ${addedCount} shared edges).`);
+  }
+  return mkFillet.Shape();
+}
+function lowerFullRoundPlan(oc, plan) {
+  const base = lowerShapeCompilePlanToOCCT(plan.base, oc);
+  const mkFillet = new oc.BRepFilletAPI_MakeFillet(base, oc.ChFi3d_FilletShape.ChFi3d_Rational);
+  mkFillet.SetContinuity(mapSurfaceContinuityToOcct(oc, plan.continuity ?? "G1"), 2 * Math.PI / 180);
+  let addedCount = 0;
+  const touchedEdges = /* @__PURE__ */ new Set();
+  for (const target of plan.edgeTargets) {
+    const matchedEdge = findOCCTEdgeByMidpoint(oc, base, target.midpoint);
+    if (!matchedEdge || touchedEdges.has(matchedEdge)) continue;
+    mkFillet.Add_2(plan.radius, matchedEdge);
+    touchedEdges.add(matchedEdge);
+    addedCount++;
+  }
+  if (addedCount === 0) {
+    throw new Error("Blend.FullRound(): no matching OCCT edges found around the center face.");
+  }
+  mkFillet.Build(new oc.Message_ProgressRange_1());
+  if (!mkFillet.IsDone()) {
+    throw new Error(`Blend.FullRound(): OCCT full round failed (radius=${plan.radius}, ${addedCount} edges).`);
   }
   return mkFillet.Shape();
 }
@@ -22409,6 +22731,10 @@ function _lowerShapeCompilePlanToOCCTInner(plan, oc) {
       return lowerChamferPlan(oc, plan);
     case "filletEdges":
       return lowerFilletEdgesPlan$1(oc, plan);
+    case "faceFillet":
+      return lowerFaceFilletPlan(oc, plan);
+    case "fullRound":
+      return lowerFullRoundPlan(oc, plan);
     case "cornerYBlend":
       return lowerCornerYBlendPlan$1(oc, plan);
     case "chamferEdges":
@@ -22708,8 +23034,10 @@ function lowerSurfaceRuledPlan$1(oc, plan) {
   return sections.Shape();
 }
 function lowerSurfaceFillPlan$1(oc, plan) {
+  var _a3, _b3;
   const hasSupport = plan.boundaries.some((boundary) => boundary.support != null);
-  if (!hasSupport && (plan.boundaries.length === 3 || plan.boundaries.length === 4)) {
+  const hasInteriorConstraints = (((_a3 = plan.interiorCurves) == null ? void 0 : _a3.length) ?? 0) > 0 || (((_b3 = plan.interiorPoints) == null ? void 0 : _b3.length) ?? 0) > 0;
+  if (!hasSupport && !hasInteriorConstraints && (plan.boundaries.length === 3 || plan.boundaries.length === 4)) {
     try {
       const handles = plan.boundaries.map(
         (boundary, index2) => buildBSplineCurveHandleFromSweepPathPlan(
@@ -22739,6 +23067,13 @@ function lowerSurfaceFillPlan$1(oc, plan) {
       filling.Add_1(edge, oc.GeomAbs_Shape.GeomAbs_C0, true);
     }
   }
+  for (const interior of plan.interiorCurves ?? []) {
+    const edge = buildCurveEdgeFromSweepPathPlan(oc, interior.curve, "Surface.Fill(through)", plan.allowApproximation);
+    filling.Add_1(edge, mapSurfaceContinuityToOcct(oc, interior.continuity), false);
+  }
+  for (const point2 of plan.interiorPoints ?? []) {
+    filling.Add_4(new oc.gp_Pnt_3(point2[0], point2[1], point2[2]));
+  }
   filling.Build(new oc.Message_ProgressRange_1());
   if (!filling.IsDone()) {
     throw new Error("Surface.Fill(): OCCT failed to build the constrained filling surface.");
@@ -23288,9 +23623,9 @@ function crossVec3$1(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 normalizeVec3$1(v) {
-  const len = Math.hypot(v[0], v[1], v[2]);
-  if (len < 1e-10) return null;
-  return [v[0] / len, v[1] / len, v[2] / len];
+  const len2 = Math.hypot(v[0], v[1], v[2]);
+  if (len2 < 1e-10) return null;
+  return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function buildSweepStartFrame(tangent, preferredUp) {
   let up = normalizeVec3$1(preferredUp) ?? [0, 0, 1];
@@ -23722,15 +24057,15 @@ function meshTriangles(mesh) {
   }
   return out;
 }
-function sub$1(a2, b) {
+function sub$2(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
 function scaleAdd(a2, b, scale2) {
   return [a2[0] + b[0] * scale2, a2[1] + b[1] * scale2, a2[2] + b[2] * scale2];
 }
 function distanceSqToSegment(p2, a2, b) {
-  const ab = sub$1(b, a2);
-  const t = Math.max(0, Math.min(1, dot3$3(sub$1(p2, a2), ab) / Math.max(dot3$3(ab, ab), 1e-20)));
+  const ab = sub$2(b, a2);
+  const t = Math.max(0, Math.min(1, dot3$3(sub$2(p2, a2), ab) / Math.max(dot3$3(ab, ab), 1e-20)));
   const q = scaleAdd(a2, ab, t);
   const dx = p2[0] - q[0];
   const dy = p2[1] - q[1];
@@ -23738,19 +24073,19 @@ function distanceSqToSegment(p2, a2, b) {
   return dx * dx + dy * dy + dz * dz;
 }
 function distanceSqToTriangle(p2, tri) {
-  const ab = sub$1(tri.b, tri.a);
-  const ac = sub$1(tri.c, tri.a);
-  const ap = sub$1(p2, tri.a);
+  const ab = sub$2(tri.b, tri.a);
+  const ac = sub$2(tri.c, tri.a);
+  const ap = sub$2(p2, tri.a);
   const d1 = dot3$3(ab, ap);
   const d2 = dot3$3(ac, ap);
   if (d1 <= 0 && d2 <= 0) return dot3$3(ap, ap);
-  const bp = sub$1(p2, tri.b);
+  const bp = sub$2(p2, tri.b);
   const d3 = dot3$3(ab, bp);
   const d4 = dot3$3(ac, bp);
   if (d3 >= 0 && d4 <= d3) return dot3$3(bp, bp);
   const vc = d1 * d4 - d3 * d2;
   if (vc <= 0 && d1 >= 0 && d3 <= 0) return distanceSqToSegment(p2, tri.a, tri.b);
-  const cp = sub$1(p2, tri.c);
+  const cp = sub$2(p2, tri.c);
   const d5 = dot3$3(ab, cp);
   const d6 = dot3$3(ac, cp);
   if (d6 >= 0 && d5 <= d6) return dot3$3(cp, cp);
@@ -23765,13 +24100,13 @@ function distanceSqToTriangle(p2, tri) {
 }
 function rayHitsTriangleX(p2, tri) {
   const dir = [1, 0, 0];
-  const e1 = sub$1(tri.b, tri.a);
-  const e2 = sub$1(tri.c, tri.a);
+  const e1 = sub$2(tri.b, tri.a);
+  const e2 = sub$2(tri.c, tri.a);
   const h = [0, -e2[2], e2[1]];
   const det = dot3$3(e1, h);
   if (Math.abs(det) < 1e-10) return false;
   const inv = 1 / det;
-  const s = sub$1(p2, tri.a);
+  const s = sub$2(p2, tri.a);
   const u2 = inv * dot3$3(s, h);
   if (u2 < 0 || u2 > 1) return false;
   const q = [s[1] * e1[2] - s[2] * e1[1], s[2] * e1[0] - s[0] * e1[2], s[0] * e1[1] - s[1] * e1[0]];
@@ -24146,7 +24481,16 @@ function stitchBoundaryLoop(boundaries, tolerance) {
   };
   return tryStitch(boundaries[0], boundaries.slice(1)) ?? tryStitch(reversePoints$1(boundaries[0]), boundaries.slice(1));
 }
+function rejectSdfInteriorConstraints(plan) {
+  var _a3, _b3;
+  if ((((_a3 = plan.interiorCurves) == null ? void 0 : _a3.length) ?? 0) > 0 || (((_b3 = plan.interiorPoints) == null ? void 0 : _b3.length) ?? 0) > 0) {
+    throw new Error(
+      "SDF backend cannot build a Surface.Fill() with interior constraint curves/points. Use the OCCT backend for constrained fills."
+    );
+  }
+}
 function sampledFillBoundaryLoop(plan) {
+  rejectSdfInteriorConstraints(plan);
   if (plan.boundaries.length < 3) throw new Error("SDF backend sampled Surface.Fill() requires at least three boundary curves.");
   const rawBoundaries = plan.boundaries.map((boundary) => sampleSurfaceCurve$1(boundary.curve, plan.resolution));
   const tolerance = pointTolerance(rawBoundaries.flat());
@@ -24172,6 +24516,7 @@ function hasUnconstrainedCoonsFillBoundaries(plan) {
   return !!namedBoundaryCurve$1(plan, "v0") && !!namedBoundaryCurve$1(plan, "u1") && !!namedBoundaryCurve$1(plan, "v1") && !!namedBoundaryCurve$1(plan, "u0") && !plan.boundaries.some((boundary) => boundary.support);
 }
 function surfaceGridForFillPlan$1(plan) {
+  rejectSdfInteriorConstraints(plan);
   const bottomCurve = namedBoundaryCurve$1(plan, "v0");
   const rightCurve = namedBoundaryCurve$1(plan, "u1");
   const topCurve = namedBoundaryCurve$1(plan, "v1");
@@ -28604,7 +28949,7 @@ function requireClipper() {
           ClipperLib2.Error("DoMaxima error");
       };
       ClipperLib2.Clipper.ReversePaths = function(polys) {
-        for (var i = 0, len = polys.length; i < len; i++)
+        for (var i = 0, len2 = polys.length; i < len2; i++)
           polys[i].reverse();
       };
       ClipperLib2.Clipper.Orientation = function(poly) {
@@ -29599,11 +29944,11 @@ function requireClipper() {
         for (var i = 0; i < this.m_polyNodes.ChildCount(); i++) {
           var node = this.m_polyNodes.Childs()[i];
           this.m_srcPoly = node.m_polygon;
-          var len = this.m_srcPoly.length;
-          if (len === 0 || delta <= 0 && (len < 3 || node.m_endtype !== ClipperLib2.EndType.etClosedPolygon))
+          var len2 = this.m_srcPoly.length;
+          if (len2 === 0 || delta <= 0 && (len2 < 3 || node.m_endtype !== ClipperLib2.EndType.etClosedPolygon))
             continue;
           this.m_destPoly = new Array();
-          if (len === 1) {
+          if (len2 === 1) {
             if (node.m_jointype === ClipperLib2.JoinType.jtRound) {
               var X = 1, Y = 0;
               for (var j = 1; j <= steps; j++) {
@@ -29628,45 +29973,45 @@ function requireClipper() {
             continue;
           }
           this.m_normals.length = 0;
-          for (var j = 0; j < len - 1; j++)
+          for (var j = 0; j < len2 - 1; j++)
             this.m_normals.push(ClipperLib2.ClipperOffset.GetUnitNormal(this.m_srcPoly[j], this.m_srcPoly[j + 1]));
           if (node.m_endtype === ClipperLib2.EndType.etClosedLine || node.m_endtype === ClipperLib2.EndType.etClosedPolygon)
-            this.m_normals.push(ClipperLib2.ClipperOffset.GetUnitNormal(this.m_srcPoly[len - 1], this.m_srcPoly[0]));
+            this.m_normals.push(ClipperLib2.ClipperOffset.GetUnitNormal(this.m_srcPoly[len2 - 1], this.m_srcPoly[0]));
           else
-            this.m_normals.push(new ClipperLib2.DoublePoint1(this.m_normals[len - 2]));
+            this.m_normals.push(new ClipperLib2.DoublePoint1(this.m_normals[len2 - 2]));
           if (node.m_endtype === ClipperLib2.EndType.etClosedPolygon) {
-            var k2 = len - 1;
-            for (var j = 0; j < len; j++)
+            var k2 = len2 - 1;
+            for (var j = 0; j < len2; j++)
               k2 = this.OffsetPoint(j, k2, node.m_jointype);
             this.m_destPolys.push(this.m_destPoly);
           } else if (node.m_endtype === ClipperLib2.EndType.etClosedLine) {
-            var k2 = len - 1;
-            for (var j = 0; j < len; j++)
+            var k2 = len2 - 1;
+            for (var j = 0; j < len2; j++)
               k2 = this.OffsetPoint(j, k2, node.m_jointype);
             this.m_destPolys.push(this.m_destPoly);
             this.m_destPoly = new Array();
-            var n = this.m_normals[len - 1];
-            for (var j = len - 1; j > 0; j--)
+            var n = this.m_normals[len2 - 1];
+            for (var j = len2 - 1; j > 0; j--)
               this.m_normals[j] = new ClipperLib2.DoublePoint2(-this.m_normals[j - 1].X, -this.m_normals[j - 1].Y);
             this.m_normals[0] = new ClipperLib2.DoublePoint2(-n.X, -n.Y);
             k2 = 0;
-            for (var j = len - 1; j >= 0; j--)
+            for (var j = len2 - 1; j >= 0; j--)
               k2 = this.OffsetPoint(j, k2, node.m_jointype);
             this.m_destPolys.push(this.m_destPoly);
           } else {
             var k2 = 0;
-            for (var j = 1; j < len - 1; ++j)
+            for (var j = 1; j < len2 - 1; ++j)
               k2 = this.OffsetPoint(j, k2, node.m_jointype);
             var pt1;
             if (node.m_endtype === ClipperLib2.EndType.etOpenButt) {
-              var j = len - 1;
+              var j = len2 - 1;
               pt1 = new ClipperLib2.IntPoint2(ClipperLib2.ClipperOffset.Round(this.m_srcPoly[j].X + this.m_normals[j].X * delta), ClipperLib2.ClipperOffset.Round(this.m_srcPoly[j].Y + this.m_normals[j].Y * delta));
               this.m_destPoly.push(pt1);
               pt1 = new ClipperLib2.IntPoint2(ClipperLib2.ClipperOffset.Round(this.m_srcPoly[j].X - this.m_normals[j].X * delta), ClipperLib2.ClipperOffset.Round(this.m_srcPoly[j].Y - this.m_normals[j].Y * delta));
               this.m_destPoly.push(pt1);
             } else {
-              var j = len - 1;
-              k2 = len - 2;
+              var j = len2 - 1;
+              k2 = len2 - 2;
               this.m_sinA = 0;
               this.m_normals[j] = new ClipperLib2.DoublePoint2(-this.m_normals[j].X, -this.m_normals[j].Y);
               if (node.m_endtype === ClipperLib2.EndType.etOpenSquare)
@@ -29674,10 +30019,10 @@ function requireClipper() {
               else
                 this.DoRound(j, k2);
             }
-            for (var j = len - 1; j > 0; j--)
+            for (var j = len2 - 1; j > 0; j--)
               this.m_normals[j] = new ClipperLib2.DoublePoint2(-this.m_normals[j - 1].X, -this.m_normals[j - 1].Y);
             this.m_normals[0] = new ClipperLib2.DoublePoint2(-this.m_normals[1].X, -this.m_normals[1].Y);
-            k2 = len - 1;
+            k2 = len2 - 1;
             for (var j = k2 - 1; j > 0; --j)
               k2 = this.OffsetPoint(j, k2, node.m_jointype);
             if (node.m_endtype === ClipperLib2.EndType.etOpenButt) {
@@ -29881,13 +30226,13 @@ function requireClipper() {
         if (polygon.length === 0 || polygon.length === 1 && polygon[0].length === 0 || delta < 0) return polygon;
         if (!isPolygons) polygon = [polygon];
         var k_length = polygon.length;
-        var len, poly, result, d2, p2, j, i;
+        var len2, poly, result, d2, p2, j, i;
         var results = [];
         for (var k2 = 0; k2 < k_length; k2++) {
           poly = polygon[k2];
-          len = poly.length;
-          if (len === 0) continue;
-          else if (len < 3) {
+          len2 = poly.length;
+          if (len2 === 0) continue;
+          else if (len2 < 3) {
             result = poly;
             results.push(result);
             continue;
@@ -29896,7 +30241,7 @@ function requireClipper() {
           d2 = delta * delta;
           p2 = poly[0];
           j = 1;
-          for (i = 1; i < len; i++) {
+          for (i = 1; i < len2; i++) {
             if ((poly[i].X - p2.X) * (poly[i].X - p2.X) + (poly[i].Y - p2.Y) * (poly[i].Y - p2.Y) <= d2)
               continue;
             result[j] = poly[i];
@@ -29906,8 +30251,8 @@ function requireClipper() {
           p2 = poly[j - 1];
           if ((poly[0].X - p2.X) * (poly[0].X - p2.X) + (poly[0].Y - p2.Y) * (poly[0].Y - p2.Y) <= d2)
             j--;
-          if (j < len)
-            result.splice(j, len - j);
+          if (j < len2)
+            result.splice(j, len2 - j);
           if (result.length) results.push(result);
         }
         if (!isPolygons && results.length) results = results[0];
@@ -29925,9 +30270,9 @@ function requireClipper() {
         ];
         var isPolygons = polygon[0] instanceof Array;
         if (!isPolygons) polygon = [polygon];
-        var len = polygon.length, plen, i, j, result;
-        var results = new Array(len);
-        for (i = 0; i < len; i++) {
+        var len2 = polygon.length, plen, i, j, result;
+        var results = new Array(len2);
+        for (i = 0; i < len2; i++) {
           plen = polygon[i].length;
           result = new Array(plen);
           for (j = 0; j < plen; j++) {
@@ -29954,10 +30299,10 @@ function requireClipper() {
         if (!isPolygons) polygon = [polygon];
         var i, j, poly, k2, poly2, plen, A, B2, P, d2, rem, addlast;
         var bxax, byay, l, ax, ay;
-        var len = polygon.length;
+        var len2 = polygon.length;
         var toleranceSq = tolerance * tolerance;
         var results = [];
-        for (i = 0; i < len; i++) {
+        for (i = 0; i < len2; i++) {
           poly = polygon[i];
           plen = poly.length;
           if (plen === 0) continue;
@@ -32229,7 +32574,7 @@ function key(point2) {
   const clean = (value) => (Math.abs(value) < 5e-8 ? 0 : value).toFixed(7);
   return `${clean(point2[0])},${clean(point2[1])}`;
 }
-function edgeKey$1(a2, b) {
+function edgeKey$2(a2, b) {
   return a2 < b ? `${a2}|${b}` : `${b}|${a2}`;
 }
 function loopsFromSegments$1(segments) {
@@ -32250,18 +32595,18 @@ function loopsFromSegments$1(segments) {
   const loops = [];
   for (const start of adjacency.keys()) {
     for (const first of adjacency.get(start) ?? []) {
-      if (visited.has(edgeKey$1(start, first))) continue;
+      if (visited.has(edgeKey$2(start, first))) continue;
       const loop = [start];
       let previous = start;
       let current = first;
-      visited.add(edgeKey$1(start, first));
+      visited.add(edgeKey$2(start, first));
       while (current !== start) {
         loop.push(current);
         const next = Array.from(adjacency.get(current) ?? []).find(
-          (candidate) => candidate !== previous && !visited.has(edgeKey$1(current, candidate))
+          (candidate) => candidate !== previous && !visited.has(edgeKey$2(current, candidate))
         );
         if (!next) break;
-        visited.add(edgeKey$1(current, next));
+        visited.add(edgeKey$2(current, next));
         previous = current;
         current = next;
       }
@@ -32948,11 +33293,11 @@ function triangulateStepFace(face, filePath) {
     const a2 = allPoints[ia];
     const b = allPoints[ib];
     const c2 = allPoints[ic];
-    const triNormal = cross3$4(sub3$2(b, a2), sub3$2(c2, a2));
-    if (Math.hypot(triNormal[0], triNormal[1], triNormal[2]) <= EPS$2) {
+    const triNormal2 = cross3$4(sub3$2(b, a2), sub3$2(c2, a2));
+    if (Math.hypot(triNormal2[0], triNormal2[1], triNormal2[2]) <= EPS$2) {
       failStepImport(filePath, `${face.context} triangulates to a degenerate triangle.`);
     }
-    return dot3$3(triNormal, normal2) >= 0 ? [a2, b, c2] : [a2, c2, b];
+    return dot3$3(triNormal2, normal2) >= 0 ? [a2, b, c2] : [a2, c2, b];
   });
 }
 const EPS$1 = 1e-6;
@@ -36094,6 +36439,8 @@ function lowerShapeCompilePlanToSdfField(plan) {
     }
     case "fromSlices":
       return lowerFromSlices(plan);
+    case "fromSectionFrames":
+      throw new Error("Shape.fromSlices framed section lofts require the Manifold backend.");
     case "fillet":
       throwSdfEdgeFeatureUnsupported("fillet()");
     case "chamfer":
@@ -36102,6 +36449,10 @@ function lowerShapeCompilePlanToSdfField(plan) {
       throwSdfEdgeFeatureUnsupported("filletEdges()");
     case "cornerYBlend":
       throwSdfEdgeFeatureUnsupported("Blend.CornerY()");
+    case "faceFillet":
+      throwSdfEdgeFeatureUnsupported("Blend.Face()");
+    case "fullRound":
+      throwSdfEdgeFeatureUnsupported("Blend.FullRound()");
     case "chamferEdges":
       throwSdfEdgeFeatureUnsupported("chamferEdges()");
     case "nurbsSurface":
@@ -36404,10 +36755,10 @@ function transformProfilePoint(point2, transform) {
     case "mirror": {
       const nx = transform.normalX;
       const ny = transform.normalY;
-      const len = Math.hypot(nx, ny);
-      if (len <= EPS) return point2;
-      const ux = nx / len;
-      const uy = ny / len;
+      const len2 = Math.hypot(nx, ny);
+      if (len2 <= EPS) return point2;
+      const ux = nx / len2;
+      const uy = ny / len2;
       const d2 = point2[0] * ux + point2[1] * uy;
       return [point2[0] - 2 * d2 * ux, point2[1] - 2 * d2 * uy];
     }
@@ -36899,10 +37250,10 @@ class TruckPolygonProfileBackend {
   }
   mirror(ax) {
     const [nx0, ny0] = ax;
-    const len = Math.hypot(nx0, ny0);
-    if (len <= 1e-12) return wrapTruckProfileRegions(this.regions);
-    const nx = nx0 / len;
-    const ny = ny0 / len;
+    const len2 = Math.hypot(nx0, ny0);
+    if (len2 <= 1e-12) return wrapTruckProfileRegions(this.regions);
+    const nx = nx0 / len2;
+    const ny = ny0 / len2;
     return wrapTruckProfileRegions(
       transformRegions(this.regions, ([x2, y2]) => {
         const d2 = 2 * (x2 * nx + y2 * ny);
@@ -36981,23 +37332,23 @@ function boundsInteriorOverlap$1(a2, b) {
   return Math.min(a2.max[0], b.max[0]) - Math.max(a2.min[0], b.min[0]) > tolerance && Math.min(a2.max[1], b.max[1]) - Math.max(a2.min[1], b.min[1]) > tolerance && Math.min(a2.max[2], b.max[2]) - Math.max(a2.min[2], b.min[2]) > tolerance;
 }
 function normalizeVec3(v) {
-  const len = Math.hypot(v[0], v[1], v[2]);
-  if (len <= 1e-12) return [0, 0, 0];
-  return [v[0] / len, v[1] / len, v[2] / len];
+  const len2 = Math.hypot(v[0], v[1], v[2]);
+  if (len2 <= 1e-12) return [0, 0, 0];
+  return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
-function dot$1(a2, b) {
+function dot$2(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
-function add(a2, b) {
+function add$1(a2, b) {
   return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
 }
-function sub(a2, b) {
+function sub$1(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
 function scale(v, scalar) {
   return [v[0] * scalar, v[1] * scalar, v[2] * scalar];
 }
-function cross$1(a2, b) {
+function cross$2(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 isFiniteNumber(value) {
@@ -37017,7 +37368,7 @@ function axisSpan(face, axis) {
   let min2 = Infinity;
   let max2 = -Infinity;
   for (const vertex2 of face.vertices) {
-    const station = dot$1(vertex2, axis);
+    const station = dot$2(vertex2, axis);
     min2 = Math.min(min2, station);
     max2 = Math.max(max2, station);
   }
@@ -37233,8 +37584,8 @@ function boundsCorners(bounds) {
 }
 function perpendicularAxes(normal2) {
   const seed = Math.abs(normal2[2]) < 0.9 ? [0, 0, 1] : [0, 1, 0];
-  const uAxis = normalizeVec3(cross$1(seed, normal2));
-  const vAxis = normalizeVec3(cross$1(normal2, uAxis));
+  const uAxis = normalizeVec3(cross$2(seed, normal2));
+  const vAxis = normalizeVec3(cross$2(normal2, uAxis));
   return { uAxis, vAxis };
 }
 function createBoundedHalfSpace(bounds, normal2, originOffset) {
@@ -37253,10 +37604,10 @@ function createBoundedHalfSpace(bounds, normal2, originOffset) {
   let maxV = -Infinity;
   let maxDistance = -Infinity;
   for (const corner of corners) {
-    const relative = sub(corner, planeOrigin);
-    const u2 = dot$1(relative, uAxis);
-    const v = dot$1(relative, vAxis);
-    const distance = dot$1(corner, n) - signedOffset;
+    const relative = sub$1(corner, planeOrigin);
+    const u2 = dot$2(relative, uAxis);
+    const v = dot$2(relative, vAxis);
+    const distance = dot$2(corner, n) - signedOffset;
     minU = Math.min(minU, u2);
     maxU = Math.max(maxU, u2);
     minV = Math.min(minV, v);
@@ -37268,7 +37619,7 @@ function createBoundedHalfSpace(bounds, normal2, originOffset) {
   const height = Math.max(maxDistance + margin, margin);
   const centerU = (minU + maxU) / 2;
   const centerV = (minV + maxV) / 2;
-  const translation = add(add(planeOrigin, scale(uAxis, centerU)), scale(vAxis, centerV));
+  const translation = add$1(add$1(planeOrigin, scale(uAxis, centerU)), scale(vAxis, centerV));
   const matrix = [
     uAxis[0],
     uAxis[1],
@@ -37302,7 +37653,7 @@ function faceAxes(face) {
   for (const vertex2 of face.vertices.slice(1)) {
     const uAxis = normalizeVec3([vertex2[0] - origin[0], vertex2[1] - origin[1], vertex2[2] - origin[2]]);
     if (Math.hypot(...uAxis) <= 1e-12) continue;
-    const vAxis = normalizeVec3(cross$1(face.normal, uAxis));
+    const vAxis = normalizeVec3(cross$2(face.normal, uAxis));
     if (Math.hypot(...vAxis) <= 1e-12) continue;
     return {
       uAxis,
@@ -37311,18 +37662,18 @@ function faceAxes(face) {
   }
   return {};
 }
-function edgeKey(start, end) {
+function edgeKey$1(start, end) {
   const encode = (p2) => p2.map((value) => value.toFixed(9)).join(",");
   const a2 = encode(start);
   const b = encode(end);
   return a2 < b ? `${a2}|${b}` : `${b}|${a2}`;
 }
 function faceEdgeIndex(face, start, end) {
-  const target = edgeKey(start, end);
+  const target = edgeKey$1(start, end);
   for (let i = 0; i < face.vertices.length; i++) {
     const faceStart = face.vertices[i];
     const faceEnd = face.vertices[(i + 1) % face.vertices.length];
-    if (faceStart && faceEnd && edgeKey(faceStart, faceEnd) === target) return i;
+    if (faceStart && faceEnd && edgeKey$1(faceStart, faceEnd) === target) return i;
   }
   return null;
 }
@@ -37523,7 +37874,7 @@ function topologyPayloadToTopology(payload) {
     const start = explicitVertices[explicitEdge.vertices[0]];
     const end = explicitVertices[explicitEdge.vertices[1]];
     if (!isVec3(start) || !isVec3(end)) continue;
-    const key2 = edgeKey(start, end);
+    const key2 = edgeKey$1(start, end);
     if (seenEdges.has(key2)) continue;
     seenEdges.set(key2, edges.size);
     const display = explicitEdgeDisplayName(payload, explicitEdge, explicitEdgeIndex, start, end);
@@ -37543,7 +37894,7 @@ function topologyPayloadToTopology(payload) {
         const start = face.vertices[i];
         const end = face.vertices[(i + 1) % face.vertices.length];
         if (!start || !end) continue;
-        const key2 = edgeKey(start, end);
+        const key2 = edgeKey$1(start, end);
         if (seenEdges.has(key2)) continue;
         seenEdges.set(key2, edges.size);
         edges.set(`${face.id}:edge-${i}`, {
@@ -37592,11 +37943,11 @@ const _TruckShapeBackend = class _TruckShapeBackend {
   }
   mirror(normal2) {
     const [nx0, ny0, nz0] = normal2;
-    const len = Math.hypot(nx0, ny0, nz0);
-    if (len < 1e-12) return this.clone();
-    const nx = nx0 / len;
-    const ny = ny0 / len;
-    const nz = nz0 / len;
+    const len2 = Math.hypot(nx0, ny0, nz0);
+    if (len2 < 1e-12) return this.clone();
+    const nx = nx0 / len2;
+    const ny = ny0 / len2;
+    const nz = nz0 / len2;
     const matrix = [
       1 - 2 * nx * nx,
       -2 * ny * nx,
@@ -37638,7 +37989,7 @@ const _TruckShapeBackend = class _TruckShapeBackend {
     if (normalLength <= 1e-12) throw new Error("Truck trimByPlane() normal vector must not be zero.");
     const n = [normal2[0] / normalLength, normal2[1] / normalLength, normal2[2] / normalLength];
     const signedOffset = originOffset / normalLength;
-    const distances = boundsCorners(bounds).map((corner) => dot$1(corner, n) - signedOffset);
+    const distances = boundsCorners(bounds).map((corner) => dot$2(corner, n) - signedOffset);
     if (distances.every((distance) => distance >= -1e-8)) return this.clone();
     if (distances.every((distance) => distance <= 1e-8)) return new _TruckShapeBackend(wasm.geometry_create_empty());
     const halfSpace = createBoundedHalfSpace(bounds, normal2, originOffset);
@@ -37785,10 +38136,10 @@ function applyProfileTransformPoint(point2, step) {
     case "scale":
       return [x2 * step.x, y2 * step.y];
     case "mirror": {
-      const len = Math.hypot(step.normalX, step.normalY);
-      if (len < 1e-12) return [x2, y2];
-      const nx = step.normalX / len;
-      const ny = step.normalY / len;
+      const len2 = Math.hypot(step.normalX, step.normalY);
+      if (len2 < 1e-12) return [x2, y2];
+      const nx = step.normalX / len2;
+      const ny = step.normalY / len2;
       const d2 = x2 * nx + y2 * ny;
       return [x2 - 2 * d2 * nx, y2 - 2 * d2 * ny];
     }
@@ -39715,6 +40066,9 @@ function applyNativeTruckFilletTargets(initialShape, targets, radius, segments,
   }
 }
 function lowerFilletEdgesPlan(plan) {
+  if (plan.variableRadius) {
+    throw new Error("Variable-radius fillet requires the OCCT backend. Run the CLI with --backend occt.");
+  }
   if (plan.edgeQuery) {
     throw new Error("filletEdges(): deferred edge queries are not supported by the Truck lowerer yet.");
   }
@@ -40250,11 +40604,11 @@ function applyShapeTransformToPoint(point2, step) {
         point2
       );
     case "mirror": {
-      const len = Math.hypot(step.normalX, step.normalY, step.normalZ);
-      if (len < 1e-12) return [point2[0], point2[1], point2[2]];
-      const nx = step.normalX / len;
-      const ny = step.normalY / len;
-      const nz = step.normalZ / len;
+      const len2 = Math.hypot(step.normalX, step.normalY, step.normalZ);
+      if (len2 < 1e-12) return [point2[0], point2[1], point2[2]];
+      const nx = step.normalX / len2;
+      const ny = step.normalY / len2;
+      const nz = step.normalZ / len2;
       const d2 = point2[0] * nx + point2[1] * ny + point2[2] * nz;
       return [point2[0] - 2 * d2 * nx, point2[1] - 2 * d2 * ny, point2[2] - 2 * d2 * nz];
     }
@@ -40335,9 +40689,9 @@ function triangleNormal(vertices, triangle) {
   const ab = [b[0] - a2[0], b[1] - a2[1], b[2] - a2[2]];
   const ac = [c2[0] - a2[0], c2[1] - a2[1], c2[2] - a2[2]];
   const normal2 = cross3$3(ab, ac);
-  const len = Math.hypot(normal2[0], normal2[1], normal2[2]);
-  if (len <= 1e-12) return null;
-  return [normal2[0] / len, normal2[1] / len, normal2[2] / len];
+  const len2 = Math.hypot(normal2[0], normal2[1], normal2[2]);
+  if (len2 <= 1e-12) return null;
+  return [normal2[0] / len2, normal2[1] / len2, normal2[2] / len2];
 }
 function offsetClosedSurfaceMesh(mesh, thickness) {
   let triangles;
@@ -40361,12 +40715,12 @@ function offsetClosedSurfaceMesh(mesh, thickness) {
   }
   const offsetVertices = mesh.vertices.map((vertex2, index2) => {
     const normal2 = normals[index2];
-    const len = Math.hypot(normal2[0], normal2[1], normal2[2]);
-    if (len <= 1e-12) return [vertex2[0], vertex2[1], vertex2[2]];
+    const len2 = Math.hypot(normal2[0], normal2[1], normal2[2]);
+    if (len2 <= 1e-12) return [vertex2[0], vertex2[1], vertex2[2]];
     return [
-      vertex2[0] - normal2[0] / len * thickness,
-      vertex2[1] - normal2[1] / len * thickness,
-      vertex2[2] - normal2[2] / len * thickness
+      vertex2[0] - normal2[0] / len2 * thickness,
+      vertex2[1] - normal2[1] / len2 * thickness,
+      vertex2[2] - normal2[2] / len2 * thickness
     ];
   });
   const innerOffset = mesh.vertices.length;
@@ -40425,6 +40779,10 @@ function lowerSurfaceRuledPlan(plan) {
   return lowerSurfaceGrid(surfaceGridForRuledPlan(plan));
 }
 function lowerSurfaceFillPlan(plan) {
+  var _a3, _b3;
+  if ((((_a3 = plan.interiorCurves) == null ? void 0 : _a3.length) ?? 0) > 0 || (((_b3 = plan.interiorPoints) == null ? void 0 : _b3.length) ?? 0) > 0) {
+    truckUnsupported("surface fill with interior constraint curves/points");
+  }
   const grid = surfaceGridForFillPlan(plan);
   if (!grid) truckUnsupported("surface fill constraints beyond four-boundary Coons patches");
   return lowerSurfaceGrid(grid);
@@ -40701,6 +41059,10 @@ function lowerShapeCompilePlanToTruckBackendUncached(plan) {
       return lowerChamferEdgesPlan(plan);
     case "cornerYBlend":
       return lowerCornerYBlendPlan();
+    case "faceFillet":
+      throw new Error("Blend.Face() requires the OCCT backend. Run the CLI with --backend occt.");
+    case "fullRound":
+      throw new Error("Blend.FullRound() requires the OCCT backend. Run the CLI with --backend occt.");
     case "draft":
       return lowerDraftPlan(plan);
     case "shell":
@@ -41044,10 +41406,10 @@ function transformProfilePointForRadial(point2, transform) {
       return [point2[0] * c2 - point2[1] * s, point2[0] * s + point2[1] * c2];
     }
     case "mirror": {
-      const len = Math.hypot(transform.normalX, transform.normalY);
-      if (len <= EXACT_PROFILE_EPS) return null;
-      const nx = transform.normalX / len;
-      const ny = transform.normalY / len;
+      const len2 = Math.hypot(transform.normalX, transform.normalY);
+      if (len2 <= EXACT_PROFILE_EPS) return null;
+      const nx = transform.normalX / len2;
+      const ny = transform.normalY / len2;
       const d2 = point2[0] * nx + point2[1] * ny;
       return [point2[0] - 2 * d2 * nx, point2[1] - 2 * d2 * ny];
     }
@@ -43296,6 +43658,8 @@ function exactVerticalProjectionProfilePlan(plan) {
       const equivalent = zAlignedFromSlicesShapePlan(plan);
       return equivalent ? exactVerticalProjectionProfilePlan(equivalent) : null;
     }
+    case "fromSectionFrames":
+      return null;
     case "transform": {
       const base = exactVerticalProjectionProfilePlan(plan.base);
       if (!base) return null;
@@ -43736,6 +44100,8 @@ function exactTruckProjectedProfilePlan(plan) {
       const equivalent = zAlignedFromSlicesShapePlan(plan);
       return equivalent ? exactTruckProjectedProfilePlan(equivalent) : null;
     }
+    case "fromSectionFrames":
+      return null;
     case "sheetMetal":
     case "shell":
     case "hole":
@@ -43745,6 +44111,8 @@ function exactTruckProjectedProfilePlan(plan) {
     case "chamfer":
     case "filletEdges":
     case "cornerYBlend":
+    case "faceFillet":
+    case "fullRound":
     case "chamferEdges":
     case "draft":
     case "importedMesh":
@@ -43884,6 +44252,8 @@ function exactTruckSlicedProfilePlan(plan, offset) {
       const equivalent = zAlignedFromSlicesShapePlan(plan);
       return equivalent ? exactTruckSlicedProfilePlan(equivalent, offset) : null;
     }
+    case "fromSectionFrames":
+      return null;
     case "sheetMetal":
     case "shell":
     case "hole":
@@ -43893,6 +44263,8 @@ function exactTruckSlicedProfilePlan(plan, offset) {
     case "chamfer":
     case "filletEdges":
     case "cornerYBlend":
+    case "faceFillet":
+    case "fullRound":
     case "chamferEdges":
     case "draft":
     case "importedMesh":
@@ -44046,6 +44418,9 @@ function tracePlanTransformations(plan) {
     case "fillet":
     case "chamfer":
     case "filletEdges":
+    case "faceFillet":
+    case "fullRound":
+    case "cornerYBlend":
     case "chamferEdges":
     case "draft":
     case "offsetSolid":
@@ -44059,24 +44434,27 @@ function findOriginOperation(plan) {
   if (!plan) return { operation: "unknown" };
   switch (plan.kind) {
     case "queryOwner":
-      return { operation: plan.owner.operation, owner: plan.owner };
+      return { operation: plan.owner.operation, owner: plan.owner, originPlan: plan };
     case "transform":
       return findOriginOperation(plan.base);
     case "boolean":
-      return { operation: `${plan.op} (${plan.shapes.length} operands)` };
+      return { operation: `${plan.op} (${plan.shapes.length} operands)`, originPlan: plan };
     case "shell":
     case "hole":
     case "cut":
     case "fillet":
     case "chamfer":
     case "filletEdges":
+    case "faceFillet":
+    case "fullRound":
+    case "cornerYBlend":
     case "chamferEdges":
     case "draft":
     case "offsetSolid":
     case "trimByPlane":
       return findOriginOperation(plan.base);
     default:
-      return { operation: plan.kind };
+      return { operation: plan.kind, originPlan: plan };
   }
 }
 function summarizeProfile(profile) {
@@ -44138,6 +44516,18 @@ function collectTimelineEntries(plan, entries) {
       collectTimelineEntries(plan.base, entries);
       entries.push({ kind: "filletEdges", label: "Fillet Edges", summary: `r = ${plan.radius}`, category: "modifier" });
       return;
+    case "faceFillet":
+      collectTimelineEntries(plan.base, entries);
+      entries.push({ kind: "faceFillet", label: "Face Fillet", summary: `r = ${plan.radius}`, category: "modifier" });
+      return;
+    case "fullRound":
+      collectTimelineEntries(plan.base, entries);
+      entries.push({ kind: "fullRound", label: "Full Round", summary: `r = ${plan.radius}`, category: "modifier" });
+      return;
+    case "cornerYBlend":
+      collectTimelineEntries(plan.base, entries);
+      entries.push({ kind: "cornerYBlend", label: "Corner Y-Blend", summary: `r = ${plan.radius}`, category: "modifier" });
+      return;
     case "chamferEdges":
       collectTimelineEntries(plan.base, entries);
       entries.push({ kind: "chamferEdges", label: "Chamfer Edges", summary: `size = ${plan.size}`, category: "modifier" });
@@ -44221,13 +44611,14 @@ function buildOperationTimeline(plan) {
   collectTimelineEntries(plan, entries);
   return entries;
 }
-function traceFaceTransformationHistory(plan, face) {
+function traceFaceTransformationHistory(plan, face, sourceSpans) {
   const transformations = tracePlanTransformations(plan);
-  const origin = findOriginOperation(plan);
+  const { originPlan, ...origin } = findOriginOperation(plan);
   const timeline = buildOperationTimeline(plan);
+  const sourceSpan = originPlan && sourceSpans ? sourceSpans.get(shapeCompilePlanCacheKey(originPlan)) : void 0;
   return {
     faceName: face.name,
-    origin,
+    origin: sourceSpan ? { ...origin, sourceSpan } : origin,
     transformations,
     query: face.query,
     timeline
@@ -44250,21 +44641,21 @@ function normalizeFaceSelector(selector) {
   }
   return { compilePlanName: null, query: selector };
 }
-function cross(a2, b) {
+function cross$1(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 dot(a2, b) {
+function dot$1(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
 function normVec3(v) {
-  const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-  if (len < 1e-10) return null;
-  return [v[0] / len, v[1] / len, v[2] / len];
+  const len2 = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+  if (len2 < 1e-10) return null;
+  return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function tangentFrame(normal2) {
   const ref = Math.abs(normal2[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
-  const v = normVec3(cross(normal2, ref));
-  const u2 = normVec3(cross(v, normal2));
+  const v = normVec3(cross$1(normal2, ref));
+  const u2 = normVec3(cross$1(v, normal2));
   return { u: u2, v };
 }
 const NORMAL_COS_EPS$1 = 0.9998;
@@ -44283,19 +44674,19 @@ function clusterMeshFaces(shape) {
     const v2 = [vertProperties[i2 * numProp], vertProperties[i2 * numProp + 1], vertProperties[i2 * numProp + 2]];
     const e1 = [v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]];
     const e2 = [v2[0] - v0[0], v2[1] - v0[1], v2[2] - v0[2]];
-    const rawCross = cross(e1, e2);
+    const rawCross = cross$1(e1, e2);
     const normal2 = normVec3(rawCross);
     if (!normal2) continue;
     const crossLen = Math.sqrt(rawCross[0] * rawCross[0] + rawCross[1] * rawCross[1] + rawCross[2] * rawCross[2]);
     const triArea = crossLen / 2;
-    const planeOffset = dot(normal2, v0);
-    const triCentroid = [(v0[0] + v1[0] + v2[0]) / 3, (v0[1] + v1[1] + v2[1]) / 3, (v0[2] + v1[2] + v2[2]) / 3];
+    const planeOffset = dot$1(normal2, v0);
+    const triCentroid2 = [(v0[0] + v1[0] + v2[0]) / 3, (v0[1] + v1[1] + v2[1]) / 3, (v0[2] + v1[2] + v2[2]) / 3];
     let merged = false;
     for (const c2 of clusters) {
-      if (dot(c2.normal, normal2) > NORMAL_COS_EPS$1 && Math.abs(c2.planeOffset - planeOffset) < PLANE_OFFSET_EPS$1) {
-        c2.centroidSum[0] += triCentroid[0];
-        c2.centroidSum[1] += triCentroid[1];
-        c2.centroidSum[2] += triCentroid[2];
+      if (dot$1(c2.normal, normal2) > NORMAL_COS_EPS$1 && Math.abs(c2.planeOffset - planeOffset) < PLANE_OFFSET_EPS$1) {
+        c2.centroidSum[0] += triCentroid2[0];
+        c2.centroidSum[1] += triCentroid2[1];
+        c2.centroidSum[2] += triCentroid2[2];
         c2.count++;
         c2.area += triArea;
         merged = true;
@@ -44306,7 +44697,7 @@ function clusterMeshFaces(shape) {
       clusters.push({
         normal: normal2,
         planeOffset,
-        centroidSum: [triCentroid[0], triCentroid[1], triCentroid[2]],
+        centroidSum: [triCentroid2[0], triCentroid2[1], triCentroid2[2]],
         count: 1,
         area: triArea
       });
@@ -44334,7 +44725,7 @@ function queryMeshFaces(shape, query) {
   let clusters = clusterMeshFaces(shape);
   if (query.normal) {
     const qn = query.normal;
-    clusters = clusters.filter((c2) => dot(c2.normal, qn) > NORMAL_COS_EPS$1);
+    clusters = clusters.filter((c2) => dot$1(c2.normal, qn) > NORMAL_COS_EPS$1);
   }
   if (query.planar !== false) {
     clusters = clusters.filter((c2) => c2.normal !== null);
@@ -44350,7 +44741,7 @@ function queryMeshFace(shape, query) {
   let clusters = clusterMeshFaces(shape);
   if (query.normal) {
     const qn = query.normal;
-    clusters = clusters.filter((c2) => dot(c2.normal, qn) > NORMAL_COS_EPS$1);
+    clusters = clusters.filter((c2) => dot$1(c2.normal, qn) > NORMAL_COS_EPS$1);
   }
   if (query.planar !== false) {
     clusters = clusters.filter((c2) => c2.normal !== null);
@@ -44599,7 +44990,8 @@ function applyMatrixToFace(face, matrix) {
     normal: normalizeAxis(tx.vector(face.normal)),
     query: cloneFaceQueryRef(face.query),
     uAxis: face.uAxis ? normalizeAxis(tx.vector(face.uAxis)) : void 0,
-    vAxis: face.vAxis ? normalizeAxis(tx.vector(face.vAxis)) : void 0
+    vAxis: face.vAxis ? normalizeAxis(tx.vector(face.vAxis)) : void 0,
+    surface: transformFaceSurface(face.surface, tx)
   };
 }
 function applyMatrixToFaceTable(table, matrix) {
@@ -44622,11 +45014,11 @@ function canonicalShapeStepMatrix(step) {
   }
 }
 function mirrorMatrix$1(normal2) {
-  const len = Math.hypot(normal2[0], normal2[1], normal2[2]);
-  if (len < 1e-12) return Transform.identity().toArray();
-  const nx = normal2[0] / len;
-  const ny = normal2[1] / len;
-  const nz = normal2[2] / len;
+  const len2 = Math.hypot(normal2[0], normal2[1], normal2[2]);
+  if (len2 < 1e-12) return Transform.identity().toArray();
+  const nx = normal2[0] / len2;
+  const ny = normal2[1] / len2;
+  const nz = normal2[2] / len2;
   return [
     1 - 2 * nx * nx,
     -2 * nx * ny,
@@ -44689,9 +45081,9 @@ function pointOnWorkplane(origin, workplaneU, workplaneV, u2, v, depthDir, depth
   ];
 }
 function normalize2d(vec2) {
-  const len = Math.hypot(vec2[0], vec2[1]);
-  if (len < 1e-12) return [1, 0];
-  return [vec2[0] / len, vec2[1] / len];
+  const len2 = Math.hypot(vec2[0], vec2[1]);
+  if (len2 < 1e-12) return [1, 0];
+  return [vec2[0] / len2, vec2[1] / len2];
 }
 function cross3$2(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]];
@@ -44717,6 +45109,9 @@ function faceFrom2DEdge(name, start, end, zMid, ownerQuery) {
     query: cloneFaceQueryRef(ownerQuery)
   };
 }
+function withPlaneCarrier(face) {
+  return { ...face, surface: { kind: "plane", normal: cloneVec3$1(face.normal) } };
+}
 function createTrackedFaceQuery(name, owner) {
   if (!owner) return void 0;
   return {
@@ -44780,6 +45175,7 @@ function buildBoxFaceTable(plan, owner) {
     planar: true,
     uAxis: [1, 0, 0],
     vAxis: [0, 1, 0],
+    surface: { kind: "plane", normal: [0, 0, 1] },
     query: topQuery
   });
   registerFace(table, {
@@ -44789,22 +45185,23 @@ function buildBoxFaceTable(plan, owner) {
     planar: true,
     uAxis: [1, 0, 0],
     vAxis: [0, -1, 0],
+    surface: { kind: "plane", normal: [0, 0, -1] },
     query: bottomQuery
   });
-  registerFace(table, {
-    ...faceFrom2DEdge("side-bottom", bl, br, (zTop + zBot) / 2, createTrackedFaceQuery("side-bottom", owner))
-  });
-  registerFace(table, {
-    ...faceFrom2DEdge("side-right", br, tr, (zTop + zBot) / 2, createTrackedFaceQuery("side-right", owner))
-  });
-  registerFace(table, {
-    ...faceFrom2DEdge("side-top", tr, tl, (zTop + zBot) / 2, createTrackedFaceQuery("side-top", owner))
-  });
-  registerFace(table, {
-    ...faceFrom2DEdge("side-left", tl, bl, (zTop + zBot) / 2, createTrackedFaceQuery("side-left", owner))
-  });
+  registerFace(table, withPlaneCarrier(faceFrom2DEdge("side-bottom", bl, br, (zTop + zBot) / 2, createTrackedFaceQuery("side-bottom", owner))));
+  registerFace(table, withPlaneCarrier(faceFrom2DEdge("side-right", br, tr, (zTop + zBot) / 2, createTrackedFaceQuery("side-right", owner))));
+  registerFace(table, withPlaneCarrier(faceFrom2DEdge("side-top", tr, tl, (zTop + zBot) / 2, createTrackedFaceQuery("side-top", owner))));
+  registerFace(table, withPlaneCarrier(faceFrom2DEdge("side-left", tl, bl, (zTop + zBot) / 2, createTrackedFaceQuery("side-left", owner))));
   return table;
 }
+function cylinderSideCarrier(plan) {
+  const radiusBottom = Math.abs(plan.radius);
+  const radiusTop = Math.abs(plan.radiusTop ?? plan.radius);
+  const height = Math.abs(plan.height);
+  const origin = [0, 0, Math.min(0, plan.height)];
+  const axis = [0, 0, 1];
+  return radiusBottom === radiusTop ? { kind: "cylinder", origin, axis, radius: radiusBottom, height } : { kind: "cone", origin, axis, radiusBottom, radiusTop, height };
+}
 function buildCylinderFaceTable(plan, owner) {
   const table = emptyFaceTable();
   const zBot = 0;
@@ -44818,6 +45215,7 @@ function buildCylinderFaceTable(plan, owner) {
     planar: true,
     uAxis: [1, 0, 0],
     vAxis: [0, 1, 0],
+    surface: { kind: "plane", normal: [0, 0, 1] },
     query: createTrackedFaceQuery("top", owner)
   });
   registerFace(table, {
@@ -44827,6 +45225,7 @@ function buildCylinderFaceTable(plan, owner) {
     planar: true,
     uAxis: [1, 0, 0],
     vAxis: [0, -1, 0],
+    surface: { kind: "plane", normal: [0, 0, -1] },
     query: createTrackedFaceQuery("bottom", owner)
   });
   registerFace(table, {
@@ -44834,10 +45233,38 @@ function buildCylinderFaceTable(plan, owner) {
     normal: [1, 0, 0],
     center: [sideRadius, 0, (zTop + zBot) / 2],
     planar: false,
+    surface: cylinderSideCarrier(plan),
     query: createTrackedFaceQuery("side", owner)
   });
   return table;
 }
+function buildSphereFaceTable(plan, owner) {
+  const table = emptyFaceTable();
+  const radius = Math.abs(plan.radius);
+  registerFace(table, {
+    name: "surface",
+    normal: [1, 0, 0],
+    center: [radius, 0, 0],
+    planar: false,
+    surface: { kind: "sphere", center: [0, 0, 0], radius },
+    query: createTrackedFaceQuery("surface", owner)
+  });
+  return table;
+}
+function buildTorusFaceTable(plan, owner) {
+  const table = emptyFaceTable();
+  const majorRadius = Math.abs(plan.majorRadius);
+  const minorRadius = Math.abs(plan.minorRadius);
+  registerFace(table, {
+    name: "surface",
+    normal: [1, 0, 0],
+    center: [majorRadius + minorRadius, 0, 0],
+    planar: false,
+    surface: { kind: "torus", center: [0, 0, 0], axis: [0, 0, 1], majorRadius, minorRadius },
+    query: createTrackedFaceQuery("surface", owner)
+  });
+  return table;
+}
 function buildRectExtrudeFaceTable(profile, height, owner) {
   const corners = rectLikeProfileCorners(profile);
   if (!corners) return emptyFaceTable();
@@ -44855,6 +45282,7 @@ function buildRectExtrudeFaceTable(profile, height, owner) {
     planar: true,
     uAxis: topU,
     vAxis: topV,
+    surface: { kind: "plane", normal: [0, 0, 1] },
     query: createTrackedFaceQuery("top", owner)
   });
   registerFace(table, {
@@ -44864,12 +45292,13 @@ function buildRectExtrudeFaceTable(profile, height, owner) {
     planar: true,
     uAxis: topU,
     vAxis: [-topV[0], -topV[1], -topV[2]],
+    surface: { kind: "plane", normal: [0, 0, -1] },
     query: createTrackedFaceQuery("bottom", owner)
   });
-  registerFace(table, faceFrom2DEdge("side-bottom", bl, br, (zTop + zBot) / 2, createTrackedFaceQuery("side-bottom", owner)));
-  registerFace(table, faceFrom2DEdge("side-right", br, tr, (zTop + zBot) / 2, createTrackedFaceQuery("side-right", owner)));
-  registerFace(table, faceFrom2DEdge("side-top", tr, tl, (zTop + zBot) / 2, createTrackedFaceQuery("side-top", owner)));
-  registerFace(table, faceFrom2DEdge("side-left", tl, bl, (zTop + zBot) / 2, createTrackedFaceQuery("side-left", owner)));
+  registerFace(table, withPlaneCarrier(faceFrom2DEdge("side-bottom", bl, br, (zTop + zBot) / 2, createTrackedFaceQuery("side-bottom", owner))));
+  registerFace(table, withPlaneCarrier(faceFrom2DEdge("side-right", br, tr, (zTop + zBot) / 2, createTrackedFaceQuery("side-right", owner))));
+  registerFace(table, withPlaneCarrier(faceFrom2DEdge("side-top", tr, tl, (zTop + zBot) / 2, createTrackedFaceQuery("side-top", owner))));
+  registerFace(table, withPlaneCarrier(faceFrom2DEdge("side-left", tl, bl, (zTop + zBot) / 2, createTrackedFaceQuery("side-left", owner))));
   return table;
 }
 function buildCircleExtrudeFaceTable(profile, height, owner) {
@@ -44889,6 +45318,7 @@ function buildCircleExtrudeFaceTable(profile, height, owner) {
     planar: true,
     uAxis: xAxis,
     vAxis: yAxis,
+    surface: { kind: "plane", normal: [0, 0, 1] },
     query: createTrackedFaceQuery("top", owner)
   });
   registerFace(table, {
@@ -44898,6 +45328,7 @@ function buildCircleExtrudeFaceTable(profile, height, owner) {
     planar: true,
     uAxis: xAxis,
     vAxis: [-yAxis[0], -yAxis[1], -yAxis[2]],
+    surface: { kind: "plane", normal: [0, 0, -1] },
     query: createTrackedFaceQuery("bottom", owner)
   });
   registerFace(table, {
@@ -44905,10 +45336,65 @@ function buildCircleExtrudeFaceTable(profile, height, owner) {
     normal: sideNormal,
     center: [sidePoint[0], sidePoint[1], (zTop + zBot) / 2],
     planar: false,
+    surface: { kind: "cylinder", origin: [origin[0], origin[1], zBot], axis: [0, 0, 1], radius: Math.abs(profile.radius), height },
     query: createTrackedFaceQuery("side", owner)
   });
   return table;
 }
+function collectExtrudeSideCarriers(profile, height, parent, prefix) {
+  switch (profile.kind) {
+    case "circle": {
+      const side = buildCircleExtrudeFaceTable(profile, height, null).faces.get("side");
+      return side ? [applyMatrixToFace({ ...side, name: `${prefix}side` }, parent.toArray())] : [];
+    }
+    case "rect":
+    case "roundedRect":
+    case "polygon": {
+      const leaf = buildRectExtrudeFaceTable(profile, height, null);
+      const out = [];
+      for (const name of ["side-bottom", "side-right", "side-top", "side-left"]) {
+        const face = leaf.faces.get(name);
+        if (face) out.push(applyMatrixToFace({ ...face, name: `${prefix}${name}` }, parent.toArray()));
+      }
+      return out;
+    }
+    case "boolean": {
+      const composed = parent.mul(profileTransformMatrix(profile.transforms));
+      return profile.profiles.flatMap((child, index2) => collectExtrudeSideCarriers(child, height, composed, `${prefix}op${index2}/`));
+    }
+    default:
+      return [];
+  }
+}
+function buildBooleanExtrudeFaceTable(profile, height, owner) {
+  const table = emptyFaceTable();
+  const zBot = 0;
+  const zTop = zBot + height;
+  registerFace(table, {
+    name: "top",
+    normal: [0, 0, 1],
+    center: [0, 0, zTop],
+    planar: true,
+    uAxis: [1, 0, 0],
+    vAxis: [0, 1, 0],
+    surface: { kind: "plane", normal: [0, 0, 1] },
+    query: createTrackedFaceQuery("top", owner)
+  });
+  registerFace(table, {
+    name: "bottom",
+    normal: [0, 0, -1],
+    center: [0, 0, zBot],
+    planar: true,
+    uAxis: [1, 0, 0],
+    vAxis: [0, -1, 0],
+    surface: { kind: "plane", normal: [0, 0, -1] },
+    query: createTrackedFaceQuery("bottom", owner)
+  });
+  for (const side of collectExtrudeSideCarriers(profile, height, Transform.identity(), "")) {
+    registerFace(table, side);
+  }
+  return table;
+}
 function buildExtrudeFaceTable(plan, owner) {
   var _a3, _b3;
   let table;
@@ -44921,6 +45407,9 @@ function buildExtrudeFaceTable(plan, owner) {
     case "circle":
       table = buildCircleExtrudeFaceTable(plan.profile, plan.height, owner);
       break;
+    case "boolean":
+      table = buildBooleanExtrudeFaceTable(plan.profile, plan.height, owner);
+      break;
     default:
       table = emptyFaceTable();
       break;
@@ -45602,7 +46091,9 @@ function resolveShapeFaceTableInternal(plan, owner) {
       return table;
     }
     case "sphere":
+      return buildSphereFaceTable(plan, owner);
     case "torus":
+      return buildTorusFaceTable(plan, owner);
     case "variableSweep":
     case "fillet":
     case "chamfer":
@@ -45610,8 +46101,13 @@ function resolveShapeFaceTableInternal(plan, owner) {
     case "offsetSolid":
       return emptyFaceTable();
     // Fillet/chamfer edges preserve all base faces — delegate to base plan.
+    // Caveat: cornerYBlend and fullRound each CONSUME a base face (the Y-corner
+    // region / the narrow center face), so the delegated base table is a known
+    // provenance approximation for those two kinds.
     case "filletEdges":
     case "cornerYBlend":
+    case "faceFillet":
+    case "fullRound":
     case "chamferEdges":
       return resolveShapeFaceTableInternal(plan.base, owner);
     case "revolve":
@@ -45692,6 +46188,7 @@ function resolveShapeFaceTableInternal(plan, owner) {
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "fromSectionFrames":
     case "analyticSurface":
     case "nurbsSurface":
     case "surfaceRuled":
@@ -45722,6 +46219,55 @@ function resolveShapeFace(plan, name) {
   if (face) return cloneFaceRefValue(face);
   return null;
 }
+function gatherShapeCarriers(plan) {
+  const carriers = [];
+  const seen = /* @__PURE__ */ new Set();
+  const emit = (prefix, table, tx) => {
+    for (const [name, raw] of table.faces.entries()) {
+      const face = applyMatrixToFace(raw, tx.toArray());
+      const surface = face.surface;
+      if (!surface) continue;
+      if (surface.kind === "ruled" || surface.kind === "nurbs") continue;
+      const planePoint = surface.kind === "plane" ? cloneVec3$1(face.center) : void 0;
+      const key2 = JSON.stringify([surface, planePoint ?? null]);
+      if (seen.has(key2)) continue;
+      seen.add(key2);
+      carriers.push({ name: prefix ? `${prefix}${name}` : name, surface: cloneFaceSurface(surface), planePoint });
+    }
+  };
+  const walk = (node, tx, prefix) => {
+    if (!node) return;
+    switch (node.kind) {
+      case "queryOwner":
+      case "surfaceExtend":
+        walk(node.base, tx, prefix);
+        return;
+      case "transform": {
+        let composed = tx;
+        for (const step of node.steps) composed = composed.mul(canonicalShapeStepMatrix(step));
+        walk(node.base, composed, prefix);
+        return;
+      }
+      case "boolean": {
+        emit(prefix, resolveShapeFaceTableInternal(node, null), tx);
+        node.shapes.forEach((shape, index2) => walk(shape, tx, `${prefix}op${index2}/`));
+        return;
+      }
+      case "filletEdges":
+      case "cornerYBlend":
+      case "faceFillet":
+      case "fullRound":
+      case "chamferEdges":
+        walk(node.base, tx, prefix);
+        return;
+      default:
+        emit(prefix, resolveShapeFaceTableInternal(node, null), tx);
+        return;
+    }
+  };
+  walk(plan, Transform.identity(), "");
+  return carriers;
+}
 const DEPRECATED_SIDE_NAMES = {
   "side-left": "left",
   "side-right": "right",
@@ -45746,6 +46292,631 @@ function supportedShellCreatedFaceNames(basePlan, openFaces) {
 function preservedShapeFaceQueries(basePlan) {
   return listShapeFaceQueries(basePlan);
 }
+const EDGE_THRESHOLD_DOT = Math.cos(Math.PI / 180);
+const SMOOTH_THRESHOLD_DOT = Math.cos(30 * Math.PI / 180);
+function computeGeometryArrays(mesh, options = {}) {
+  const { numProp, numTri: triCount, triVerts, vertProperties, vertNormals, cornerNormals } = mesh;
+  if (numProp !== NUM_PROP_POSITION_ONLY && numProp !== NUM_PROP_WITH_NORMAL && numProp !== NUM_PROP_WITH_UV) {
+    throw new Error(
+      `computeGeometryArrays: illegal vertProperties numProp ${numProp}. Only ${NUM_PROP_POSITION_ONLY} (position), ${NUM_PROP_WITH_NORMAL} (position+normal), and ${NUM_PROP_WITH_UV} (position+normal+uv) are valid; ${numProp} (e.g. a truncated uv channel) is not.`
+    );
+  }
+  const hasStoredNormals = numProp === NUM_PROP_WITH_NORMAL || numProp === NUM_PROP_WITH_UV;
+  const hasStoredUvs = numProp === NUM_PROP_WITH_UV;
+  const useCornerNormals = !!cornerNormals && cornerNormals.length === triCount * 9;
+  const positions = new Float32Array(triCount * 9);
+  const normals = new Float32Array(triCount * 9);
+  const uvs = hasStoredUvs ? new Float32Array(triCount * 6) : void 0;
+  const faceNx = new Float32Array(triCount);
+  const faceNy = new Float32Array(triCount);
+  const faceNz = new Float32Array(triCount);
+  for (let t = 0; t < triCount; t++) {
+    const i0 = triVerts[t * 3];
+    const i1 = triVerts[t * 3 + 1];
+    const i2 = triVerts[t * 3 + 2];
+    const ax = vertProperties[i0 * numProp], ay = vertProperties[i0 * numProp + 1], az = vertProperties[i0 * numProp + 2];
+    const bx = vertProperties[i1 * numProp], by = vertProperties[i1 * numProp + 1], bz = vertProperties[i1 * numProp + 2];
+    const cx = vertProperties[i2 * numProp], cy = vertProperties[i2 * numProp + 1], cz = vertProperties[i2 * numProp + 2];
+    const e1x = bx - ax, e1y = by - ay, e1z = bz - az;
+    const e2x = cx - ax, e2y = cy - ay, e2z = cz - az;
+    let fnx = e1y * e2z - e1z * e2y;
+    let fny = e1z * e2x - e1x * e2z;
+    let fnz = e1x * e2y - e1y * e2x;
+    const len2 = Math.sqrt(fnx * fnx + fny * fny + fnz * fnz) || 1;
+    fnx /= len2;
+    fny /= len2;
+    fnz /= len2;
+    const o = t * 9;
+    positions[o] = ax;
+    positions[o + 1] = ay;
+    positions[o + 2] = az;
+    positions[o + 3] = bx;
+    positions[o + 4] = by;
+    positions[o + 5] = bz;
+    positions[o + 6] = cx;
+    positions[o + 7] = cy;
+    positions[o + 8] = cz;
+    if (uvs) {
+      const u2 = t * 6;
+      uvs[u2] = vertProperties[i0 * numProp + UV_OFFSET];
+      uvs[u2 + 1] = vertProperties[i0 * numProp + UV_OFFSET + 1];
+      uvs[u2 + 2] = vertProperties[i1 * numProp + UV_OFFSET];
+      uvs[u2 + 3] = vertProperties[i1 * numProp + UV_OFFSET + 1];
+      uvs[u2 + 4] = vertProperties[i2 * numProp + UV_OFFSET];
+      uvs[u2 + 5] = vertProperties[i2 * numProp + UV_OFFSET + 1];
+    }
+    if (useCornerNormals) {
+      for (let k2 = 0; k2 < 9; k2++) normals[o + k2] = cornerNormals[o + k2];
+    } else if (vertNormals) {
+      normals[o] = vertNormals[i0 * 3];
+      normals[o + 1] = vertNormals[i0 * 3 + 1];
+      normals[o + 2] = vertNormals[i0 * 3 + 2];
+      normals[o + 3] = vertNormals[i1 * 3];
+      normals[o + 4] = vertNormals[i1 * 3 + 1];
+      normals[o + 5] = vertNormals[i1 * 3 + 2];
+      normals[o + 6] = vertNormals[i2 * 3];
+      normals[o + 7] = vertNormals[i2 * 3 + 1];
+      normals[o + 8] = vertNormals[i2 * 3 + 2];
+    } else if (hasStoredNormals) {
+      const corners = [i0, i1, i2];
+      for (let v = 0; v < 3; v++) {
+        const base = corners[v] * numProp;
+        const nx = vertProperties[base + NORMAL_OFFSET];
+        const ny = vertProperties[base + NORMAL_OFFSET + 1];
+        const nz = vertProperties[base + NORMAL_OFFSET + 2];
+        const oc = o + v * 3;
+        if (nx * nx + ny * ny + nz * nz > 1e-12) {
+          normals[oc] = nx;
+          normals[oc + 1] = ny;
+          normals[oc + 2] = nz;
+        } else {
+          normals[oc] = fnx;
+          normals[oc + 1] = fny;
+          normals[oc + 2] = fnz;
+        }
+      }
+    } else {
+      normals[o] = fnx;
+      normals[o + 1] = fny;
+      normals[o + 2] = fnz;
+      normals[o + 3] = fnx;
+      normals[o + 4] = fny;
+      normals[o + 5] = fnz;
+      normals[o + 6] = fnx;
+      normals[o + 7] = fny;
+      normals[o + 8] = fnz;
+    }
+    faceNx[t] = fnx;
+    faceNy[t] = fny;
+    faceNz[t] = fnz;
+  }
+  if (!useCornerNormals && !vertNormals && !hasStoredNormals && triCount > 0) {
+    computeAutoSmoothNormals(
+      triVerts,
+      vertProperties,
+      numProp,
+      triCount,
+      faceNx,
+      faceNy,
+      faceNz,
+      normals,
+      mesh.mergeFromVert,
+      mesh.mergeToVert
+    );
+  }
+  const edgePositions = options.skipEdges ? new Float32Array(0) : computeSharpEdges(triVerts, vertProperties, numProp, triCount, faceNx, faceNy, faceNz, mesh.mergeFromVert, mesh.mergeToVert);
+  return {
+    positions,
+    normals,
+    edgePositions,
+    hasSmoothNormals: triCount > 0,
+    uvs
+  };
+}
+function computeAutoSmoothNormals(triVerts, vertProperties, numProp, triCount, faceNx, faceNy, faceNz, normals, mergeFromVert, mergeToVert) {
+  const numVerts = vertProperties.length / numProp;
+  const canon = buildCanonicalMap$2(numVerts, mergeFromVert, mergeToVert);
+  const vertToTris = /* @__PURE__ */ new Map();
+  for (let t = 0; t < triCount; t++) {
+    for (let v = 0; v < 3; v++) {
+      const cv = canon[triVerts[t * 3 + v]];
+      let list = vertToTris.get(cv);
+      if (!list) {
+        list = [];
+        vertToTris.set(cv, list);
+      }
+      list.push(t);
+    }
+  }
+  for (let t = 0; t < triCount; t++) {
+    for (let v = 0; v < 3; v++) {
+      const cv = canon[triVerts[t * 3 + v]];
+      const adjacentTris = vertToTris.get(cv);
+      if (!adjacentTris || adjacentTris.length <= 1) continue;
+      let sx = 0, sy = 0, sz = 0;
+      for (const adj of adjacentTris) {
+        const dot2 = faceNx[t] * faceNx[adj] + faceNy[t] * faceNy[adj] + faceNz[t] * faceNz[adj];
+        if (dot2 >= SMOOTH_THRESHOLD_DOT) {
+          sx += faceNx[adj];
+          sy += faceNy[adj];
+          sz += faceNz[adj];
+        }
+      }
+      const slen = Math.sqrt(sx * sx + sy * sy + sz * sz);
+      if (slen > 1e-9) {
+        sx /= slen;
+        sy /= slen;
+        sz /= slen;
+        const o = t * 9 + v * 3;
+        normals[o] = sx;
+        normals[o + 1] = sy;
+        normals[o + 2] = sz;
+      }
+    }
+  }
+}
+function computeSharpEdges(triVerts, vertProperties, numProp, triCount, faceNx, faceNy, faceNz, mergeFromVert, mergeToVert) {
+  const numVerts = vertProperties.length / numProp;
+  const canon = buildCanonicalMap$2(numVerts, mergeFromVert, mergeToVert);
+  const MAX_NUMERIC = 1 << 21;
+  let maxCanon = 0;
+  for (let i = 0; i < numVerts; i++) {
+    if (canon[i] > maxCanon) maxCanon = canon[i];
+  }
+  const useNumeric = maxCanon < MAX_NUMERIC;
+  const halfEdges = /* @__PURE__ */ new Map();
+  const edgeList = [];
+  for (let t = 0; t < triCount; t++) {
+    const ca = canon[triVerts[t * 3]];
+    const cb = canon[triVerts[t * 3 + 1]];
+    const cc = canon[triVerts[t * 3 + 2]];
+    const tv = [ca, cb, cc];
+    for (let e = 0; e < 3; e++) {
+      const va = tv[e], vb = tv[(e + 1) % 3];
+      const fwdKey = useNumeric ? va * MAX_NUMERIC + vb : `${va},${vb}`;
+      const revKey = useNumeric ? vb * MAX_NUMERIC + va : `${vb},${va}`;
+      const adjTri = halfEdges.get(revKey);
+      if (adjTri !== void 0) {
+        const dot2 = faceNx[t] * faceNx[adjTri] + faceNy[t] * faceNy[adjTri] + faceNz[t] * faceNz[adjTri];
+        if (dot2 <= EDGE_THRESHOLD_DOT) {
+          const origVa = triVerts[t * 3 + e];
+          const origVb = triVerts[t * 3 + (e + 1) % 3];
+          edgeList.push(
+            vertProperties[origVa * numProp],
+            vertProperties[origVa * numProp + 1],
+            vertProperties[origVa * numProp + 2],
+            vertProperties[origVb * numProp],
+            vertProperties[origVb * numProp + 1],
+            vertProperties[origVb * numProp + 2]
+          );
+        }
+        halfEdges.delete(revKey);
+      } else {
+        halfEdges.set(fwdKey, t);
+      }
+    }
+  }
+  for (const [key2, t] of halfEdges) {
+    const ca = canon[triVerts[t * 3]];
+    const cb = canon[triVerts[t * 3 + 1]];
+    const cc = canon[triVerts[t * 3 + 2]];
+    const tv = [ca, cb, cc];
+    for (let e = 0; e < 3; e++) {
+      const va = tv[e], vb = tv[(e + 1) % 3];
+      const fwdKey = useNumeric ? va * MAX_NUMERIC + vb : `${va},${vb}`;
+      if (fwdKey === key2) {
+        const origVa = triVerts[t * 3 + e];
+        const origVb = triVerts[t * 3 + (e + 1) % 3];
+        edgeList.push(
+          vertProperties[origVa * numProp],
+          vertProperties[origVa * numProp + 1],
+          vertProperties[origVa * numProp + 2],
+          vertProperties[origVb * numProp],
+          vertProperties[origVb * numProp + 1],
+          vertProperties[origVb * numProp + 2]
+        );
+        break;
+      }
+    }
+  }
+  return new Float32Array(edgeList);
+}
+function buildCanonicalMap$2(numVerts, mergeFromVert, mergeToVert) {
+  const canon = new Uint32Array(numVerts);
+  for (let i = 0; i < numVerts; i++) canon[i] = i;
+  if (mergeFromVert && mergeToVert) {
+    for (let i = 0; i < mergeFromVert.length; i++) {
+      canon[mergeFromVert[i]] = mergeToVert[i];
+    }
+    for (let i = 0; i < numVerts; i++) {
+      let v = canon[i];
+      while (canon[v] !== v) v = canon[v];
+      canon[i] = v;
+    }
+  }
+  return canon;
+}
+const sub = (a2, b) => [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
+const add = (a2, b) => [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
+const dot = (a2, b) => a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
+const len = (a2) => Math.hypot(a2[0], a2[1], a2[2]);
+const scl = (a2, s) => [a2[0] * s, a2[1] * s, a2[2] * s];
+const cross = (a2, b) => [
+  a2[1] * b[2] - a2[2] * b[1],
+  a2[2] * b[0] - a2[0] * b[2],
+  a2[0] * b[1] - a2[1] * b[0]
+];
+const DEGENERATE = 1e-12;
+function normalize$1(a2) {
+  const L = len(a2);
+  if (L < DEGENERATE) throw new Error("vec3exact.normalize: degenerate (zero-length) vector");
+  return [a2[0] / L, a2[1] / L, a2[2] / L];
+}
+function carrierSignedDistance(surface, p2, planePoint) {
+  switch (surface.kind) {
+    case "plane": {
+      if (!planePoint) throw new Error("plane carrier requires planePoint (FaceRef.center)");
+      const n = normalize$1(surface.normal);
+      return dot(n, sub(p2, planePoint));
+    }
+    case "cylinder": {
+      const ax = normalize$1(surface.axis);
+      const v = sub(p2, surface.origin);
+      const radial = sub(v, scl(ax, dot(v, ax)));
+      return len(radial) - surface.radius;
+    }
+    case "sphere": {
+      return len(sub(p2, surface.center)) - surface.radius;
+    }
+    case "cone": {
+      const ax = normalize$1(surface.axis);
+      const v = sub(p2, surface.origin);
+      const t = dot(v, ax);
+      const rad = len(sub(v, scl(ax, t)));
+      const surfaceR = surface.radiusBottom + (surface.radiusTop - surface.radiusBottom) * (t / surface.height);
+      const slope = (surface.radiusTop - surface.radiusBottom) / surface.height;
+      const cosHalf = 1 / Math.hypot(1, slope);
+      return (rad - surfaceR) * cosHalf;
+    }
+    case "torus": {
+      const ax = normalize$1(surface.axis);
+      const v = sub(p2, surface.center);
+      const z2 = dot(v, ax);
+      const rho = len(sub(v, scl(ax, z2)));
+      const dr = rho - surface.majorRadius;
+      return Math.hypot(dr, z2) - surface.minorRadius;
+    }
+    case "ruled":
+    case "nurbs":
+      return null;
+  }
+}
+function carrierNormalAt(surface, p2, planePoint) {
+  switch (surface.kind) {
+    case "plane":
+      return normalize$1(surface.normal);
+    case "cylinder": {
+      const ax = normalize$1(surface.axis);
+      const v = sub(p2, surface.origin);
+      const radial = sub(v, scl(ax, dot(v, ax)));
+      const r = len(radial);
+      return r < DEGENERATE ? ax : scl(radial, 1 / r);
+    }
+    case "sphere": {
+      const v = sub(p2, surface.center);
+      const r = len(v);
+      return r < DEGENERATE ? [1, 0, 0] : scl(v, 1 / r);
+    }
+    case "cone": {
+      const ax = normalize$1(surface.axis);
+      const v = sub(p2, surface.origin);
+      const t = dot(v, ax);
+      const radialVec = sub(v, scl(ax, t));
+      const rad = len(radialVec);
+      const slope = (surface.radiusTop - surface.radiusBottom) / surface.height;
+      const h = Math.hypot(1, slope);
+      const cosHalf = 1 / h;
+      const sinHalf = slope / h;
+      const rHat = rad < DEGENERATE ? ax : scl(radialVec, 1 / rad);
+      return normalize$1([
+        rHat[0] * cosHalf - ax[0] * sinHalf,
+        rHat[1] * cosHalf - ax[1] * sinHalf,
+        rHat[2] * cosHalf - ax[2] * sinHalf
+      ]);
+    }
+    case "torus": {
+      const ax = normalize$1(surface.axis);
+      const v = sub(p2, surface.center);
+      const z2 = dot(v, ax);
+      const radialVec = sub(v, scl(ax, z2));
+      const rho = len(radialVec);
+      const rHat = rho < DEGENERATE ? [1, 0, 0] : scl(radialVec, 1 / rho);
+      const dr = rho - surface.majorRadius;
+      const tubeDist = Math.hypot(dr, z2);
+      if (tubeDist < DEGENERATE) return rHat;
+      return normalize$1([
+        rHat[0] * dr + ax[0] * z2,
+        rHat[1] * dr + ax[1] * z2,
+        rHat[2] * dr + ax[2] * z2
+      ]);
+    }
+    case "ruled":
+    case "nurbs":
+      return null;
+  }
+}
+function minCurvatureRadius(surface, p2) {
+  switch (surface.kind) {
+    case "plane":
+      return Number.POSITIVE_INFINITY;
+    case "sphere":
+      return surface.radius;
+    case "cylinder":
+      return surface.radius;
+    case "cone": {
+      const ax = normalize$1(surface.axis);
+      const v = sub(p2, surface.origin);
+      const t = dot(v, ax);
+      const surfaceR = surface.radiusBottom + (surface.radiusTop - surface.radiusBottom) * (t / surface.height);
+      return Math.max(Math.abs(surfaceR), DEGENERATE);
+    }
+    case "torus":
+      return surface.minorRadius;
+    default:
+      return Number.POSITIVE_INFINITY;
+  }
+}
+function triCentroid(mesh, t) {
+  const { triVerts, vertProperties, numProp } = mesh;
+  const i0 = triVerts[t * 3] * numProp;
+  const i1 = triVerts[t * 3 + 1] * numProp;
+  const i2 = triVerts[t * 3 + 2] * numProp;
+  return [
+    (vertProperties[i0] + vertProperties[i1] + vertProperties[i2]) / 3,
+    (vertProperties[i0 + 1] + vertProperties[i1 + 1] + vertProperties[i2 + 1]) / 3,
+    (vertProperties[i0 + 2] + vertProperties[i1 + 2] + vertProperties[i2 + 2]) / 3
+  ];
+}
+function triNormal(mesh, t) {
+  const { triVerts, vertProperties, numProp } = mesh;
+  const i0 = triVerts[t * 3] * numProp;
+  const i1 = triVerts[t * 3 + 1] * numProp;
+  const i2 = triVerts[t * 3 + 2] * numProp;
+  const v0 = [vertProperties[i0], vertProperties[i0 + 1], vertProperties[i0 + 2]];
+  const v1 = [vertProperties[i1], vertProperties[i1 + 1], vertProperties[i1 + 2]];
+  const v2 = [vertProperties[i2], vertProperties[i2 + 1], vertProperties[i2 + 2]];
+  return cross(sub(v1, v0), sub(v2, v0));
+}
+function triMaxEdge(mesh, t) {
+  const { triVerts, vertProperties, numProp } = mesh;
+  const i0 = triVerts[t * 3] * numProp;
+  const i1 = triVerts[t * 3 + 1] * numProp;
+  const i2 = triVerts[t * 3 + 2] * numProp;
+  const v0 = [vertProperties[i0], vertProperties[i0 + 1], vertProperties[i0 + 2]];
+  const v1 = [vertProperties[i1], vertProperties[i1 + 1], vertProperties[i1 + 2]];
+  const v2 = [vertProperties[i2], vertProperties[i2 + 1], vertProperties[i2 + 2]];
+  return Math.max(len(sub(v1, v0)), len(sub(v2, v1)), len(sub(v0, v2)));
+}
+function chordSagitta(R, h) {
+  if (!Number.isFinite(R)) return 0;
+  const c2 = h / 2;
+  if (c2 >= R) return R;
+  return R - Math.sqrt(R * R - c2 * c2);
+}
+function triVertices(mesh, t) {
+  const { triVerts, vertProperties, numProp } = mesh;
+  const i0 = triVerts[t * 3] * numProp;
+  const i1 = triVerts[t * 3 + 1] * numProp;
+  const i2 = triVerts[t * 3 + 2] * numProp;
+  return [
+    [vertProperties[i0], vertProperties[i0 + 1], vertProperties[i0 + 2]],
+    [vertProperties[i1], vertProperties[i1 + 1], vertProperties[i1 + 2]],
+    [vertProperties[i2], vertProperties[i2 + 1], vertProperties[i2 + 2]]
+  ];
+}
+function triTolerance(surface, p2, h, safety) {
+  const R = minCurvatureRadius(surface, p2);
+  const sagitta = chordSagitta(R, h);
+  const floor = h * 1e-3;
+  return safety * Math.max(sagitta, floor);
+}
+function triAngularCosMin(surface, p2, h, safety) {
+  const R = minCurvatureRadius(surface, p2);
+  const theta = Number.isFinite(R) ? Math.asin(Math.min(1, h / (2 * R))) : safety * 0.01;
+  return Math.cos(Math.min(safety * theta, Math.PI / 2));
+}
+function classifyMeshFaces(mesh, carriers, opts = {}) {
+  const safety = opts.safety ?? 2;
+  const numTri = mesh.numTri;
+  for (const c2 of carriers) {
+    if (c2.surface.kind === "plane" && !c2.planePoint) {
+      throw new Error(`carrier '${c2.name}' is a plane but has no planePoint (FaceRef.center)`);
+    }
+  }
+  const assigned = new Array(numTri).fill(null);
+  const deviation = new Array(numTri).fill(Number.POSITIVE_INFINITY);
+  const unitNormal = new Array(numTri).fill(null);
+  for (let t = 0; t < numTri; t++) {
+    const p2 = triCentroid(mesh, t);
+    const nRaw = triNormal(mesh, t);
+    const nLen = len(nRaw);
+    if (nLen < DEGENERATE) continue;
+    const nTri = scl(nRaw, 1 / nLen);
+    unitNormal[t] = nTri;
+    const h = triMaxEdge(mesh, t);
+    let bestName = null;
+    let bestAbsD = Number.POSITIVE_INFINITY;
+    const verts = triVertices(mesh, t);
+    for (const c2 of carriers) {
+      const d2 = carrierSignedDistance(c2.surface, p2, c2.planePoint);
+      if (d2 === null) continue;
+      const absD = Math.abs(d2);
+      const tol = triTolerance(c2.surface, p2, h, safety);
+      if (absD > tol) continue;
+      let vertsOnCarrier = true;
+      for (const vtx of verts) {
+        const dv = carrierSignedDistance(c2.surface, vtx, c2.planePoint);
+        if (dv === null || Math.abs(dv) > tol) {
+          vertsOnCarrier = false;
+          break;
+        }
+      }
+      if (!vertsOnCarrier) continue;
+      const nCarrier = carrierNormalAt(c2.surface, p2, c2.planePoint);
+      if (!nCarrier) continue;
+      const align = Math.abs(dot(nTri, nCarrier));
+      if (align < triAngularCosMin(c2.surface, p2, h, safety)) continue;
+      if (absD < bestAbsD) {
+        bestAbsD = absD;
+        bestName = c2.name;
+      }
+    }
+    assigned[t] = bestName;
+    if (bestName !== null) deviation[t] = bestAbsD;
+  }
+  const parent = new Int32Array(numTri);
+  for (let i = 0; i < numTri; i++) parent[i] = i;
+  const find = (x2) => {
+    let r = x2;
+    while (parent[r] !== r) r = parent[r];
+    while (parent[x2] !== r) {
+      const nx = parent[x2];
+      parent[x2] = r;
+      x2 = nx;
+    }
+    return r;
+  };
+  const unite = (a2, b) => {
+    const ra = find(a2);
+    const rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  };
+  const edgeMap = /* @__PURE__ */ new Map();
+  const edgeKey2 = (a2, b) => a2 < b ? `${a2}_${b}` : `${b}_${a2}`;
+  for (let t = 0; t < numTri; t++) {
+    const a2 = mesh.triVerts[t * 3];
+    const b = mesh.triVerts[t * 3 + 1];
+    const c2 = mesh.triVerts[t * 3 + 2];
+    for (const [u2, v] of [
+      [a2, b],
+      [b, c2],
+      [c2, a2]
+    ]) {
+      const k2 = edgeKey2(u2, v);
+      const other = edgeMap.get(k2);
+      if (other === void 0) {
+        edgeMap.set(k2, t);
+      } else if (assigned[t] === assigned[other]) {
+        if (assigned[t] !== null) {
+          unite(t, other);
+        } else {
+          const na = unitNormal[t];
+          const nb = unitNormal[other];
+          if (na && nb && dot(na, nb) >= SMOOTH_THRESHOLD_DOT) unite(t, other);
+        }
+      }
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (let t = 0; t < numTri; t++) {
+    const r = find(t);
+    let g2 = groups.get(r);
+    if (!g2) {
+      g2 = [];
+      groups.set(r, g2);
+    }
+    g2.push(t);
+  }
+  const faces = [];
+  let unclassified = 0;
+  for (const tris of groups.values()) {
+    const name = assigned[tris[0]];
+    if (name === null) {
+      unclassified += tris.length;
+    }
+    const carrier = carriers.find((c2) => c2.name === name);
+    let maxDev = 0;
+    let maxTol = 0;
+    for (const t of tris) {
+      if (deviation[t] !== Number.POSITIVE_INFINITY) maxDev = Math.max(maxDev, deviation[t]);
+      if (carrier) {
+        const p2 = triCentroid(mesh, t);
+        const h = triMaxEdge(mesh, t);
+        maxTol = Math.max(maxTol, triTolerance(carrier.surface, p2, h, safety));
+      }
+    }
+    faces.push({
+      carrier: name,
+      kind: carrier ? carrier.surface.kind : "unidentified",
+      triangleIndices: tris,
+      connected: true,
+      maxMemberDeviation: maxDev,
+      tol: maxTol
+    });
+  }
+  return { faces, unclassifiedTriangleCount: unclassified };
+}
+const UNIDENTIFIED_FACE_NAME = "unidentified";
+function synthesizePerTriangleFaceIds(result, numTri) {
+  const faceID = new Int32Array(numTri).fill(-1);
+  const faceIdNames = [];
+  for (const face of result.faces) {
+    const id = faceIdNames.length;
+    faceIdNames.push(face.carrier ?? UNIDENTIFIED_FACE_NAME);
+    for (const t of face.triangleIndices) faceID[t] = id;
+  }
+  return { faceID, faceIdNames };
+}
+function buildCarrierFaceRefs(mesh, carriers) {
+  const out = /* @__PURE__ */ new Map();
+  const ids = mesh.faceID;
+  const names = mesh.faceIdNames;
+  if (!ids || !names || ids.length === 0 || names.length === 0) return out;
+  const surfaceByName = /* @__PURE__ */ new Map();
+  for (const c2 of carriers) surfaceByName.set(c2.name, c2.surface);
+  const { triVerts, vertProperties, numProp, numTri } = mesh;
+  const acc = /* @__PURE__ */ new Map();
+  for (let t = 0; t < numTri; t++) {
+    const id = ids[t];
+    if (id < 0) continue;
+    const name = names[id];
+    if (!name || name === UNIDENTIFIED_FACE_NAME) continue;
+    if (!surfaceByName.has(name)) continue;
+    const i0 = triVerts[t * 3] * numProp;
+    const i1 = triVerts[t * 3 + 1] * numProp;
+    const i2 = triVerts[t * 3 + 2] * numProp;
+    const ax = vertProperties[i0], ay = vertProperties[i0 + 1], az = vertProperties[i0 + 2];
+    const bx = vertProperties[i1], by = vertProperties[i1 + 1], bz = vertProperties[i1 + 2];
+    const cx = vertProperties[i2], cy = vertProperties[i2 + 1], cz = vertProperties[i2 + 2];
+    const nx = (by - ay) * (cz - az) - (bz - az) * (cy - ay);
+    const ny = (bz - az) * (cx - ax) - (bx - ax) * (cz - az);
+    const nz = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+    const twoArea = Math.hypot(nx, ny, nz);
+    const area2 = twoArea * 0.5;
+    let a2 = acc.get(name);
+    if (!a2) {
+      a2 = { area: 0, cx: 0, cy: 0, cz: 0, nx: 0, ny: 0, nz: 0, facetNormal: null };
+      acc.set(name, a2);
+    }
+    a2.area += area2;
+    a2.cx += (ax + bx + cx) / 3 * area2;
+    a2.cy += (ay + by + cy) / 3 * area2;
+    a2.cz += (az + bz + cz) / 3 * area2;
+    a2.nx += nx * 0.5;
+    a2.ny += ny * 0.5;
+    a2.nz += nz * 0.5;
+    if (!a2.facetNormal && twoArea > 1e-12) a2.facetNormal = [nx / twoArea, ny / twoArea, nz / twoArea];
+  }
+  for (const [name, a2] of acc) {
+    if (a2.area <= 0) continue;
+    const center2 = [a2.cx / a2.area, a2.cy / a2.area, a2.cz / a2.area];
+    const nlen = Math.hypot(a2.nx, a2.ny, a2.nz);
+    const normal2 = nlen > 1e-9 ? [a2.nx / nlen, a2.ny / nlen, a2.nz / nlen] : a2.facetNormal ?? [0, 0, 1];
+    const surface = surfaceByName.get(name);
+    out.set(name, { name, center: center2, normal: normal2, surface, planar: surface ? surface.kind === "plane" : void 0 });
+  }
+  return out;
+}
 const PLACEMENT_REFERENCE_KINDS = ["points", "edges", "surfaces", "objects"];
 function cloneVec3(value, label) {
   if (!Array.isArray(value) || value.length < 3) {
@@ -45763,9 +46934,9 @@ function midpoint(start, end) {
   return [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2, (start[2] + end[2]) / 2];
 }
 function normalizeVector(value) {
-  const len = Math.hypot(value[0], value[1], value[2]);
-  if (len < 1e-10) return [0, 0, 1];
-  return [value[0] / len, value[1] / len, value[2] / len];
+  const len2 = Math.hypot(value[0], value[1], value[2]);
+  if (len2 < 1e-10) return [0, 0, 1];
+  return [value[0] / len2, value[1] / len2, value[2] / len2];
 }
 function isBoundsObject(value) {
   return !!value && typeof value === "object" && "min" in value && "max" in value;
@@ -46578,9 +47749,9 @@ function requireVec3Pivot(v, method) {
 }
 function mirrorPlaneMatrix(normal2) {
   const [nx0, ny0, nz0] = normal2;
-  const len = Math.hypot(nx0, ny0, nz0);
-  if (len < 1e-12) return Transform.identity().toArray();
-  const nx = nx0 / len, ny = ny0 / len, nz = nz0 / len;
+  const len2 = Math.hypot(nx0, ny0, nz0);
+  if (len2 < 1e-12) return Transform.identity().toArray();
+  const nx = nx0 / len2, ny = ny0 / len2, nz = nz0 / len2;
   const m00 = 1 - 2 * nx * nx, m01 = -2 * nx * ny, m02 = -2 * nx * nz;
   const m10 = -2 * ny * nx, m11 = 1 - 2 * ny * ny, m12 = -2 * ny * nz;
   const m20 = -2 * nz * nx, m21 = -2 * nz * ny, m22 = 1 - 2 * nz * nz;
@@ -46825,8 +47996,8 @@ class ShapeGroup {
   /** Reorient the group so its local Z axis points along `direction`. */
   pointAlong(direction) {
     const [dx, dy, dz] = requireNonZeroFiniteVec3(direction, "ShapeGroup.pointAlong() direction");
-    const len = Math.sqrt(dx * dx + dy * dy + dz * dz) || 1;
-    const nx = dx / len, ny = dy / len, nz = dz / len;
+    const len2 = Math.sqrt(dx * dx + dy * dy + dz * dz) || 1;
+    const nx = dx / len2, ny = dy / len2, nz = dz / len2;
     const cx = -ny, cy = nx, cz = 0;
     const sinA = Math.sqrt(cx * cx + cy * cy + cz * cz);
     const cosA = nz;
@@ -47037,9 +48208,9 @@ class ShapeGroup {
     if (firstPair) {
       const selfAxis = firstPair.selfPort.axis;
       const transformed = tx.vector(selfAxis);
-      const len = Math.hypot(transformed[0], transformed[1], transformed[2]);
-      if (len > 1e-10) {
-        _groupExplodeHint.set(result, [transformed[0] / len, transformed[1] / len, transformed[2] / len]);
+      const len2 = Math.hypot(transformed[0], transformed[1], transformed[2]);
+      if (len2 > 1e-10) {
+        _groupExplodeHint.set(result, [transformed[0] / len2, transformed[1] / len2, transformed[2] / len2]);
       }
     }
     return result;
@@ -47296,12 +48467,15 @@ function rootTopologyRewritePropagation(plan) {
     case "variableSweep":
     case "filletEdges":
     case "cornerYBlend":
+    case "faceFillet":
+    case "fullRound":
     case "chamferEdges":
     case "draft":
     case "offsetSolid":
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "fromSectionFrames":
     case "analyticSurface":
     case "nurbsSurface":
     case "surfaceRuled":
@@ -47729,12 +48903,15 @@ function rootPlanPropagation(plan) {
     case "variableSweep":
     case "filletEdges":
     case "cornerYBlend":
+    case "faceFillet":
+    case "fullRound":
     case "chamferEdges":
     case "draft":
     case "offsetSolid":
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "fromSectionFrames":
     case "analyticSurface":
     case "nurbsSurface":
     case "surfaceRuled":
@@ -48069,11 +49246,11 @@ function clusterTriangles(mesh) {
     let nx = e1y * e2z - e1z * e2y;
     let ny = e1z * e2x - e1x * e2z;
     let nz = e1x * e2y - e1y * e2x;
-    const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
-    if (len < 1e-10) continue;
-    nx /= len;
-    ny /= len;
-    nz /= len;
+    const len2 = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    if (len2 < 1e-10) continue;
+    nx /= len2;
+    ny /= len2;
+    nz /= len2;
     const normal2 = [nx, ny, nz];
     const planeOffset = nx * v0x + ny * v0y + nz * v0z;
     let matched = -1;
@@ -48161,10 +49338,10 @@ function extractEdgesWithFaces(mesh, triCluster) {
     const nx = e1y * e2z - e1z * e2y;
     const ny = e1z * e2x - e1x * e2z;
     const nz = e1x * e2y - e1y * e2x;
-    const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
-    faceNx[t] = nx / len;
-    faceNy[t] = ny / len;
-    faceNz[t] = nz / len;
+    const len2 = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+    faceNx[t] = nx / len2;
+    faceNy[t] = ny / len2;
+    faceNz[t] = nz / len2;
   }
   const numVerts = vertProperties.length / numProp;
   const canon = buildCanonicalMap$1(numVerts, mesh.mergeFromVert, mesh.mergeToVert);
@@ -48424,9 +49601,9 @@ function extractFaceVertices(mesh, faceNormal, faceCenter, tolerance = 0.5) {
   return vertices;
 }
 function normalize(v) {
-  const len = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-  if (len < 1e-12) throw new Error("Cannot normalize zero-length vector.");
-  return [v[0] / len, v[1] / len, v[2] / len];
+  const len2 = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+  if (len2 < 1e-12) throw new Error("Cannot normalize zero-length vector.");
+  return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function computeSeatTranslation(faceVertices, faceNormal, targetMesh, options = {}) {
   const depth = options.depth ?? "full";
@@ -48713,10 +49890,10 @@ function rotationAroundAxisMatrix(axis, angleDeg, pivot) {
   const rad = angleDeg * Math.PI / 180;
   const cos2 = Math.cos(rad);
   const sin2 = Math.sin(rad);
-  const len = Math.sqrt(axis[0] ** 2 + axis[1] ** 2 + axis[2] ** 2) || 1;
-  const ux = axis[0] / len;
-  const uy = axis[1] / len;
-  const uz = axis[2] / len;
+  const len2 = Math.sqrt(axis[0] ** 2 + axis[1] ** 2 + axis[2] ** 2) || 1;
+  const ux = axis[0] / len2;
+  const uy = axis[1] / len2;
+  const uz = axis[2] / len2;
   const m00 = cos2 + ux * ux * (1 - cos2);
   const m01 = ux * uy * (1 - cos2) - uz * sin2;
   const m02 = ux * uz * (1 - cos2) + uy * sin2;
@@ -48733,11 +49910,11 @@ function rotationAroundAxisMatrix(axis, angleDeg, pivot) {
 }
 function mirrorMatrix(normal2) {
   const [nx0, ny0, nz0] = normal2;
-  const len = Math.hypot(nx0, ny0, nz0);
-  if (len < 1e-12) return Transform.identity().toArray();
-  const nx = nx0 / len;
-  const ny = ny0 / len;
-  const nz = nz0 / len;
+  const len2 = Math.hypot(nx0, ny0, nz0);
+  if (len2 < 1e-12) return Transform.identity().toArray();
+  const nx = nx0 / len2;
+  const ny = ny0 / len2;
+  const nz = nz0 / len2;
   const m00 = 1 - 2 * nx * nx;
   const m01 = -2 * nx * ny;
   const m02 = -2 * nx * nz;
@@ -48821,6 +49998,7 @@ const _shapeTopology = /* @__PURE__ */ new WeakMap();
 const _shapeLineageTokens = /* @__PURE__ */ new WeakMap();
 const _shapeFaceLabels = /* @__PURE__ */ new WeakMap();
 const _shapeReferenceNames = /* @__PURE__ */ new WeakMap();
+const _shapeCarrierFaceRefs = /* @__PURE__ */ new WeakMap();
 const _shapeReferenceAliases = /* @__PURE__ */ new WeakMap();
 const _edgeRefOwners = /* @__PURE__ */ new WeakMap();
 const _faceRefOwners = /* @__PURE__ */ new WeakMap();
@@ -49034,6 +50212,32 @@ function getShapeRuntimeBackendInternal(shape) {
   if (!backend) throw new Error("Runtime backend missing on Shape");
   return backend;
 }
+function withCarrierFaceIds(mesh, shape) {
+  if (mesh.faceID && mesh.faceID.length > 0 && mesh.faceIdNames && mesh.faceIdNames.length > 0) return mesh;
+  if (mesh.numTri === 0) return mesh;
+  const carriers = gatherShapeCarriers(getShapeCompilePlanInternal(shape));
+  if (carriers.length === 0) return mesh;
+  const result = classifyMeshFaces(mesh, carriers);
+  const { faceID, faceIdNames } = synthesizePerTriangleFaceIds(result, mesh.numTri);
+  if (faceIdNames.length === 0) return mesh;
+  const writable = mesh;
+  writable.faceID = faceID;
+  writable.faceIdNames = faceIdNames;
+  return mesh;
+}
+function getCarrierFaceRefs(shape) {
+  const cached = _shapeCarrierFaceRefs.get(shape);
+  if (cached) return cached;
+  let refs;
+  try {
+    const mesh = shape.getMesh();
+    refs = buildCarrierFaceRefs(mesh, gatherShapeCarriers(getShapeCompilePlanInternal(shape)));
+  } catch {
+    refs = /* @__PURE__ */ new Map();
+  }
+  _shapeCarrierFaceRefs.set(shape, refs);
+  return refs;
+}
 function getShapeCompilePlanInternal(shape) {
   const stored = _shapeCompilePlans.get(shape);
   if (!stored) throw new Error("Shape has no compile plan — every Shape must have an explicit plan set via setShapeCompilePlanInternal()");
@@ -49791,9 +50995,9 @@ function withTransformedDimensions(source, out, m2) {
   if (sourceHint) {
     const tx = Transform.from(m2);
     const transformed = tx.vector(sourceHint);
-    const len = Math.hypot(transformed[0], transformed[1], transformed[2]);
-    if (len > 1e-10) {
-      setShapeExplodeHintInternal(out, [transformed[0] / len, transformed[1] / len, transformed[2] / len]);
+    const len2 = Math.hypot(transformed[0], transformed[1], transformed[2]);
+    if (len2 > 1e-10) {
+      setShapeExplodeHintInternal(out, [transformed[0] / len2, transformed[1] / len2, transformed[2] / len2]);
     }
   }
   if (source.materialProps) out.materialProps = { ...source.materialProps };
@@ -49874,6 +51078,14 @@ function setShapePlacementReferences(shape, refs, options = {}) {
 function getShapeRuntimeBackend(shape) {
   return getShapeRuntimeBackendInternal(shape);
 }
+function getShapeCompilePlan(shape) {
+  return getShapeCompilePlanInternal(shape);
+}
+function getShapeSourceSpans(shape) {
+  const records = _shapeSourceSpans.get(shape);
+  if (!records) return [];
+  return [...records].map(([planCacheKey, sourceSpan]) => ({ planCacheKey, sourceSpan }));
+}
 function setShapeCompilePlan(shape, plan) {
   return setShapeCompilePlanInternal(shape, plan);
 }
@@ -50539,6 +51751,10 @@ class Shape {
       const detected = queryMeshFace(this, query);
       if (detected) return rememberFaceRefOwner(this, detected);
     }
+    if (compilePlanName) {
+      const carrierRef = getCarrierFaceRefs(this).get(compilePlanName);
+      if (carrierRef) return rememberFaceRefOwner(this, { ...carrierRef }, compilePlanName);
+    }
     if (compilePlanName) {
       const plan = getShapeCompilePlanInternal(this);
       throw new Error(explainMissingShapeFace(plan, compilePlanName));
@@ -50564,6 +51780,7 @@ class Shape {
     if (topo) {
       for (const topoName of topo.faces.keys()) all.add(topoName);
     }
+    for (const carrierName of getCarrierFaceRefs(this).keys()) all.add(carrierName);
     if (!labels || labels.size === 0) return Array.from(all).sort();
     for (const userLabel of labels.keys()) all.add(userLabel);
     return Array.from(all).sort();
@@ -50793,7 +52010,8 @@ class Shape {
     if (!face) {
       throw new Error(explainMissingShapeFace(plan, name));
     }
-    return traceFaceTransformationHistory(plan, face);
+    const sourceSpans = new Map(getShapeSourceSpans(this).map((record) => [record.planCacheKey, record.sourceSpan]));
+    return traceFaceTransformationHistory(plan, face, sourceSpans);
   }
   /**
    * Translate the shape so the given anchor or reference lands on the target coordinate.
@@ -50995,8 +52213,8 @@ class Shape {
    */
   pointAlong(direction) {
     const [dx, dy, dz] = requireNonZeroFiniteVec3(direction, "Shape.pointAlong() direction");
-    const len = Math.sqrt(dx * dx + dy * dy + dz * dz) || 1;
-    const nx = dx / len, ny = dy / len, nz = dz / len;
+    const len2 = Math.sqrt(dx * dx + dy * dy + dz * dz) || 1;
+    const nx = dx / len2, ny = dy / len2, nz = dz / len2;
     const cx = -ny, cy = nx, cz = 0;
     const sinA = Math.sqrt(cx * cx + cy * cy + cz * cz);
     const cosA = nz;
@@ -51016,8 +52234,8 @@ class Shape {
     const rotateAxis = requireNonZeroFiniteVec3(axis, "Shape.rotateAroundAxis() axis");
     const degrees = requireFiniteNumber(angleDeg, "Shape.rotateAroundAxis() angleDeg");
     const rotatePivot = requireFiniteVec3$1(pivot, "Shape.rotateAroundAxis() pivot");
-    const len = Math.sqrt(rotateAxis[0] ** 2 + rotateAxis[1] ** 2 + rotateAxis[2] ** 2) || 1;
-    const normalizedAxis = [rotateAxis[0] / len, rotateAxis[1] / len, rotateAxis[2] / len];
+    const len2 = Math.sqrt(rotateAxis[0] ** 2 + rotateAxis[1] ** 2 + rotateAxis[2] ** 2) || 1;
+    const normalizedAxis = [rotateAxis[0] / len2, rotateAxis[1] / len2, rotateAxis[2] / len2];
     const matrix = rotationAroundAxisMatrix(normalizedAxis, degrees, rotatePivot);
     const nextPlan = appendShapeCompileTransform(getShapeCompilePlanInternal(this), {
       kind: "rotateAround",
@@ -51338,7 +52556,8 @@ class Shape {
   }
   /** Extract triangle mesh for Three.js rendering */
   getMesh() {
-    return getShapeRuntimeBackendInternal(this).getMesh();
+    const mesh = getShapeRuntimeBackendInternal(this).getMesh();
+    return withCarrierFaceIds(mesh, this);
   }
   /** Slice the runtime solid by a plane normal to local Z at the given offset. */
   slice(offset = 0) {
@@ -51558,9 +52777,9 @@ class Shape {
     if (firstPair) {
       const selfAxis = firstPair.selfPort.axis;
       const transformed = tx.vector(selfAxis);
-      const len = Math.hypot(transformed[0], transformed[1], transformed[2]);
-      if (len > 1e-10) {
-        setShapeExplodeHintInternal(result, [transformed[0] / len, transformed[1] / len, transformed[2] / len]);
+      const len2 = Math.hypot(transformed[0], transformed[1], transformed[2]);
+      if (len2 > 1e-10) {
+        setShapeExplodeHintInternal(result, [transformed[0] / len2, transformed[1] / len2, transformed[2] / len2]);
       }
     }
     markPortsUsed(
@@ -51680,6 +52899,257 @@ function normalizeShapeOperands(apiName, inputs, minCount, usage) {
     coerce: (value) => unwrapShapeLike(value)
   });
 }
+const PARALLEL_DOT = Math.cos(0.5 * Math.PI / 180);
+function vertPos(mesh, vIdx) {
+  const b = vIdx * mesh.numProp;
+  return [mesh.vertProperties[b], mesh.vertProperties[b + 1], mesh.vertProperties[b + 2]];
+}
+const edgeKey = (a2, b) => a2 < b ? `${a2}_${b}` : `${b}_${a2}`;
+const pairKey = (a2, b) => JSON.stringify(a2 < b ? [a2, b] : [b, a2]);
+function buildCanonicalMap(mesh) {
+  const numVerts = mesh.vertProperties.length / mesh.numProp;
+  const canon = new Uint32Array(numVerts);
+  for (let i = 0; i < numVerts; i++) canon[i] = i;
+  const { mergeFromVert, mergeToVert } = mesh;
+  if (mergeFromVert && mergeToVert) {
+    for (let i = 0; i < mergeFromVert.length; i++) canon[mergeFromVert[i]] = mergeToVert[i];
+    for (let i = 0; i < numVerts; i++) {
+      let v = canon[i];
+      while (canon[v] !== v) v = canon[v];
+      canon[i] = v;
+    }
+  }
+  return canon;
+}
+function buildEdgeClassification(mesh, carriers) {
+  const ids = mesh.faceID;
+  const names = mesh.faceIdNames;
+  if (!ids || !names || ids.length === 0 || names.length === 0) return [];
+  if (mesh.numTri === 0) return [];
+  const surfaceByName = /* @__PURE__ */ new Map();
+  const planePointByName = /* @__PURE__ */ new Map();
+  for (const c2 of carriers) {
+    surfaceByName.set(c2.name, c2.surface);
+    if (c2.planePoint) planePointByName.set(c2.name, c2.planePoint);
+  }
+  const canon = buildCanonicalMap(mesh);
+  const edgeOwner = /* @__PURE__ */ new Map();
+  const byPair = /* @__PURE__ */ new Map();
+  const triFaceName = (t) => {
+    const id = ids[t];
+    if (id < 0) return null;
+    return names[id] ?? null;
+  };
+  for (let t = 0; t < mesh.numTri; t++) {
+    const v0 = mesh.triVerts[t * 3];
+    const v1 = mesh.triVerts[t * 3 + 1];
+    const v2 = mesh.triVerts[t * 3 + 2];
+    const ca = canon[v0];
+    const cb = canon[v1];
+    const cc = canon[v2];
+    for (const [u2, v] of [
+      [ca, cb],
+      [cb, cc],
+      [cc, ca]
+    ]) {
+      const k2 = edgeKey(u2, v);
+      const other = edgeOwner.get(k2);
+      if (other === void 0) {
+        edgeOwner.set(k2, t);
+        continue;
+      }
+      const nameThis = triFaceName(t);
+      const nameOther = triFaceName(other);
+      if (nameThis === null || nameOther === null) continue;
+      if (nameThis === nameOther) continue;
+      const pk = pairKey(nameThis, nameOther);
+      let bucket = byPair.get(pk);
+      if (!bucket) {
+        const [fa, fb] = nameThis < nameOther ? [nameThis, nameOther] : [nameOther, nameThis];
+        bucket = { faceA: fa, faceB: fb, edges: [] };
+        byPair.set(pk, bucket);
+      }
+      bucket.edges.push({ a: u2, b: v });
+    }
+  }
+  const result = [];
+  for (const bucket of byPair.values()) {
+    const chains = splitIntoChains(bucket.edges);
+    for (const chainVerts of chains) {
+      const chain = chainVerts.map((vi) => vertPos(mesh, vi));
+      if (chain.length < 2) continue;
+      const { curve, length: length4 } = deriveCurve(bucket.faceA, bucket.faceB, chain, surfaceByName, planePointByName);
+      result.push({ faceA: bucket.faceA, faceB: bucket.faceB, curve, length: length4, chain });
+    }
+  }
+  return result;
+}
+function splitIntoChains(edges) {
+  const adj = /* @__PURE__ */ new Map();
+  const addAdj = (x2, y2) => {
+    let l = adj.get(x2);
+    if (!l) {
+      l = [];
+      adj.set(x2, l);
+    }
+    l.push(y2);
+  };
+  const seenEdge = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    const k2 = edgeKey(e.a, e.b);
+    if (seenEdge.has(k2)) continue;
+    seenEdge.add(k2);
+    addAdj(e.a, e.b);
+    addAdj(e.b, e.a);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const chains = [];
+  for (const startSeed of adj.keys()) {
+    if (visited.has(startSeed)) continue;
+    const compVerts = [];
+    const stack = [startSeed];
+    visited.add(startSeed);
+    while (stack.length) {
+      const v = stack.pop();
+      compVerts.push(v);
+      for (const w2 of adj.get(v) ?? []) {
+        if (!visited.has(w2)) {
+          visited.add(w2);
+          stack.push(w2);
+        }
+      }
+    }
+    chains.push(orderComponent(compVerts, adj));
+  }
+  return chains;
+}
+function orderComponent(compVerts, adj, seenEdge) {
+  var _a3, _b3;
+  if (compVerts.length <= 2) return compVerts;
+  let start = compVerts[0];
+  for (const v of compVerts) {
+    if ((((_a3 = adj.get(v)) == null ? void 0 : _a3.length) ?? 0) === 1) {
+      start = v;
+      break;
+    }
+  }
+  const ordered = [];
+  const usedEdge = /* @__PURE__ */ new Set();
+  let prev = -1;
+  let cur = start;
+  for (let guard = 0; guard <= compVerts.length; guard++) {
+    ordered.push(cur);
+    let next = -1;
+    for (const w2 of adj.get(cur) ?? []) {
+      const k2 = edgeKey(cur, w2);
+      if (usedEdge.has(k2)) continue;
+      if (w2 === prev && (((_b3 = adj.get(cur)) == null ? void 0 : _b3.length) ?? 0) > 1) continue;
+      next = w2;
+      usedEdge.add(k2);
+      break;
+    }
+    if (next === -1) break;
+    prev = cur;
+    cur = next;
+    if (cur === start) {
+      ordered.push(cur);
+      break;
+    }
+  }
+  return ordered;
+}
+function polylineLength(chain) {
+  let L = 0;
+  for (let i = 1; i < chain.length; i++) L += len(sub(chain[i], chain[i - 1]));
+  return L;
+}
+function deriveCurve(faceA, faceB, chain, surfaceByName, planePointByName) {
+  const sA = surfaceByName.get(faceA);
+  const sB = surfaceByName.get(faceB);
+  if ((sA == null ? void 0 : sA.kind) === "plane" && (sB == null ? void 0 : sB.kind) === "plane") {
+    const { start, end } = chainExtremes(chain);
+    return {
+      curve: { kind: "line", start, end, faceName: faceA },
+      length: len(sub(end, start))
+    };
+  }
+  const planeFirst = (sA == null ? void 0 : sA.kind) === "plane";
+  const plane = planeFirst ? sA : (sB == null ? void 0 : sB.kind) === "plane" ? sB : void 0;
+  const planeName = planeFirst ? faceA : faceB;
+  const curved = planeFirst ? sB : sA;
+  const curvedName = planeFirst ? faceB : faceA;
+  if (plane && curved) {
+    const circle = circleFromPlaneAndCarrier(plane, planeName, curved, curvedName, chain, planePointByName);
+    if (circle) {
+      return { curve: circle, length: 2 * Math.PI * circle.radius };
+    }
+  }
+  return { curve: { kind: "unidentified" }, length: polylineLength(chain) };
+}
+function circleFromPlaneAndCarrier(plane, planeName, curved, curvedName, chain, planePointByName) {
+  const planePoint = planePointByName.get(planeName);
+  if (!planePoint) return null;
+  const n = normalize$1(plane.normal);
+  const onEdge = chainCentroid(chain);
+  switch (curved.kind) {
+    case "cylinder": {
+      const ax = normalize$1(curved.axis);
+      if (Math.abs(dot(ax, n)) < PARALLEL_DOT) return null;
+      const center2 = axisPointAtPlane(curved.origin, ax, onEdge);
+      return { kind: "circle", center: center2, axis: ax, radius: curved.radius, faceName: curvedName };
+    }
+    case "cone": {
+      const ax = normalize$1(curved.axis);
+      if (Math.abs(dot(ax, n)) < PARALLEL_DOT) return null;
+      const center2 = axisPointAtPlane(curved.origin, ax, onEdge);
+      const t = dot(sub(center2, curved.origin), ax);
+      const radius = curved.radiusBottom + (curved.radiusTop - curved.radiusBottom) * (t / curved.height);
+      if (!(radius > DEGENERATE)) return null;
+      return { kind: "circle", center: center2, axis: ax, radius, faceName: curvedName };
+    }
+    case "sphere": {
+      const dPlane = dot(n, sub(curved.center, planePoint));
+      const r2 = curved.radius * curved.radius - dPlane * dPlane;
+      if (!(r2 > DEGENERATE)) return null;
+      const center2 = sub(curved.center, scl(n, dPlane));
+      return { kind: "circle", center: center2, axis: n, radius: Math.sqrt(r2), faceName: curvedName };
+    }
+    default:
+      return null;
+  }
+}
+function axisPointAtPlane(origin, ax, onEdge) {
+  const t = dot(sub(onEdge, origin), ax);
+  return add(origin, scl(ax, t));
+}
+function chainCentroid(chain) {
+  let x2 = 0;
+  let y2 = 0;
+  let z2 = 0;
+  for (const p2 of chain) {
+    x2 += p2[0];
+    y2 += p2[1];
+    z2 += p2[2];
+  }
+  const k2 = 1 / chain.length;
+  return [x2 * k2, y2 * k2, z2 * k2];
+}
+function chainExtremes(chain) {
+  let best = -1;
+  let si = 0;
+  let ei = chain.length - 1;
+  for (let i = 0; i < chain.length; i++) {
+    for (let j = i + 1; j < chain.length; j++) {
+      const d2 = len(sub(chain[j], chain[i]));
+      if (d2 > best) {
+        best = d2;
+        si = i;
+        ei = j;
+      }
+    }
+  }
+  return { start: chain[si], end: chain[ei] };
+}
 function cloneSerializedFaceRef(face) {
   return {
     ...face,
@@ -51713,6 +53183,7 @@ class FrozenShapeBackend {
       edgePositions: this._data.geometryEdgePositions,
       triangleFaceIds: this._data.geometryTriangleFaceIds,
       faceIdNames: this._data.geometryFaceIdNames,
+      forgeEdges: this._data.geometryEdges ?? [],
       hasSmoothNormals: this._data.hasSmoothNormals ?? false,
       uvs: this._data.geometryUvs
     };
@@ -51881,249 +53352,25 @@ class FrozenShape extends Shape {
     return history;
   }
 }
-const EDGE_THRESHOLD_DOT = Math.cos(Math.PI / 180);
-const SMOOTH_THRESHOLD_DOT = Math.cos(30 * Math.PI / 180);
-function computeGeometryArrays(mesh, options = {}) {
-  const { numProp, numTri: triCount, triVerts, vertProperties, vertNormals, cornerNormals } = mesh;
-  if (numProp !== NUM_PROP_POSITION_ONLY && numProp !== NUM_PROP_WITH_NORMAL && numProp !== NUM_PROP_WITH_UV) {
-    throw new Error(
-      `computeGeometryArrays: illegal vertProperties numProp ${numProp}. Only ${NUM_PROP_POSITION_ONLY} (position), ${NUM_PROP_WITH_NORMAL} (position+normal), and ${NUM_PROP_WITH_UV} (position+normal+uv) are valid; ${numProp} (e.g. a truncated uv channel) is not.`
-    );
-  }
-  const hasStoredNormals = numProp === NUM_PROP_WITH_NORMAL || numProp === NUM_PROP_WITH_UV;
-  const hasStoredUvs = numProp === NUM_PROP_WITH_UV;
-  const useCornerNormals = !!cornerNormals && cornerNormals.length === triCount * 9;
-  const positions = new Float32Array(triCount * 9);
-  const normals = new Float32Array(triCount * 9);
-  const uvs = hasStoredUvs ? new Float32Array(triCount * 6) : void 0;
-  const faceNx = new Float32Array(triCount);
-  const faceNy = new Float32Array(triCount);
-  const faceNz = new Float32Array(triCount);
-  for (let t = 0; t < triCount; t++) {
-    const i0 = triVerts[t * 3];
-    const i1 = triVerts[t * 3 + 1];
-    const i2 = triVerts[t * 3 + 2];
-    const ax = vertProperties[i0 * numProp], ay = vertProperties[i0 * numProp + 1], az = vertProperties[i0 * numProp + 2];
-    const bx = vertProperties[i1 * numProp], by = vertProperties[i1 * numProp + 1], bz = vertProperties[i1 * numProp + 2];
-    const cx = vertProperties[i2 * numProp], cy = vertProperties[i2 * numProp + 1], cz = vertProperties[i2 * numProp + 2];
-    const e1x = bx - ax, e1y = by - ay, e1z = bz - az;
-    const e2x = cx - ax, e2y = cy - ay, e2z = cz - az;
-    let fnx = e1y * e2z - e1z * e2y;
-    let fny = e1z * e2x - e1x * e2z;
-    let fnz = e1x * e2y - e1y * e2x;
-    const len = Math.sqrt(fnx * fnx + fny * fny + fnz * fnz) || 1;
-    fnx /= len;
-    fny /= len;
-    fnz /= len;
-    const o = t * 9;
-    positions[o] = ax;
-    positions[o + 1] = ay;
-    positions[o + 2] = az;
-    positions[o + 3] = bx;
-    positions[o + 4] = by;
-    positions[o + 5] = bz;
-    positions[o + 6] = cx;
-    positions[o + 7] = cy;
-    positions[o + 8] = cz;
-    if (uvs) {
-      const u2 = t * 6;
-      uvs[u2] = vertProperties[i0 * numProp + UV_OFFSET];
-      uvs[u2 + 1] = vertProperties[i0 * numProp + UV_OFFSET + 1];
-      uvs[u2 + 2] = vertProperties[i1 * numProp + UV_OFFSET];
-      uvs[u2 + 3] = vertProperties[i1 * numProp + UV_OFFSET + 1];
-      uvs[u2 + 4] = vertProperties[i2 * numProp + UV_OFFSET];
-      uvs[u2 + 5] = vertProperties[i2 * numProp + UV_OFFSET + 1];
-    }
-    if (useCornerNormals) {
-      for (let k2 = 0; k2 < 9; k2++) normals[o + k2] = cornerNormals[o + k2];
-    } else if (vertNormals) {
-      normals[o] = vertNormals[i0 * 3];
-      normals[o + 1] = vertNormals[i0 * 3 + 1];
-      normals[o + 2] = vertNormals[i0 * 3 + 2];
-      normals[o + 3] = vertNormals[i1 * 3];
-      normals[o + 4] = vertNormals[i1 * 3 + 1];
-      normals[o + 5] = vertNormals[i1 * 3 + 2];
-      normals[o + 6] = vertNormals[i2 * 3];
-      normals[o + 7] = vertNormals[i2 * 3 + 1];
-      normals[o + 8] = vertNormals[i2 * 3 + 2];
-    } else if (hasStoredNormals) {
-      const corners = [i0, i1, i2];
-      for (let v = 0; v < 3; v++) {
-        const base = corners[v] * numProp;
-        const nx = vertProperties[base + NORMAL_OFFSET];
-        const ny = vertProperties[base + NORMAL_OFFSET + 1];
-        const nz = vertProperties[base + NORMAL_OFFSET + 2];
-        const oc = o + v * 3;
-        if (nx * nx + ny * ny + nz * nz > 1e-12) {
-          normals[oc] = nx;
-          normals[oc + 1] = ny;
-          normals[oc + 2] = nz;
-        } else {
-          normals[oc] = fnx;
-          normals[oc + 1] = fny;
-          normals[oc + 2] = fnz;
-        }
-      }
-    } else {
-      normals[o] = fnx;
-      normals[o + 1] = fny;
-      normals[o + 2] = fnz;
-      normals[o + 3] = fnx;
-      normals[o + 4] = fny;
-      normals[o + 5] = fnz;
-      normals[o + 6] = fnx;
-      normals[o + 7] = fny;
-      normals[o + 8] = fnz;
-    }
-    faceNx[t] = fnx;
-    faceNy[t] = fny;
-    faceNz[t] = fnz;
-  }
-  if (!useCornerNormals && !vertNormals && !hasStoredNormals && triCount > 0) {
-    computeAutoSmoothNormals(
-      triVerts,
-      vertProperties,
-      numProp,
-      triCount,
-      faceNx,
-      faceNy,
-      faceNz,
-      normals,
-      mesh.mergeFromVert,
-      mesh.mergeToVert
-    );
-  }
-  const edgePositions = options.skipEdges ? new Float32Array(0) : computeSharpEdges(triVerts, vertProperties, numProp, triCount, faceNx, faceNy, faceNz, mesh.mergeFromVert, mesh.mergeToVert);
-  return {
-    positions,
-    normals,
-    edgePositions,
-    hasSmoothNormals: triCount > 0,
-    uvs
-  };
-}
-function computeAutoSmoothNormals(triVerts, vertProperties, numProp, triCount, faceNx, faceNy, faceNz, normals, mergeFromVert, mergeToVert) {
-  const numVerts = vertProperties.length / numProp;
-  const canon = buildCanonicalMap(numVerts, mergeFromVert, mergeToVert);
-  const vertToTris = /* @__PURE__ */ new Map();
-  for (let t = 0; t < triCount; t++) {
-    for (let v = 0; v < 3; v++) {
-      const cv = canon[triVerts[t * 3 + v]];
-      let list = vertToTris.get(cv);
-      if (!list) {
-        list = [];
-        vertToTris.set(cv, list);
-      }
-      list.push(t);
-    }
-  }
-  for (let t = 0; t < triCount; t++) {
-    for (let v = 0; v < 3; v++) {
-      const cv = canon[triVerts[t * 3 + v]];
-      const adjacentTris = vertToTris.get(cv);
-      if (!adjacentTris || adjacentTris.length <= 1) continue;
-      let sx = 0, sy = 0, sz = 0;
-      for (const adj of adjacentTris) {
-        const dot2 = faceNx[t] * faceNx[adj] + faceNy[t] * faceNy[adj] + faceNz[t] * faceNz[adj];
-        if (dot2 >= SMOOTH_THRESHOLD_DOT) {
-          sx += faceNx[adj];
-          sy += faceNy[adj];
-          sz += faceNz[adj];
-        }
-      }
-      const slen = Math.sqrt(sx * sx + sy * sy + sz * sz);
-      if (slen > 1e-9) {
-        sx /= slen;
-        sy /= slen;
-        sz /= slen;
-        const o = t * 9 + v * 3;
-        normals[o] = sx;
-        normals[o + 1] = sy;
-        normals[o + 2] = sz;
-      }
-    }
-  }
-}
-function computeSharpEdges(triVerts, vertProperties, numProp, triCount, faceNx, faceNy, faceNz, mergeFromVert, mergeToVert) {
-  const numVerts = vertProperties.length / numProp;
-  const canon = buildCanonicalMap(numVerts, mergeFromVert, mergeToVert);
-  const MAX_NUMERIC = 1 << 21;
-  let maxCanon = 0;
-  for (let i = 0; i < numVerts; i++) {
-    if (canon[i] > maxCanon) maxCanon = canon[i];
-  }
-  const useNumeric = maxCanon < MAX_NUMERIC;
-  const halfEdges = /* @__PURE__ */ new Map();
-  const edgeList = [];
-  for (let t = 0; t < triCount; t++) {
-    const ca = canon[triVerts[t * 3]];
-    const cb = canon[triVerts[t * 3 + 1]];
-    const cc = canon[triVerts[t * 3 + 2]];
-    const tv = [ca, cb, cc];
-    for (let e = 0; e < 3; e++) {
-      const va = tv[e], vb = tv[(e + 1) % 3];
-      const fwdKey = useNumeric ? va * MAX_NUMERIC + vb : `${va},${vb}`;
-      const revKey = useNumeric ? vb * MAX_NUMERIC + va : `${vb},${va}`;
-      const adjTri = halfEdges.get(revKey);
-      if (adjTri !== void 0) {
-        const dot2 = faceNx[t] * faceNx[adjTri] + faceNy[t] * faceNy[adjTri] + faceNz[t] * faceNz[adjTri];
-        if (dot2 <= EDGE_THRESHOLD_DOT) {
-          const origVa = triVerts[t * 3 + e];
-          const origVb = triVerts[t * 3 + (e + 1) % 3];
-          edgeList.push(
-            vertProperties[origVa * numProp],
-            vertProperties[origVa * numProp + 1],
-            vertProperties[origVa * numProp + 2],
-            vertProperties[origVb * numProp],
-            vertProperties[origVb * numProp + 1],
-            vertProperties[origVb * numProp + 2]
-          );
-        }
-        halfEdges.delete(revKey);
-      } else {
-        halfEdges.set(fwdKey, t);
-      }
-    }
-  }
-  for (const [key2, t] of halfEdges) {
-    const ca = canon[triVerts[t * 3]];
-    const cb = canon[triVerts[t * 3 + 1]];
-    const cc = canon[triVerts[t * 3 + 2]];
-    const tv = [ca, cb, cc];
-    for (let e = 0; e < 3; e++) {
-      const va = tv[e], vb = tv[(e + 1) % 3];
-      const fwdKey = useNumeric ? va * MAX_NUMERIC + vb : `${va},${vb}`;
-      if (fwdKey === key2) {
-        const origVa = triVerts[t * 3 + e];
-        const origVb = triVerts[t * 3 + (e + 1) % 3];
-        edgeList.push(
-          vertProperties[origVa * numProp],
-          vertProperties[origVa * numProp + 1],
-          vertProperties[origVa * numProp + 2],
-          vertProperties[origVb * numProp],
-          vertProperties[origVb * numProp + 1],
-          vertProperties[origVb * numProp + 2]
-        );
-        break;
-      }
-    }
+function toBakedEdge(edge) {
+  const points = [];
+  for (const p2 of edge.chain) {
+    points.push(p2[0], p2[1], p2[2]);
   }
-  return new Float32Array(edgeList);
+  return { faceA: edge.faceA, faceB: edge.faceB, curve: edge.curve, length: edge.length, points };
 }
-function buildCanonicalMap(numVerts, mergeFromVert, mergeToVert) {
-  const canon = new Uint32Array(numVerts);
-  for (let i = 0; i < numVerts; i++) canon[i] = i;
-  if (mergeFromVert && mergeToVert) {
-    for (let i = 0; i < mergeFromVert.length; i++) {
-      canon[mergeFromVert[i]] = mergeToVert[i];
-    }
-    for (let i = 0; i < numVerts; i++) {
-      let v = canon[i];
-      while (canon[v] !== v) v = canon[v];
-      canon[i] = v;
-    }
+function attachEdgeMetadata(geometry, mesh, shape) {
+  let edges;
+  try {
+    const carriers = gatherShapeCarriers(getShapeCompilePlan(shape));
+    if (carriers.length === 0) return;
+    edges = buildEdgeClassification(mesh, carriers);
+  } catch {
+    return;
   }
-  return canon;
+  if (edges.length === 0) return;
+  const userData = geometry.userData;
+  userData.forgeEdges = edges.map(toBakedEdge);
 }
 function attachKernelFaceMetadata(geometry, triangleFaceIds, faceIdNames) {
   if (!triangleFaceIds || triangleFaceIds.length === 0 || !faceIdNames || faceIdNames.length === 0) return;
@@ -52134,12 +53381,15 @@ function attachKernelFaceMetadata(geometry, triangleFaceIds, faceIdNames) {
 }
 function shapeToGeometry(shape) {
   if (shape instanceof FrozenShape) {
-    const { positions, normals, edgePositions, triangleFaceIds, faceIdNames, hasSmoothNormals, uvs } = shape.getPrecomputedGeometry();
+    const { positions, normals, edgePositions, triangleFaceIds, faceIdNames, forgeEdges, hasSmoothNormals, uvs } = shape.getPrecomputedGeometry();
     const solid = new BufferGeometry();
     solid.setAttribute("position", new BufferAttribute(positions, 3));
     solid.setAttribute("normal", new BufferAttribute(normals, 3));
     if (uvs) solid.setAttribute("uv", new BufferAttribute(uvs, 2));
     attachKernelFaceMetadata(solid, triangleFaceIds, faceIdNames);
+    if (forgeEdges && forgeEdges.length > 0) {
+      solid.userData.forgeEdges = forgeEdges;
+    }
     const edges = new BufferGeometry();
     edges.setAttribute("position", new BufferAttribute(edgePositions, 3));
     return { solid, edges, hasSmoothNormals };
@@ -52176,6 +53426,7 @@ function shapeToGeometryFallback(shape) {
   solid.setAttribute("normal", new BufferAttribute(normals, 3));
   if (uvs) solid.setAttribute("uv", new BufferAttribute(uvs, 2));
   attachKernelFaceMetadata(solid, mesh.faceID, mesh.faceIdNames);
+  attachEdgeMetadata(solid, mesh, shape);
   const edges = new BufferGeometry();
   edges.setAttribute("position", new BufferAttribute(edgePositions, 3));
   return { solid, edges, hasSmoothNormals };