forgecad 0.9.4 → 0.9.6

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

@@ -542,6 +542,47 @@ function cloneSdfFunctionConstants(constants) {
   if (!constants) return void 0;
   return Object.fromEntries(Object.entries(constants).map(([key, value]) => [key, cloneSdfFunctionConstant(value)]));
 }
+function cloneSdfSurfacePatternNode(pattern) {
+  switch (pattern.kind) {
+    case "surfacePattern:constant":
+      return { kind: "surfacePattern:constant", value: pattern.value };
+    case "surfacePattern:sineWave":
+      return {
+        kind: "surfacePattern:sineWave",
+        direction: [...pattern.direction],
+        wavelength: pattern.wavelength,
+        amplitude: pattern.amplitude,
+        phase: pattern.phase,
+        bias: pattern.bias
+      };
+    case "surfacePattern:stripes":
+      return {
+        kind: "surfacePattern:stripes",
+        direction: [...pattern.direction],
+        spacing: pattern.spacing,
+        width: pattern.width,
+        depth: pattern.depth
+      };
+    case "surfacePattern:overUnderWeave":
+      return {
+        kind: "surfacePattern:overUnderWeave",
+        spacing: [...pattern.spacing],
+        threadWidth: [...pattern.threadWidth],
+        depth: pattern.depth,
+        underScale: pattern.underScale
+      };
+    case "surfacePattern:abs":
+    case "surfacePattern:negate":
+      return { kind: pattern.kind, child: cloneSdfSurfacePatternNode(pattern.child) };
+    case "surfacePattern:add":
+    case "surfacePattern:multiply":
+    case "surfacePattern:min":
+    case "surfacePattern:max":
+      return { kind: pattern.kind, children: pattern.children.map(cloneSdfSurfacePatternNode) };
+    case "surfacePattern:clamp":
+      return { kind: "surfacePattern:clamp", child: cloneSdfSurfacePatternNode(pattern.child), min: pattern.min, max: pattern.max };
+  }
+}
 function cloneSdfNode(node) {
   switch (node.kind) {
     // Primitives — plain value types
@@ -592,6 +633,8 @@ function cloneSdfNode(node) {
       return { kind: "sdf:bend", child: cloneSdfNode(node.child), radius: node.radius };
     case "sdf:repeat":
       return { kind: "sdf:repeat", child: cloneSdfNode(node.child), spacing: [...node.spacing], count: [...node.count] };
+    case "sdf:circularArray":
+      return { kind: "sdf:circularArray", child: cloneSdfNode(node.child), count: node.count, offset: node.offset };
     case "sdf:shell":
       return { kind: "sdf:shell", child: cloneSdfNode(node.child), thickness: node.thickness };
     case "sdf:displace":
@@ -605,6 +648,7 @@ function cloneSdfNode(node) {
       return {
         kind: "sdf:surfaceDisplace",
         child: cloneSdfNode(node.child),
+        ...node.pattern ? { pattern: cloneSdfSurfacePatternNode(node.pattern) } : {},
         patternBody: node.patternBody,
         ...node.constants ? { constants: cloneSdfFunctionConstants(node.constants) } : {},
         ...node.uvMode ? { uvMode: node.uvMode } : {},
@@ -677,7 +721,7 @@ function cloneSdfNode(node) {
   }
 }
 const SHEET_METAL_EDGES = ["top", "right", "bottom", "left"];
-const EPS$c = 1e-9;
+const EPS$d = 1e-9;
 function isFinitePositive$3(value) {
   return Number.isFinite(value) && value > 0;
 }
@@ -718,7 +762,7 @@ function edgeDisplayName(edge) {
   return `sheetMetal().flange("${edge}", ...)`;
 }
 function normalizeAngle(angleDeg) {
-  return Math.abs(angleDeg) <= EPS$c ? 0 : angleDeg;
+  return Math.abs(angleDeg) <= EPS$d ? 0 : angleDeg;
 }
 function validateSheetMetalModel(model) {
   if (!isFinitePositive$3(model.panel.width) || !isFinitePositive$3(model.panel.height)) {
@@ -730,7 +774,7 @@ function validateSheetMetalModel(model) {
   if (!isFiniteNonNegative(model.bendRadius)) {
     return "sheetMetal() requires a finite non-negative bendRadius.";
   }
-  if (model.bendRadius <= EPS$c) {
+  if (model.bendRadius <= EPS$d) {
     return "sheetMetal() v1 requires a positive bendRadius so the bend region stays explicit instead of collapsing into a sharp fold.";
   }
   if (model.bendAllowance.kind !== "k-factor") {
@@ -792,7 +836,7 @@ function deriveSheetMetalModel(model) {
     const trimEnd = flanges.has(adjacent.end) ? model.cornerRelief.size : 0;
     const fullLength = edge === "top" || edge === "bottom" ? model.panel.width : model.panel.height;
     const span = fullLength - trimStart - trimEnd;
-    if (!(span > EPS$c)) {
+    if (!(span > EPS$d)) {
       throw new Error(
         `${edgeDisplayName(edge)} loses all usable span after applying the defended rectangular corner relief size ${model.cornerRelief.size}.`
       );
@@ -850,7 +894,7 @@ function transformPlacement(origin, u2, v, normal) {
   };
 }
 function translatePlan(plan, x2, y2, z2) {
-  if (Math.abs(x2) <= EPS$c && Math.abs(y2) <= EPS$c && Math.abs(z2) <= EPS$c) return cloneShapeCompilePlan(plan);
+  if (Math.abs(x2) <= EPS$d && Math.abs(y2) <= EPS$d && Math.abs(z2) <= EPS$d) return cloneShapeCompilePlan(plan);
   return appendShapeCompileTransform(cloneShapeCompilePlan(plan), {
     kind: "translate",
     x: x2,
@@ -1294,7 +1338,7 @@ function cloneShapeWorkplanePlacement(placement) {
     placement: cloneSketchPlacementModel(placement.placement)
   };
 }
-const EPS$b = 1e-10;
+const EPS$c = 1e-10;
 function subVec3(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
@@ -1320,7 +1364,7 @@ function projectRadial(v, axis) {
 function signedAngleAroundAxis(from, to, axis) {
   const fromLen = lengthVec3$1(from);
   const toLen = lengthVec3$1(to);
-  if (fromLen < EPS$b || toLen < EPS$b) return 0;
+  if (fromLen < EPS$c || toLen < EPS$c) return 0;
   const fn = scaleVec3(from, 1 / fromLen);
   const tn = scaleVec3(to, 1 / toLen);
   const sin2 = dotVec3$4(axis, crossVec3$2(fn, tn));
@@ -1341,19 +1385,19 @@ function solveRotateAroundAngle(axis, pivot, movingPoint, targetPoint, options =
   const targetDecomp = projectRadial(target, unitAxis);
   const movingRadialLen = lengthVec3$1(movingDecomp.radial);
   const targetRadialLen = lengthVec3$1(targetDecomp.radial);
-  if (movingRadialLen < EPS$b) {
-    if (mode === "line" && targetRadialLen >= EPS$b) {
+  if (movingRadialLen < EPS$c) {
+    if (mode === "line" && targetRadialLen >= EPS$c) {
       throw new Error("rotateAroundTo(...): moving point lies on the rotation axis, so line alignment is impossible");
     }
     return 0;
   }
   if (mode === "plane") {
-    if (targetRadialLen < EPS$b) {
+    if (targetRadialLen < EPS$c) {
       throw new Error("rotateAroundTo(...): target point lies on the rotation axis, so the target plane is undefined");
     }
     return signedAngleAroundAxis(movingDecomp.radial, targetDecomp.radial, unitAxis);
   }
-  if (targetRadialLen < EPS$b) {
+  if (targetRadialLen < EPS$c) {
     throw new Error("rotateAroundTo(...): target line lies on the rotation axis, but the moving point does not");
   }
   const axialTol = 1e-8 * Math.max(1, Math.abs(movingDecomp.axial), Math.abs(targetDecomp.axial));
@@ -1393,7 +1437,7 @@ function multiplyMat4(a2, b) {
 }
 function normalizeVec3$5(v) {
   const len2 = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-  if (len2 < EPS$b) throw new Error("Axis must be non-zero");
+  if (len2 < EPS$c) throw new Error("Axis must be non-zero");
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function transformPoint$1(m2, p2, w2) {
@@ -1423,7 +1467,7 @@ function invertMat4(m2) {
   const b10 = a21 * a33 - a23 * a31;
   const b11 = a22 * a33 - a23 * a32;
   const det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
-  if (Math.abs(det) < EPS$b) throw new Error("Transform matrix is not invertible");
+  if (Math.abs(det) < EPS$c) throw new Error("Transform matrix is not invertible");
   const invDet = 1 / det;
   out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * invDet;
   out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * invDet;
@@ -3180,14 +3224,14 @@ function sweepPathToPolylineAdaptive(path2, baseSamples = 48) {
   pts.push(evalPathAt(path2, 1));
   return pts;
 }
-const EPS$a = 1e-8;
+const EPS$b = 1e-8;
 const SUPPORTED_VERTICAL_EDGE_NAMES = ["vert-bl", "vert-br", "vert-tr", "vert-tl"];
 function midpoint$4(start, end) {
   return [(start[0] + end[0]) * 0.5, (start[1] + end[1]) * 0.5, (start[2] + end[2]) * 0.5];
 }
 function normalize$7(v) {
   const len2 = Math.hypot(v[0], v[1], v[2]);
-  if (len2 <= EPS$a) throw new Error("Edge feature selection requires a non-zero direction vector");
+  if (len2 <= EPS$b) throw new Error("Edge feature selection requires a non-zero direction vector");
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function subtract(a2, b) {
@@ -3269,7 +3313,7 @@ function rigidTransformForEdgeStep(step) {
     case "mirror": {
       const [nx0, ny0, nz0] = [step.normalX, step.normalY, step.normalZ];
       const len2 = Math.hypot(nx0, ny0, nz0);
-      if (len2 <= EPS$a) return Transform.identity();
+      if (len2 <= EPS$b) return Transform.identity();
       const nx = nx0 / len2;
       const ny = ny0 / len2;
       const nz = nz0 / len2;
@@ -3580,7 +3624,7 @@ function isRectangleProfile(points) {
     return [next[0] - point2[0], next[1] - point2[1]];
   });
   const lengths2 = vectors.map(([x2, y2]) => Math.hypot(x2, y2));
-  if (lengths2.some((length4) => length4 <= EPS$a)) return false;
+  if (lengths2.some((length4) => length4 <= EPS$b)) return false;
   const dot01 = vectors[0][0] * vectors[1][0] + vectors[0][1] * vectors[1][1];
   const dot12 = vectors[1][0] * vectors[2][0] + vectors[1][1] * vectors[2][1];
   const dot23 = vectors[2][0] * vectors[3][0] + vectors[2][1] * vectors[3][1];
@@ -4646,7 +4690,7 @@ for (var i = 0; i < 32; ++i)
   fdt[i] = 5;
 var flm = /* @__PURE__ */ hMap(flt, 9, 0), flrm = /* @__PURE__ */ hMap(flt, 9, 1);
 var fdm = /* @__PURE__ */ hMap(fdt, 5, 0), fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
-var max$1 = function(a2) {
+var max$2 = function(a2) {
   var m2 = a2[0];
   for (var i = 1; i < a2.length; ++i) {
     if (a2[i] > m2)
@@ -4746,7 +4790,7 @@ var inflt = function(dat, st, buf, dict) {
           clt[clim[i]] = bits(dat, pos + i * 3, 7);
         }
         pos += hcLen * 3;
-        var clb = max$1(clt), clbmsk = (1 << clb) - 1;
+        var clb = max$2(clt), clbmsk = (1 << clb) - 1;
         var clm = hMap(clt, clb, 1);
         for (var i = 0; i < tl; ) {
           var r = clm[bits(dat, pos, clbmsk)];
@@ -4767,8 +4811,8 @@ var inflt = function(dat, st, buf, dict) {
           }
         }
         var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
-        lbt = max$1(lt);
-        dbt = max$1(dt);
+        lbt = max$2(lt);
+        dbt = max$2(dt);
         lm = hMap(lt, lbt, 1);
         dm = hMap(dt, dbt, 1);
       } else
@@ -5621,8 +5665,8 @@ function parse3mf(data) {
     while ((tMatch = trianglePattern.exec(meshXml)) !== null) {
       const v1 = parseInt(tMatch[1], 10) + vertexOffset;
       const v2 = parseInt(tMatch[2], 10) + vertexOffset;
-      const v3 = parseInt(tMatch[3], 10) + vertexOffset;
-      allTriIndices.push(v1, v2, v3);
+      const v32 = parseInt(tMatch[3], 10) + vertexOffset;
+      allTriIndices.push(v1, v2, v32);
     }
     for (let i = 0; i < meshVerts.length; i++) {
       allPositions.push(meshVerts[i]);
@@ -5647,13 +5691,13 @@ function parseMeshFile(data, format) {
       return parse3mf(data);
   }
 }
-const EPS$9 = 1e-8;
+const EPS$a = 1e-8;
 function length$3(v) {
   return Math.hypot(v[0], v[1], v[2]);
 }
 function normalize$6(v) {
   const len2 = length$3(v);
-  if (len2 < EPS$9) throw new Error("Plane normal must be non-zero");
+  if (len2 < EPS$a) throw new Error("Plane normal must be non-zero");
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
 function resolvePlaneOriginNormal(plane) {
@@ -5675,12 +5719,12 @@ function resolvePlaneOriginNormal(plane) {
 function rotationToPlaneSpace(normal) {
   const n = normalize$6(normal);
   const dot2 = n[2];
-  if (dot2 > 1 - EPS$9) {
+  if (dot2 > 1 - EPS$a) {
     return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
   }
   let axis;
   let angle;
-  if (dot2 < -1 + EPS$9) {
+  if (dot2 < -1 + EPS$a) {
     axis = [1, 0, 0];
     angle = Math.PI;
   } else {
@@ -6005,6 +6049,287 @@ function lowerShellShapeCompilePlanToConcretePlan(plan) {
   }
   return lowerBaseShellPlanToConcretePlan(plan.base, plan.thickness, normalizeShellOpenFaces(plan.openFaces));
 }
+const DEFAULT_MAX_GRID_POINTS = 8e6;
+const DEFAULT_MIN_EDGE_LENGTH = 0.15;
+function resolveSdfMeshingSettings(tree, bounds, options = {}) {
+  const quality = options.quality ?? "preview";
+  const minEdgeLength = positiveOrDefault(options.minEdgeLength, DEFAULT_MIN_EDGE_LENGTH);
+  const maxGridPoints = positiveOrDefault(options.maxGridPoints, DEFAULT_MAX_GRID_POINTS);
+  const tolerance = options.tolerance !== void 0 ? requirePositiveFinite$3(options.tolerance, "SDF tolerance") : void 0;
+  const minFeatureSize = options.minFeatureSize !== void 0 ? requirePositiveFinite$3(options.minFeatureSize, "SDF minFeatureSize") : void 0;
+  const maxTriangles = options.maxTriangles !== void 0 ? Math.floor(requirePositiveFinite$3(options.maxTriangles, "SDF maxTriangles")) : void 0;
+  const analysis = analyzeSdfTree(tree);
+  const warnings = [];
+  let edgeLength2;
+  if (options.edgeLength !== void 0) {
+    edgeLength2 = requirePositiveFinite$3(options.edgeLength, "SDF edgeLength");
+    if (edgeLength2 < minEdgeLength) {
+      warnings.push(`edgeLength ${formatMm(edgeLength2)} was clamped to minimum ${formatMm(minEdgeLength)}.`);
+      edgeLength2 = minEdgeLength;
+    }
+  } else {
+    edgeLength2 = resolveDefaultEdgeLength(bounds, quality, minEdgeLength, analysis, options);
+  }
+  if (analysis.minWallThickness < Infinity && analysis.minWallThickness < edgeLength2 * 2) {
+    analysis.riskFlags.add("thin-shell");
+    warnings.push(
+      `shell/wall thickness ${formatMm(analysis.minWallThickness)} is below 2 x edgeLength ${formatMm(edgeLength2)}; thin features may be under-sampled.`
+    );
+  }
+  if (!options.bounds && analysis.hasInfiniteRepeat) {
+    warnings.push("infinite repeat bounds are heuristic; pass .toShape({ bounds }) for predictable clipping.");
+  }
+  if (!options.bounds && analysis.riskFlags.has("noise")) {
+    warnings.push("noise field bounds are heuristic; pass .toShape({ bounds }) for predictable clipping.");
+  }
+  if (!options.bounds && (analysis.riskFlags.has("tpms") || analysis.riskFlags.has("voronoi"))) {
+    warnings.push("TPMS/Voronoi bounds are heuristic unless clipped or passed explicitly.");
+  }
+  if (analysis.hasLegacyTpmsThreshold) {
+    warnings.push("TPMS thickness is using legacy field-threshold units; use wallThickness for approximate millimeters.");
+  }
+  return {
+    quality,
+    edgeLength: edgeLength2,
+    tolerance,
+    minFeatureSize,
+    minEdgeLength,
+    simplify: resolveSimplificationMode(options.simplify, quality, analysis.riskFlags),
+    maxTriangles,
+    maxGridPoints,
+    diagnostics: options.diagnostics === true,
+    treeRiskFlags: [...analysis.riskFlags].sort(),
+    warnings
+  };
+}
+function withScaledSdfEdgeLength(settings, edgeLength2) {
+  return { ...settings, edgeLength: Math.max(settings.minEdgeLength, edgeLength2) };
+}
+function createSdfMeshingDiagnostics(settings, bounds, paddedBounds) {
+  const grid = estimateSdfGridDimensions(paddedBounds, settings.edgeLength);
+  const estimatedSamples = grid[0] * grid[1] * grid[2];
+  return {
+    bounds: cloneBounds$2(bounds),
+    paddedBounds: cloneBounds$2(paddedBounds),
+    edgeLength: settings.edgeLength,
+    grid,
+    estimatedSamples,
+    estimatedMemoryBytes: estimatedSamples * 8,
+    treeRiskFlags: [...settings.treeRiskFlags],
+    simplification: settings.simplify,
+    capMode: "box",
+    capInset: settings.edgeLength,
+    warnings: [...settings.warnings]
+  };
+}
+function assertSdfMeshingBudget(diagnostics, maxGridPoints) {
+  if (diagnostics.estimatedSamples <= maxGridPoints) return;
+  const suggestedEdge = suggestEdgeLengthForSampleBudget(diagnostics.paddedBounds, maxGridPoints);
+  throw new Error(
+    `SDF meshing would sample ${formatCount(diagnostics.estimatedSamples)} grid points (~${formatBytes(
+      diagnostics.estimatedMemoryBytes
+    )}). Reduce bounds or use edgeLength >= ${formatMm(suggestedEdge)}.`
+  );
+}
+function estimateSdfGridDimensions(bounds, edgeLength2) {
+  const dx = bounds.max[0] - bounds.min[0];
+  const dy = bounds.max[1] - bounds.min[1];
+  const dz = bounds.max[2] - bounds.min[2];
+  return [
+    Math.max(2, Math.ceil(dx / edgeLength2) + 1),
+    Math.max(2, Math.ceil(dy / edgeLength2) + 1),
+    Math.max(2, Math.ceil(dz / edgeLength2) + 1)
+  ];
+}
+function logSdfMeshingDiagnostics(prefix, diagnostics) {
+  const warnings = diagnostics.warnings.length > 0 ? `, warnings=${diagnostics.warnings.join(" | ")}` : "";
+  const evaluator = diagnostics.evaluator ? `, evaluator=${diagnostics.evaluator}${diagnostics.evaluatorUnsupportedReason ? ` (${diagnostics.evaluatorUnsupportedReason})` : ""}` : "";
+  console.info(
+    `${prefix}: bounds=${formatBounds(diagnostics.bounds)}, paddedBounds=${formatBounds(diagnostics.paddedBounds)}, edgeLength=${formatMm(diagnostics.edgeLength)}, grid=${diagnostics.grid.join("x")}, estimatedSamples=${formatCount(diagnostics.estimatedSamples)}, treeRisk=${diagnostics.treeRiskFlags.join("+") || "none"}, simplify=${diagnostics.simplification}${evaluator}, capMode=${diagnostics.capMode}, capInset=${formatMm(diagnostics.capInset)}${warnings}`
+  );
+}
+function resolveDefaultEdgeLength(bounds, quality, minEdgeLength, analysis, options) {
+  const dx = bounds.max[0] - bounds.min[0];
+  const dy = bounds.max[1] - bounds.min[1];
+  const dz = bounds.max[2] - bounds.min[2];
+  const maxDim = Math.max(dx, dy, dz, minEdgeLength);
+  const divisor = quality === "draft" ? 60 : quality === "export" ? 160 : 100;
+  const candidates = [maxDim / divisor];
+  if (options.tolerance !== void 0) candidates.push(requirePositiveFinite$3(options.tolerance, "SDF tolerance") * 2);
+  if (options.minFeatureSize !== void 0) candidates.push(requirePositiveFinite$3(options.minFeatureSize, "SDF minFeatureSize") / 2.5);
+  if (analysis.minMetricTpmsThickness < Infinity) candidates.push(analysis.minMetricTpmsThickness / 2);
+  if (analysis.minTpmsCellSize < Infinity) candidates.push(analysis.minTpmsCellSize / 10);
+  if (analysis.minRepeatSpacing < Infinity) candidates.push(analysis.minRepeatSpacing / 8);
+  if (analysis.minWallThickness < Infinity) candidates.push(analysis.minWallThickness / 2.5);
+  return Math.max(minEdgeLength, Math.min(...candidates.filter((v) => Number.isFinite(v) && v > 0)));
+}
+function resolveSimplificationMode(simplify, quality, riskFlags) {
+  if (simplify === false) return "off";
+  if (simplify === true || simplify === "safe") return "safe";
+  if (quality === "export" && riskFlags.size > 0) return "off";
+  return "safe";
+}
+function analyzeSdfTree(tree) {
+  const analysis = {
+    riskFlags: /* @__PURE__ */ new Set(),
+    minTpmsCellSize: Infinity,
+    minMetricTpmsThickness: Infinity,
+    minRepeatSpacing: Infinity,
+    minWallThickness: Infinity,
+    hasInfiniteRepeat: false,
+    hasLegacyTpmsThreshold: false
+  };
+  visitSdfNode(tree, analysis);
+  return analysis;
+}
+function minPositive(...values) {
+  let result = Infinity;
+  for (const value of values) {
+    if (value !== null && value !== void 0 && Number.isFinite(value) && value > 0) {
+      result = Math.min(result, value);
+    }
+  }
+  return result === Infinity ? null : result;
+}
+function estimateSurfacePatternSpacing(pattern) {
+  switch (pattern.kind) {
+    case "surfacePattern:constant":
+      return null;
+    case "surfacePattern:sineWave":
+      return pattern.wavelength;
+    case "surfacePattern:stripes":
+      return Math.min(pattern.spacing, pattern.width);
+    case "surfacePattern:overUnderWeave":
+      return Math.min(...pattern.spacing, ...pattern.threadWidth);
+    case "surfacePattern:abs":
+    case "surfacePattern:negate":
+      return estimateSurfacePatternSpacing(pattern.child);
+    case "surfacePattern:add":
+    case "surfacePattern:multiply":
+    case "surfacePattern:min":
+    case "surfacePattern:max":
+      return minPositive(...pattern.children.map(estimateSurfacePatternSpacing));
+    case "surfacePattern:clamp":
+      return estimateSurfacePatternSpacing(pattern.child);
+  }
+}
+function visitSdfNode(node, analysis) {
+  switch (node.kind) {
+    case "sdf:union":
+    case "sdf:difference":
+    case "sdf:intersection":
+    case "sdf:smoothUnion":
+    case "sdf:smoothDifference":
+    case "sdf:smoothIntersection":
+      for (const child of node.children) visitSdfNode(child, analysis);
+      break;
+    case "sdf:morph":
+    case "sdf:spatialBlend":
+      visitSdfNode(node.a, analysis);
+      visitSdfNode(node.b, analysis);
+      break;
+    case "sdf:translate":
+    case "sdf:rotate":
+    case "sdf:scale":
+    case "sdf:twist":
+    case "sdf:bend":
+    case "sdf:onion":
+      visitSdfNode(node.child, analysis);
+      break;
+    case "sdf:repeat":
+      analysis.riskFlags.add("repeat");
+      for (let i = 0; i < 3; i++) {
+        const spacing = node.spacing[i];
+        if (spacing > 0) {
+          analysis.minRepeatSpacing = Math.min(analysis.minRepeatSpacing, spacing);
+          if (node.count[i] <= 0) analysis.hasInfiniteRepeat = true;
+        }
+      }
+      visitSdfNode(node.child, analysis);
+      break;
+    case "sdf:circularArray": {
+      analysis.riskFlags.add("repeat");
+      if (node.offset > 0) {
+        analysis.minRepeatSpacing = Math.min(analysis.minRepeatSpacing, 2 * Math.PI * node.offset / node.count);
+      }
+      visitSdfNode(node.child, analysis);
+      break;
+    }
+    case "sdf:shell":
+      analysis.minWallThickness = Math.min(analysis.minWallThickness, node.thickness);
+      visitSdfNode(node.child, analysis);
+      break;
+    case "sdf:displace":
+    case "sdf:surfaceDisplace":
+      analysis.riskFlags.add("displacement");
+      if (node.kind === "sdf:surfaceDisplace" && node.pattern) {
+        const spacing = estimateSurfacePatternSpacing(node.pattern);
+        if (spacing !== null) analysis.minRepeatSpacing = Math.min(analysis.minRepeatSpacing, spacing);
+      }
+      visitSdfNode(node.child, analysis);
+      break;
+    case "sdf:gyroid":
+    case "sdf:schwarzP":
+    case "sdf:diamond":
+    case "sdf:lidinoid":
+      analysis.riskFlags.add("tpms");
+      analysis.minTpmsCellSize = Math.min(analysis.minTpmsCellSize, node.cellSize);
+      if (node.thicknessMode === "metric-approx") {
+        analysis.minMetricTpmsThickness = Math.min(analysis.minMetricTpmsThickness, node.thickness);
+        analysis.minWallThickness = Math.min(analysis.minWallThickness, node.thickness);
+      } else {
+        analysis.hasLegacyTpmsThreshold = true;
+      }
+      break;
+    case "sdf:noise":
+      analysis.riskFlags.add("noise");
+      break;
+    case "sdf:voronoi":
+      analysis.riskFlags.add("voronoi");
+      analysis.minWallThickness = Math.min(analysis.minWallThickness, node.wallThickness);
+      if (node.surfaceChild) visitSdfNode(node.surfaceChild, analysis);
+      break;
+    case "sdf:custom":
+      analysis.riskFlags.add("custom");
+      break;
+  }
+}
+function positiveOrDefault(value, fallback) {
+  if (value === void 0) return fallback;
+  return requirePositiveFinite$3(value, "SDF meshing option");
+}
+function requirePositiveFinite$3(value, name) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${name} must be a positive finite number.`);
+  }
+  return value;
+}
+function cloneBounds$2(bounds) {
+  return { min: [...bounds.min], max: [...bounds.max] };
+}
+function suggestEdgeLengthForSampleBudget(bounds, maxGridPoints) {
+  const dx = bounds.max[0] - bounds.min[0];
+  const dy = bounds.max[1] - bounds.min[1];
+  const dz = bounds.max[2] - bounds.min[2];
+  const volume = Math.max(dx * dy * dz, 1);
+  return Math.cbrt(volume / Math.max(maxGridPoints, 8));
+}
+function formatBounds(bounds) {
+  return `[${bounds.min.map(formatNumber).join(",")}]-[${bounds.max.map(formatNumber).join(",")}]`;
+}
+function formatMm(value) {
+  return `${formatNumber(value)}mm`;
+}
+function formatNumber(value) {
+  return Number.isInteger(value) ? String(value) : value.toFixed(3).replace(/0+$/, "").replace(/\.$/, "");
+}
+function formatCount(value) {
+  return Math.round(value).toLocaleString("en-US");
+}
+function formatBytes(bytes) {
+  if (bytes < 1024 * 1024) return `${Math.ceil(bytes / 1024)} KB`;
+  return `${Math.ceil(bytes / (1024 * 1024))} MB`;
+}
 const grad3 = new Float64Array([
   1,
   1,
@@ -6465,8 +6790,8 @@ function triplanarWeights(nx, ny, nz, sharpness) {
   const inv = 1 / sum2;
   return { wx: wx * inv, wy: wy * inv, wz: wz * inv };
 }
-const { atan2, acos, cos: cos$2, sin: sin$2, sqrt: sqrt$2, PI: PI$2 } = Math;
-const DEG$2 = PI$2 / 180;
+const { atan2, acos, cos: cos$3, sin: sin$3, sqrt: sqrt$3, PI: PI$3 } = Math;
+const DEG$3 = PI$3 / 180;
 const IDENTITY = (p2) => p2;
 function analyzeUV(node, override) {
   if (override) {
@@ -6493,10 +6818,10 @@ function analyzeNodeUV(node, toLocal) {
       return analyzeNodeUV(node.child, next);
     }
     case "sdf:rotate": {
-      const [rx, ry, rz] = node.degrees.map((d2) => d2 * DEG$2);
-      const cx = cos$2(rx), sx = sin$2(rx);
-      const cy = cos$2(ry), sy = sin$2(ry);
-      const cz = cos$2(rz), sz = sin$2(rz);
+      const [rx, ry, rz] = node.degrees.map((d2) => d2 * DEG$3);
+      const cx = cos$3(rx), sx = sin$3(rx);
+      const cy = cos$3(ry), sy = sin$3(ry);
+      const cz = cos$3(rz), sz = sin$3(rz);
       const prev = toLocal;
       const next = (p2) => {
         const pp = prev(p2);
@@ -6553,7 +6878,7 @@ function compileUVFunction(analysis) {
       return (p2) => {
         const lp = toLocal(p2);
         const u2 = atan2(lp[1], lp[0]) * R;
-        const len2 = sqrt$2(lp[0] * lp[0] + lp[1] * lp[1] + lp[2] * lp[2]);
+        const len2 = sqrt$3(lp[0] * lp[0] + lp[1] * lp[1] + lp[2] * lp[2]);
         const v = acos(clampUnit(lp[2] / (len2 || 1))) * R;
         return [u2, v];
       };
@@ -6573,23 +6898,23 @@ function compileUVFunction(analysis) {
       return (p2) => {
         const lp = toLocal(p2);
         const u2 = atan2(lp[1], lp[0]) * R;
-        const xyDist = sqrt$2(lp[0] * lp[0] + lp[1] * lp[1]) - R;
+        const xyDist = sqrt$3(lp[0] * lp[0] + lp[1] * lp[1]) - R;
         const v = atan2(lp[2], xyDist) * r;
         return [u2, v];
       };
     }
   }
 }
-const { abs: abs$1, cos: cos$1, sin: sin$1, sqrt: sqrt$1, PI: PI$1 } = Math;
-const TAU = 2 * PI$1;
-const GRAD_EPS = 1e-9;
+const { abs: abs$1, cos: cos$2, sin: sin$2, sqrt: sqrt$2, PI: PI$2 } = Math;
+const TAU$1 = 2 * PI$2;
+const GRAD_EPS$1 = 1e-9;
 function gyroidValueAndGradient(x2, y2, z2, cellSize) {
-  const s = TAU / cellSize;
+  const s = TAU$1 / cellSize;
   const xs = x2 * s;
   const ys = y2 * s;
   const zs = z2 * s;
-  const sx = sin$1(xs), sy = sin$1(ys), sz = sin$1(zs);
-  const cx = cos$1(xs), cy = cos$1(ys), cz = cos$1(zs);
+  const sx = sin$2(xs), sy = sin$2(ys), sz = sin$2(zs);
+  const cx = cos$2(xs), cy = cos$2(ys), cz = cos$2(zs);
   return {
     value: sx * cy + sy * cz + sz * cx,
     gx: s * (cx * cy - sz * sx),
@@ -6598,24 +6923,24 @@ function gyroidValueAndGradient(x2, y2, z2, cellSize) {
   };
 }
 function schwarzPValueAndGradient(x2, y2, z2, cellSize) {
-  const s = TAU / cellSize;
+  const s = TAU$1 / cellSize;
   const xs = x2 * s;
   const ys = y2 * s;
   const zs = z2 * s;
   return {
-    value: cos$1(xs) + cos$1(ys) + cos$1(zs),
-    gx: -s * sin$1(xs),
-    gy: -s * sin$1(ys),
-    gz: -s * sin$1(zs)
+    value: cos$2(xs) + cos$2(ys) + cos$2(zs),
+    gx: -s * sin$2(xs),
+    gy: -s * sin$2(ys),
+    gz: -s * sin$2(zs)
   };
 }
 function diamondValueAndGradient(x2, y2, z2, cellSize) {
-  const s = TAU / cellSize;
+  const s = TAU$1 / cellSize;
   const xs = x2 * s;
   const ys = y2 * s;
   const zs = z2 * s;
-  const sx = sin$1(xs), sy = sin$1(ys), sz = sin$1(zs);
-  const cx = cos$1(xs), cy = cos$1(ys), cz = cos$1(zs);
+  const sx = sin$2(xs), sy = sin$2(ys), sz = sin$2(zs);
+  const cx = cos$2(xs), cy = cos$2(ys), cz = cos$2(zs);
   return {
     value: sx * sy * sz + sx * cy * cz + cx * sy * cz + cx * cy * sz,
     gx: s * (cx * sy * sz + cx * cy * cz - sx * sy * cz - sx * cy * sz),
@@ -6624,12 +6949,12 @@ function diamondValueAndGradient(x2, y2, z2, cellSize) {
   };
 }
 function lidinoidValueAndGradient(x2, y2, z2, cellSize) {
-  const s = TAU / cellSize;
+  const s = TAU$1 / cellSize;
   const sx2 = x2 * s, sy2 = y2 * s, sz2 = z2 * s;
-  const sx = sin$1(sx2), sy = sin$1(sy2), sz = sin$1(sz2);
-  const cx = cos$1(sx2), cy = cos$1(sy2), cz = cos$1(sz2);
-  const s2x = sin$1(2 * sx2), s2y = sin$1(2 * sy2), s2z = sin$1(2 * sz2);
-  const c2x = cos$1(2 * sx2), c2y = cos$1(2 * sy2), c2z = cos$1(2 * sz2);
+  const sx = sin$2(sx2), sy = sin$2(sy2), sz = sin$2(sz2);
+  const cx = cos$2(sx2), cy = cos$2(sy2), cz = cos$2(sz2);
+  const s2x = sin$2(2 * sx2), s2y = sin$2(2 * sy2), s2z = sin$2(2 * sz2);
+  const c2x = cos$2(2 * sx2), c2y = cos$2(2 * sy2), c2z = cos$2(2 * sz2);
   const val = s2x * cy * sz + s2y * cz * sx + s2z * cx * sy - c2x * c2y - c2y * c2z - c2z * c2x + 0.3;
   return {
     value: val,
@@ -6652,8 +6977,8 @@ function lidinoid$1(x2, y2, z2, cellSize, thickness, thicknessMode) {
 }
 function tpmsDistance({ value, gx, gy, gz }, thickness, thicknessMode) {
   if (thicknessMode !== "metric-approx") return abs$1(value) - thickness;
-  const grad = sqrt$1(gx * gx + gy * gy + gz * gz);
-  return abs$1(value) / Math.max(grad, GRAD_EPS) - thickness * 0.5;
+  const grad = sqrt$2(gx * gx + gy * gy + gz * gz);
+  return abs$1(value) / Math.max(grad, GRAD_EPS$1) - thickness * 0.5;
 }
 function mix(h) {
   h = (h ^ h >>> 16) * 2246822507 | 0;
@@ -6749,76 +7074,76 @@ function seededWorley3Surface(seed) {
   const s = seed | 0;
   return (x2, y2, z2, nx, ny, nz, threshold) => worleySurface(x2, y2, z2, s, nx, ny, nz, threshold);
 }
-const { abs, cos, max, min, sin, sqrt, PI } = Math;
-const DEG$1 = PI / 180;
+const { abs, cos: cos$1, max: max$1, min, sin: sin$1, sqrt: sqrt$1, PI: PI$1 } = Math;
+const DEG$2 = PI$1 / 180;
 function clamp$a(v, lo, hi) {
   return v < lo ? lo : v > hi ? hi : v;
 }
-function length2(x2, y2) {
-  return sqrt(x2 * x2 + y2 * y2);
+function length2$1(x2, y2) {
+  return sqrt$1(x2 * x2 + y2 * y2);
 }
-function length3(x2, y2, z2) {
-  return sqrt(x2 * x2 + y2 * y2 + z2 * z2);
+function length3$1(x2, y2, z2) {
+  return sqrt$1(x2 * x2 + y2 * y2 + z2 * z2);
 }
-function sdSphere(px, py, pz, r) {
-  return length3(px, py, pz) - r;
+function sdSphere$1(px, py, pz, r) {
+  return length3$1(px, py, pz) - r;
 }
-function sdBox(px, py, pz, hx, hy, hz) {
+function sdBox$1(px, py, pz, hx, hy, hz) {
   const dx = abs(px) - hx;
   const dy = abs(py) - hy;
   const dz = abs(pz) - hz;
-  return length3(max(dx, 0), max(dy, 0), max(dz, 0)) + min(max(dx, dy, dz), 0);
+  return length3$1(max$1(dx, 0), max$1(dy, 0), max$1(dz, 0)) + min(max$1(dx, dy, dz), 0);
 }
-function sdCylinder(px, py, pz, h, r) {
-  const dx = length2(px, py) - r;
+function sdCylinder$1(px, py, pz, h, r) {
+  const dx = length2$1(px, py) - r;
   const dz = abs(pz) - h * 0.5;
-  return length2(max(dx, 0), max(dz, 0)) + min(max(dx, dz), 0);
+  return length2$1(max$1(dx, 0), max$1(dz, 0)) + min(max$1(dx, dz), 0);
 }
-function sdTorus(px, py, pz, R, r) {
-  const qx = length2(px, py) - R;
-  return length2(qx, pz) - r;
+function sdTorus$1(px, py, pz, R, r) {
+  const qx = length2$1(px, py) - R;
+  return length2$1(qx, pz) - r;
 }
-function sdCapsule(px, py, pz, h, r) {
+function sdCapsule$1(px, py, pz, h, r) {
   const halfH = h * 0.5;
   const cz = clamp$a(pz, -halfH, halfH);
-  return length3(px, py, pz - cz) - r;
+  return length3$1(px, py, pz - cz) - r;
 }
-function sdCone(px, py, pz, h, r) {
-  const q = length2(px, py);
-  const cLen = length2(h, r);
+function sdCone$1(px, py, pz, h, r) {
+  const q = length2$1(px, py);
+  const cLen = length2$1(h, r);
   const nx = h / cLen;
   const nz = -r / cLen;
-  const d2 = max(nx * q + nz * (pz - h), -pz, pz - h);
+  const d2 = max$1(nx * q + nz * (pz - h), -pz, pz - h);
   return d2;
 }
-function sdTaperedSegment(px, py, pz, ax, ay, az, bx, by, bz, ra, rb) {
+function sdTaperedSegment$1(px, py, pz, ax, ay, az, bx, by, bz, ra, rb) {
   const vx = bx - ax;
   const vy = by - ay;
   const vz = bz - az;
   const len2 = vx * vx + vy * vy + vz * vz;
-  if (len2 <= 1e-12) return sdSphere(px - ax, py - ay, pz - az, max(ra, rb));
+  if (len2 <= 1e-12) return sdSphere$1(px - ax, py - ay, pz - az, max$1(ra, rb));
   const h = clamp$a(((px - ax) * vx + (py - ay) * vy + (pz - az) * vz) / len2, 0, 1);
-  return length3(px - (ax + vx * h), py - (ay + vy * h), pz - (az + vz * h)) - (ra + (rb - ra) * h);
+  return length3$1(px - (ax + vx * h), py - (ay + vy * h), pz - (az + vz * h)) - (ra + (rb - ra) * h);
 }
 function sdPolylineSweep3(node, x2, y2, z2) {
   let d2 = 1e20;
   for (let i = 0; i < node.points.length - 1; i++) {
     const a2 = node.points[i];
     const b = node.points[i + 1];
-    const segment = sdTaperedSegment(x2, y2, z2, a2[0], a2[1], a2[2], b[0], b[1], b[2], node.radii[i], node.radii[i + 1]);
-    d2 = i === 0 ? segment : smin(d2, segment, node.blend);
+    const segment = sdTaperedSegment$1(x2, y2, z2, a2[0], a2[1], a2[2], b[0], b[1], b[2], node.radii[i], node.radii[i + 1]);
+    d2 = i === 0 ? segment : smin$1(d2, segment, node.blend);
   }
   return d2;
 }
-function smin(a2, b, k2) {
+function smin$1(a2, b, k2) {
   if (k2 <= 0) return min(a2, b);
-  const h = max(k2 - abs(a2 - b), 0) / k2;
+  const h = max$1(k2 - abs(a2 - b), 0) / k2;
   return min(a2, b) - h * h * h * k2 * (1 / 6);
 }
-function smax(a2, b, k2) {
-  return -smin(-a2, -b, k2);
+function smax$1(a2, b, k2) {
+  return -smin$1(-a2, -b, k2);
 }
-function repeatCoord(v, spacing, count) {
+function repeatCoord$1(v, spacing, count) {
   if (spacing <= 0) return v;
   if (count > 0) {
     const center = (count - 1) * 0.5;
@@ -6827,31 +7152,138 @@ function repeatCoord(v, spacing, count) {
   }
   return v - spacing * Math.round(v / spacing);
 }
+function positiveMod(v, period) {
+  return (v % period + period) % period;
+}
+function evalStripesPattern(u2, v, directionX, directionY, spacing, width, depth) {
+  const coord = u2 * directionX + v * directionY;
+  const d2 = abs(coord - Math.round(coord / spacing) * spacing);
+  const profile = max$1(0, 1 - d2 / (width * 0.5));
+  return -(profile * profile) * depth;
+}
+function evalOverUnderWeavePattern(u2, v, spacingX, spacingY, widthX, widthY, depth, underScale) {
+  const su = u2 / spacingX;
+  const sv = v / spacingY;
+  let pU = max$1(0, 1 - abs(su - Math.round(su)) * spacingX / (widthX * 0.5));
+  let pV = max$1(0, 1 - abs(sv - Math.round(sv)) * spacingY / (widthY * 0.5));
+  pU *= pU;
+  pV *= pV;
+  const checker = (Math.round(su) & 65535) + (Math.round(sv) & 65535) & 1;
+  const top = checker ? pV : pU;
+  const bot = checker ? pU : pV;
+  return -max$1(top, bot * underScale) * depth;
+}
+function compileTypedSurfacePattern(pattern) {
+  switch (pattern.kind) {
+    case "surfacePattern:constant":
+      return () => pattern.value;
+    case "surfacePattern:sineWave": {
+      const { direction: direction2, wavelength, amplitude, phase, bias } = pattern;
+      const frequency = 2 * PI$1 / wavelength;
+      return (u2, v) => bias + sin$1((u2 * direction2[0] + v * direction2[1]) * frequency + phase) * amplitude;
+    }
+    case "surfacePattern:stripes": {
+      const { direction: direction2, spacing, width, depth } = pattern;
+      return (u2, v) => evalStripesPattern(u2, v, direction2[0], direction2[1], spacing, width, depth);
+    }
+    case "surfacePattern:overUnderWeave": {
+      const { spacing, threadWidth, depth, underScale } = pattern;
+      return (u2, v) => evalOverUnderWeavePattern(u2, v, spacing[0], spacing[1], threadWidth[0], threadWidth[1], depth, underScale);
+    }
+    case "surfacePattern:abs": {
+      const child = compileTypedSurfacePattern(pattern.child);
+      return (u2, v) => abs(child(u2, v));
+    }
+    case "surfacePattern:negate": {
+      const child = compileTypedSurfacePattern(pattern.child);
+      return (u2, v) => -child(u2, v);
+    }
+    case "surfacePattern:add": {
+      const children = pattern.children.map(compileTypedSurfacePattern);
+      return (u2, v) => children.reduce((sum2, child) => sum2 + child(u2, v), 0);
+    }
+    case "surfacePattern:multiply": {
+      const children = pattern.children.map(compileTypedSurfacePattern);
+      return (u2, v) => children.reduce((product, child) => product * child(u2, v), 1);
+    }
+    case "surfacePattern:min": {
+      const children = pattern.children.map(compileTypedSurfacePattern);
+      if (children.length === 0) return () => 0;
+      return (u2, v) => children.reduce((value, child) => min(value, child(u2, v)), Infinity);
+    }
+    case "surfacePattern:max": {
+      const children = pattern.children.map(compileTypedSurfacePattern);
+      if (children.length === 0) return () => 0;
+      return (u2, v) => children.reduce((value, child) => max$1(value, child(u2, v)), -Infinity);
+    }
+    case "surfacePattern:clamp": {
+      const child = compileTypedSurfacePattern(pattern.child);
+      return (u2, v) => clamp$a(child(u2, v), pattern.min, pattern.max);
+    }
+  }
+}
+function estimateSurfacePatternAmplitude(pattern) {
+  switch (pattern.kind) {
+    case "surfacePattern:constant":
+      return abs(pattern.value);
+    case "surfacePattern:sineWave":
+      return abs(pattern.bias) + abs(pattern.amplitude);
+    case "surfacePattern:stripes":
+    case "surfacePattern:overUnderWeave":
+      return pattern.depth;
+    case "surfacePattern:abs":
+    case "surfacePattern:negate":
+      return estimateSurfacePatternAmplitude(pattern.child);
+    case "surfacePattern:add": {
+      const amplitudes = pattern.children.map(estimateSurfacePatternAmplitude);
+      return amplitudes.every((value) => value !== null) ? amplitudes.reduce((sum2, value) => sum2 + value, 0) : null;
+    }
+    case "surfacePattern:multiply": {
+      const amplitudes = pattern.children.map(estimateSurfacePatternAmplitude);
+      return amplitudes.every((value) => value !== null) ? amplitudes.reduce((product, value) => product * value, 1) : null;
+    }
+    case "surfacePattern:min":
+    case "surfacePattern:max": {
+      const amplitudes = pattern.children.map(estimateSurfacePatternAmplitude);
+      return amplitudes.every((value) => value !== null) ? max$1(...amplitudes) : null;
+    }
+    case "surfacePattern:clamp":
+      return max$1(abs(pattern.min), abs(pattern.max));
+  }
+}
+function compileSurfacePattern(node) {
+  if (node.pattern) return compileTypedSurfacePattern(node.pattern);
+  const constEntries = Object.entries(node.constants ?? {});
+  const constNames = constEntries.map(([k2]) => k2);
+  const constValues = constEntries.map(([, v]) => v);
+  const patternFn = new Function("u", "v", ...constNames, `return (${node.patternBody});`);
+  return (u2, v) => patternFn(u2, v, ...constValues);
+}
 function compileSdfNode3(node) {
   switch (node.kind) {
     case "sdf:sphere": {
       const r = node.radius;
-      return (x2, y2, z2) => sdSphere(x2, y2, z2, r);
+      return (x2, y2, z2) => sdSphere$1(x2, y2, z2, r);
     }
     case "sdf:box": {
       const [hx, hy, hz] = node.halfExtents;
-      return (x2, y2, z2) => sdBox(x2, y2, z2, hx, hy, hz);
+      return (x2, y2, z2) => sdBox$1(x2, y2, z2, hx, hy, hz);
     }
     case "sdf:cylinder": {
       const { height: h, radius: r } = node;
-      return (x2, y2, z2) => sdCylinder(x2, y2, z2, h, r);
+      return (x2, y2, z2) => sdCylinder$1(x2, y2, z2, h, r);
     }
     case "sdf:torus": {
       const { majorRadius: R, minorRadius: r } = node;
-      return (x2, y2, z2) => sdTorus(x2, y2, z2, R, r);
+      return (x2, y2, z2) => sdTorus$1(x2, y2, z2, R, r);
     }
     case "sdf:capsule": {
       const { height: h, radius: r } = node;
-      return (x2, y2, z2) => sdCapsule(x2, y2, z2, h, r);
+      return (x2, y2, z2) => sdCapsule$1(x2, y2, z2, h, r);
     }
     case "sdf:cone": {
       const { height: h, radius: r } = node;
-      return (x2, y2, z2) => sdCone(x2, y2, z2, h, r);
+      return (x2, y2, z2) => sdCone$1(x2, y2, z2, h, r);
     }
     case "sdf:polylineSweep": {
       return (x2, y2, z2) => sdPolylineSweep3(node, x2, y2, z2);
@@ -6868,7 +7300,7 @@ function compileSdfNode3(node) {
       const fns = node.children.map(compileSdfNode3);
       return (x2, y2, z2) => {
         let d2 = fns[0](x2, y2, z2);
-        for (let i = 1; i < fns.length; i++) d2 = max(d2, -fns[i](x2, y2, z2));
+        for (let i = 1; i < fns.length; i++) d2 = max$1(d2, -fns[i](x2, y2, z2));
         return d2;
       };
     }
@@ -6876,7 +7308,7 @@ function compileSdfNode3(node) {
       const fns = node.children.map(compileSdfNode3);
       return (x2, y2, z2) => {
         let d2 = fns[0](x2, y2, z2);
-        for (let i = 1; i < fns.length; i++) d2 = max(d2, fns[i](x2, y2, z2));
+        for (let i = 1; i < fns.length; i++) d2 = max$1(d2, fns[i](x2, y2, z2));
         return d2;
       };
     }
@@ -6885,7 +7317,7 @@ function compileSdfNode3(node) {
       const k2 = node.radius;
       return (x2, y2, z2) => {
         let d2 = fns[0](x2, y2, z2);
-        for (let i = 1; i < fns.length; i++) d2 = smin(d2, fns[i](x2, y2, z2), k2);
+        for (let i = 1; i < fns.length; i++) d2 = smin$1(d2, fns[i](x2, y2, z2), k2);
         return d2;
       };
     }
@@ -6894,7 +7326,7 @@ function compileSdfNode3(node) {
       const k2 = node.radius;
       return (x2, y2, z2) => {
         let d2 = fns[0](x2, y2, z2);
-        for (let i = 1; i < fns.length; i++) d2 = smax(d2, -fns[i](x2, y2, z2), k2);
+        for (let i = 1; i < fns.length; i++) d2 = smax$1(d2, -fns[i](x2, y2, z2), k2);
         return d2;
       };
     }
@@ -6903,7 +7335,7 @@ function compileSdfNode3(node) {
       const k2 = node.radius;
       return (x2, y2, z2) => {
         let d2 = fns[0](x2, y2, z2);
-        for (let i = 1; i < fns.length; i++) d2 = smax(d2, fns[i](x2, y2, z2), k2);
+        for (let i = 1; i < fns.length; i++) d2 = smax$1(d2, fns[i](x2, y2, z2), k2);
         return d2;
       };
     }
@@ -6921,10 +7353,10 @@ function compileSdfNode3(node) {
     }
     case "sdf:rotate": {
       const fn = compileSdfNode3(node.child);
-      const [rx, ry, rz] = node.degrees.map((d2) => d2 * DEG$1);
-      const cx = cos(rx), sx = sin(rx);
-      const cy = cos(ry), sy = sin(ry);
-      const cz = cos(rz), sz = sin(rz);
+      const [rx, ry, rz] = node.degrees.map((d2) => d2 * DEG$2);
+      const cx = cos$1(rx), sx = sin$1(rx);
+      const cy = cos$1(ry), sy = sin$1(ry);
+      const cz = cos$1(rz), sz = sin$1(rz);
       return (x2, y2, z2) => {
         const x1 = cz * x2 + sz * y2;
         const y1 = -sz * x2 + cz * y2;
@@ -6943,10 +7375,10 @@ function compileSdfNode3(node) {
     }
     case "sdf:twist": {
       const fn = compileSdfNode3(node.child);
-      const k2 = node.degreesPerUnit * DEG$1;
+      const k2 = node.degreesPerUnit * DEG$2;
       return (x2, y2, z2) => {
         const angle = k2 * z2;
-        const c2 = cos(angle), s = sin(angle);
+        const c2 = cos$1(angle), s = sin$1(angle);
         return fn(c2 * x2 - s * y2, s * x2 + c2 * y2, z2);
       };
     }
@@ -6955,7 +7387,7 @@ function compileSdfNode3(node) {
       const r = node.radius;
       return (x2, y2, z2) => {
         const angle = x2 / r;
-        const c2 = cos(angle), s = sin(angle);
+        const c2 = cos$1(angle), s = sin$1(angle);
         return fn((r + y2) * s, (r + y2) * c2 - r, z2);
       };
     }
@@ -6963,7 +7395,19 @@ function compileSdfNode3(node) {
       const fn = compileSdfNode3(node.child);
       const [sx, sy, sz] = node.spacing;
       const [cx, cy, cz] = node.count;
-      return (x2, y2, z2) => fn(repeatCoord(x2, sx, cx), repeatCoord(y2, sy, cy), repeatCoord(z2, sz, cz));
+      return (x2, y2, z2) => fn(repeatCoord$1(x2, sx, cx), repeatCoord$1(y2, sy, cy), repeatCoord$1(z2, sz, cz));
+    }
+    case "sdf:circularArray": {
+      const fn = compileSdfNode3(node.child);
+      const da = 2 * PI$1 / node.count;
+      const offset2 = node.offset;
+      return (x2, y2, z2) => {
+        const r = length2$1(x2, y2);
+        const a2 = positiveMod(Math.atan2(y2, x2), da);
+        const d1 = fn(cos$1(a2 - da) * r - offset2, sin$1(a2 - da) * r, z2);
+        const d2 = fn(cos$1(a2) * r - offset2, sin$1(a2) * r, z2);
+        return min(d1, d2);
+      };
     }
     case "sdf:shell": {
       const fn = compileSdfNode3(node.child);
@@ -6980,10 +7424,7 @@ function compileSdfNode3(node) {
     }
     case "sdf:surfaceDisplace": {
       const childFn = compileSdfNode3(node.child);
-      const constEntries = Object.entries(node.constants ?? {});
-      const constNames = constEntries.map(([k2]) => k2);
-      const constValues = constEntries.map(([, v]) => v);
-      const patternFn = new Function("u", "v", ...constNames, `return (${node.patternBody});`);
+      const patternFn = compileSurfacePattern(node);
       const uvMode = node.uvMode && node.uvMode !== "auto" ? node.uvMode : void 0;
       const analysis = analyzeUV(node.child, uvMode);
       const uvFn = compileUVFunction(analysis);
@@ -6995,7 +7436,7 @@ function compileSdfNode3(node) {
           p2[1] = y2;
           p2[2] = z2;
           const [u2, v] = uvFn(p2);
-          return d2 + patternFn(u2, v, ...constValues);
+          return d2 + patternFn(u2, v);
         };
       }
       const sharpness = node.triplanarSharpness ?? 4;
@@ -7006,9 +7447,9 @@ function compileSdfNode3(node) {
         const gy = childFn(x2, y2 + eps, z2) - childFn(x2, y2 - eps, z2);
         const gz = childFn(x2, y2, z2 + eps) - childFn(x2, y2, z2 - eps);
         const { wx, wy, wz } = triplanarWeights(gx, gy, gz, sharpness);
-        const hX = patternFn(y2, z2, ...constValues);
-        const hY = patternFn(x2, z2, ...constValues);
-        const hZ = patternFn(x2, y2, ...constValues);
+        const hX = patternFn(y2, z2);
+        const hY = patternFn(x2, z2);
+        const hZ = patternFn(x2, y2);
         return d2 + wx * hX + wy * hY + wz * hZ;
       };
     }
@@ -7078,7 +7519,7 @@ function compileSdfNode3(node) {
           const gx = gradFn(x2 + eps, y2, z2) - gradFn(x2 - eps, y2, z2);
           const gy = gradFn(x2, y2 + eps, z2) - gradFn(x2, y2 - eps, z2);
           const gz = gradFn(x2, y2, z2 + eps) - gradFn(x2, y2, z2 - eps);
-          const glen = sqrt(gx * gx + gy * gy + gz * gz);
+          const glen = sqrt$1(gx * gx + gy * gy + gz * gz);
           let nx = 0, ny = 0, nz = 0;
           if (glen > 1e-10) {
             const invG = 1 / glen;
@@ -7140,7 +7581,7 @@ function estimateSdfBounds(node) {
       for (const point2 of node.points) {
         for (let i = 0; i < 3; i++) {
           minPoint[i] = min(minPoint[i], point2[i]);
-          maxPoint[i] = max(maxPoint[i], point2[i]);
+          maxPoint[i] = max$1(maxPoint[i], point2[i]);
         }
       }
       return padBounds({ min: minPoint, max: maxPoint }, pad);
@@ -7171,7 +7612,7 @@ function estimateSdfBounds(node) {
     }
     case "sdf:rotate": {
       const b = estimateSdfBounds(node.child);
-      const r = length3(max(abs(b.min[0]), abs(b.max[0])), max(abs(b.min[1]), abs(b.max[1])), max(abs(b.min[2]), abs(b.max[2])));
+      const r = length3$1(max$1(abs(b.min[0]), abs(b.max[0])), max$1(abs(b.min[1]), abs(b.max[1])), max$1(abs(b.min[2]), abs(b.max[2])));
       return { min: [-r, -r, -r], max: [r, r, r] };
     }
     case "sdf:scale": {
@@ -7185,7 +7626,7 @@ function estimateSdfBounds(node) {
     case "sdf:twist":
     case "sdf:bend": {
       const b = estimateSdfBounds(node.child);
-      const r = length3(max(abs(b.min[0]), abs(b.max[0])), max(abs(b.min[1]), abs(b.max[1])), max(abs(b.min[2]), abs(b.max[2]))) * 1.5;
+      const r = length3$1(max$1(abs(b.min[0]), abs(b.max[0])), max$1(abs(b.min[1]), abs(b.max[1])), max$1(abs(b.min[2]), abs(b.max[2]))) * 1.5;
       return { min: [-r, -r, -r], max: [r, r, r] };
     }
     case "sdf:repeat": {
@@ -7206,16 +7647,29 @@ function estimateSdfBounds(node) {
       const [zMin, zMax] = expand(sz, cz, b.min[2], b.max[2]);
       return { min: [xMin, yMin, zMin], max: [xMax, yMax, zMax] };
     }
+    case "sdf:circularArray": {
+      const b = estimateSdfBounds(node.child);
+      const x0 = b.min[0] + node.offset;
+      const x1 = b.max[0] + node.offset;
+      const y0 = b.min[1];
+      const y1 = b.max[1];
+      const r = max$1(length2$1(x0, y0), length2$1(x0, y1), length2$1(x1, y0), length2$1(x1, y1));
+      return { min: [-r, -r, b.min[2]], max: [r, r, b.max[2]] };
+    }
     case "sdf:shell": {
       const b = estimateSdfBounds(node.child);
       const t = node.thickness * 0.5;
       return padBounds(b, t);
     }
-    case "sdf:displace":
-    case "sdf:surfaceDisplace": {
+    case "sdf:displace": {
       const b = estimateSdfBounds(node.child);
       return padBounds(b, 5);
     }
+    case "sdf:surfaceDisplace": {
+      const b = estimateSdfBounds(node.child);
+      if (!node.pattern) return padBounds(b, 5);
+      return padBounds(b, estimateSurfacePatternAmplitude(node.pattern) ?? 5);
+    }
     case "sdf:onion": {
       const b = estimateSdfBounds(node.child);
       return padBounds(b, node.layers * node.thickness);
@@ -7252,7 +7706,7 @@ function unionBounds(bounds, pad) {
   for (const b of bounds) {
     for (let i = 0; i < 3; i++) {
       result.min[i] = min(result.min[i], b.min[i]);
-      result.max[i] = max(result.max[i], b.max[i]);
+      result.max[i] = max$1(result.max[i], b.max[i]);
     }
   }
   if (pad > 0) return padBounds(result, pad);
@@ -7265,7 +7719,7 @@ function intersectBounds(bounds, pad) {
   };
   for (const b of bounds) {
     for (let i = 0; i < 3; i++) {
-      result.min[i] = max(result.min[i], b.min[i]);
+      result.min[i] = max$1(result.min[i], b.min[i]);
       result.max[i] = min(result.max[i], b.max[i]);
     }
   }
@@ -7281,242 +7735,544 @@ function padBounds(b, pad) {
     max: [b.max[0] + pad, b.max[1] + pad, b.max[2] + pad]
   };
 }
-const DEFAULT_MAX_GRID_POINTS = 8e6;
-const DEFAULT_MIN_EDGE_LENGTH = 0.15;
-function resolveSdfMeshingSettings(tree, bounds, options = {}) {
-  const quality = options.quality ?? "preview";
-  const minEdgeLength = positiveOrDefault(options.minEdgeLength, DEFAULT_MIN_EDGE_LENGTH);
-  const maxGridPoints = positiveOrDefault(options.maxGridPoints, DEFAULT_MAX_GRID_POINTS);
-  const tolerance = options.tolerance !== void 0 ? requirePositiveFinite$2(options.tolerance, "SDF tolerance") : void 0;
-  const minFeatureSize = options.minFeatureSize !== void 0 ? requirePositiveFinite$2(options.minFeatureSize, "SDF minFeatureSize") : void 0;
-  const maxTriangles = options.maxTriangles !== void 0 ? Math.floor(requirePositiveFinite$2(options.maxTriangles, "SDF maxTriangles")) : void 0;
-  const analysis = analyzeSdfTree(tree);
-  const warnings = [];
-  let edgeLength2;
-  if (options.edgeLength !== void 0) {
-    edgeLength2 = requirePositiveFinite$2(options.edgeLength, "SDF edgeLength");
-    if (edgeLength2 < minEdgeLength) {
-      warnings.push(`edgeLength ${formatMm(edgeLength2)} was clamped to minimum ${formatMm(minEdgeLength)}.`);
-      edgeLength2 = minEdgeLength;
-    }
-  } else {
-    edgeLength2 = resolveDefaultEdgeLength(bounds, quality, minEdgeLength, analysis, options);
+const { PI } = Math;
+const DEG$1 = PI / 180;
+const TAU = 2 * PI;
+const GRAD_EPS = 1e-9;
+const Op = {
+  Const: 0,
+  Neg: 1,
+  Abs: 2,
+  Sqrt: 3,
+  Sin: 4,
+  Cos: 5,
+  Round: 6,
+  Add: 7,
+  Sub: 8,
+  Mul: 9,
+  Div: 10,
+  Min: 11,
+  Max: 12
+};
+class UnsupportedSdfProgramNodeError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnsupportedSdfProgramNodeError";
   }
-  if (analysis.minWallThickness < Infinity && analysis.minWallThickness < edgeLength2 * 2) {
-    analysis.riskFlags.add("thin-shell");
-    warnings.push(
-      `shell/wall thickness ${formatMm(analysis.minWallThickness)} is below 2 x edgeLength ${formatMm(edgeLength2)}; thin features may be under-sampled.`
-    );
+}
+class SdfProgramBuilder {
+  constructor() {
+    __publicField(this, "opcodes", []);
+    __publicField(this, "argA", []);
+    __publicField(this, "argB", []);
+    __publicField(this, "argC", []);
+    __publicField(this, "constants", []);
+    __publicField(this, "x", 0);
+    __publicField(this, "y", 1);
+    __publicField(this, "z", 2);
   }
-  if (!options.bounds && analysis.hasInfiniteRepeat) {
-    warnings.push("infinite repeat bounds are heuristic; pass .toShape({ bounds }) for predictable clipping.");
+  constant(value) {
+    const index2 = this.constants.length;
+    this.constants.push(value);
+    return this.push(Op.Const, 0, 0, index2);
   }
-  if (!options.bounds && analysis.riskFlags.has("noise")) {
-    warnings.push("noise field bounds are heuristic; pass .toShape({ bounds }) for predictable clipping.");
+  neg(a2) {
+    return this.push(Op.Neg, a2);
   }
-  if (!options.bounds && (analysis.riskFlags.has("tpms") || analysis.riskFlags.has("voronoi"))) {
-    warnings.push("TPMS/Voronoi bounds are heuristic unless clipped or passed explicitly.");
+  abs(a2) {
+    return this.push(Op.Abs, a2);
   }
-  if (analysis.hasLegacyTpmsThreshold) {
-    warnings.push("TPMS thickness is using legacy field-threshold units; use wallThickness for approximate millimeters.");
+  sqrt(a2) {
+    return this.push(Op.Sqrt, a2);
+  }
+  sin(a2) {
+    return this.push(Op.Sin, a2);
+  }
+  cos(a2) {
+    return this.push(Op.Cos, a2);
+  }
+  round(a2) {
+    return this.push(Op.Round, a2);
+  }
+  add(a2, b) {
+    return this.push(Op.Add, a2, b);
+  }
+  sub(a2, b) {
+    return this.push(Op.Sub, a2, b);
+  }
+  mul(a2, b) {
+    return this.push(Op.Mul, a2, b);
+  }
+  div(a2, b) {
+    return this.push(Op.Div, a2, b);
+  }
+  min(a2, b) {
+    return this.push(Op.Min, a2, b);
+  }
+  max(a2, b) {
+    return this.push(Op.Max, a2, b);
+  }
+  finalize(output) {
+    return {
+      opcodes: Uint8Array.from(this.opcodes),
+      argA: Int32Array.from(this.argA),
+      argB: Int32Array.from(this.argB),
+      argC: Int32Array.from(this.argC),
+      constants: Float64Array.from(this.constants),
+      output,
+      slotCount: this.opcodes.length + 3
+    };
+  }
+  push(op, a2 = 0, b = 0, c2 = 0) {
+    const slot2 = this.opcodes.length + 3;
+    this.opcodes.push(op);
+    this.argA.push(a2);
+    this.argB.push(b);
+    this.argC.push(c2);
+    return slot2;
+  }
+}
+function compileSdfProgramEvaluator3(program) {
+  const lines = ["const { abs, sqrt, sin, cos, round, min, max } = Math;", "let v0 = x;", "let v1 = y;", "let v2 = z;"];
+  const { opcodes, argA, argB, argC, constants, output } = program;
+  for (let i = 0; i < opcodes.length; i++) {
+    const slot2 = `v${i + 3}`;
+    const a2 = `v${argA[i]}`;
+    const b = `v${argB[i]}`;
+    switch (opcodes[i]) {
+      case Op.Const:
+        lines.push(`let ${slot2} = ${numberLiteral(constants[argC[i]])};`);
+        break;
+      case Op.Neg:
+        lines.push(`let ${slot2} = -${a2};`);
+        break;
+      case Op.Abs:
+        lines.push(`let ${slot2} = abs(${a2});`);
+        break;
+      case Op.Sqrt:
+        lines.push(`let ${slot2} = sqrt(${a2});`);
+        break;
+      case Op.Sin:
+        lines.push(`let ${slot2} = sin(${a2});`);
+        break;
+      case Op.Cos:
+        lines.push(`let ${slot2} = cos(${a2});`);
+        break;
+      case Op.Round:
+        lines.push(`let ${slot2} = round(${a2});`);
+        break;
+      case Op.Add:
+        lines.push(`let ${slot2} = ${a2} + ${b};`);
+        break;
+      case Op.Sub:
+        lines.push(`let ${slot2} = ${a2} - ${b};`);
+        break;
+      case Op.Mul:
+        lines.push(`let ${slot2} = ${a2} * ${b};`);
+        break;
+      case Op.Div:
+        lines.push(`let ${slot2} = ${a2} / ${b};`);
+        break;
+      case Op.Min:
+        lines.push(`let ${slot2} = min(${a2}, ${b});`);
+        break;
+      case Op.Max:
+        lines.push(`let ${slot2} = max(${a2}, ${b});`);
+        break;
+      default:
+        throw new Error(`Unknown SdfProgram opcode ${opcodes[i]} at instruction ${i}.`);
+    }
   }
+  lines.push(`return v${output};`);
+  return new Function("Math", `return function sdfProgramEval(x, y, z) {
+${lines.join("\n")}
+};`)(Math);
+}
+function numberLiteral(value) {
+  if (Number.isNaN(value)) return "NaN";
+  if (value === Number.POSITIVE_INFINITY) return "Infinity";
+  if (value === Number.NEGATIVE_INFINITY) return "-Infinity";
+  return String(value);
+}
+function clampSlot(b, v, lo, hi) {
+  return b.min(b.max(v, b.constant(lo)), b.constant(hi));
+}
+function length2(b, x2, y2) {
+  return b.sqrt(b.add(b.mul(x2, x2), b.mul(y2, y2)));
+}
+function length3(b, x2, y2, z2) {
+  return b.sqrt(b.add(b.add(b.mul(x2, x2), b.mul(y2, y2)), b.mul(z2, z2)));
+}
+function smin(b, a2, child, k2) {
+  if (k2 <= 0) return b.min(a2, child);
+  const h = b.div(b.max(b.sub(b.constant(k2), b.abs(b.sub(a2, child))), b.constant(0)), b.constant(k2));
+  return b.sub(b.min(a2, child), b.mul(b.mul(b.mul(h, h), h), b.constant(k2 / 6)));
+}
+function smax(b, a2, child, k2) {
+  return b.neg(smin(b, b.neg(a2), b.neg(child), k2));
+}
+function emitScaledTrig(b, x2, y2, z2, cellSize) {
+  const s = b.constant(TAU / cellSize);
+  const xs = b.mul(x2, s);
+  const ys = b.mul(y2, s);
+  const zs = b.mul(z2, s);
   return {
-    quality,
-    edgeLength: edgeLength2,
-    tolerance,
-    minFeatureSize,
-    minEdgeLength,
-    simplify: resolveSimplificationMode(options.simplify, quality, analysis.riskFlags),
-    maxTriangles,
-    maxGridPoints,
-    diagnostics: options.diagnostics === true,
-    treeRiskFlags: [...analysis.riskFlags].sort(),
-    warnings
+    scale: s,
+    sx: b.sin(xs),
+    sy: b.sin(ys),
+    sz: b.sin(zs),
+    cx: b.cos(xs),
+    cy: b.cos(ys),
+    cz: b.cos(zs),
+    sx2: b.sin(b.mul(b.constant(2), xs)),
+    sy2: b.sin(b.mul(b.constant(2), ys)),
+    sz2: b.sin(b.mul(b.constant(2), zs)),
+    cx2: b.cos(b.mul(b.constant(2), xs)),
+    cy2: b.cos(b.mul(b.constant(2), ys)),
+    cz2: b.cos(b.mul(b.constant(2), zs))
   };
 }
-function withScaledSdfEdgeLength(settings, edgeLength2) {
-  return { ...settings, edgeLength: Math.max(settings.minEdgeLength, edgeLength2) };
+function emitGyroidValueAndGradient(b, x2, y2, z2, cellSize) {
+  const t = emitScaledTrig(b, x2, y2, z2, cellSize);
+  return {
+    value: b.add(b.add(b.mul(t.sx, t.cy), b.mul(t.sy, t.cz)), b.mul(t.sz, t.cx)),
+    gx: b.mul(t.scale, b.sub(b.mul(t.cx, t.cy), b.mul(t.sz, t.sx))),
+    gy: b.mul(t.scale, b.add(b.neg(b.mul(t.sx, t.sy)), b.mul(t.cy, t.cz))),
+    gz: b.mul(t.scale, b.add(b.neg(b.mul(t.sy, t.sz)), b.mul(t.cz, t.cx)))
+  };
 }
-function createSdfMeshingDiagnostics(settings, bounds, paddedBounds) {
-  const grid = estimateSdfGridDimensions(paddedBounds, settings.edgeLength);
-  const estimatedSamples = grid[0] * grid[1] * grid[2];
+function emitSchwarzPValueAndGradient(b, x2, y2, z2, cellSize) {
+  const t = emitScaledTrig(b, x2, y2, z2, cellSize);
   return {
-    bounds: cloneBounds$2(bounds),
-    paddedBounds: cloneBounds$2(paddedBounds),
-    edgeLength: settings.edgeLength,
-    grid,
-    estimatedSamples,
-    estimatedMemoryBytes: estimatedSamples * 8,
-    treeRiskFlags: [...settings.treeRiskFlags],
-    simplification: settings.simplify,
-    capMode: "box",
-    capInset: settings.edgeLength,
-    warnings: [...settings.warnings]
+    value: b.add(b.add(t.cx, t.cy), t.cz),
+    gx: b.neg(b.mul(t.scale, t.sx)),
+    gy: b.neg(b.mul(t.scale, t.sy)),
+    gz: b.neg(b.mul(t.scale, t.sz))
   };
 }
-function assertSdfMeshingBudget(diagnostics, maxGridPoints) {
-  if (diagnostics.estimatedSamples <= maxGridPoints) return;
-  const suggestedEdge = suggestEdgeLengthForSampleBudget(diagnostics.paddedBounds, maxGridPoints);
-  throw new Error(
-    `SDF meshing would sample ${formatCount(diagnostics.estimatedSamples)} grid points (~${formatBytes(
-      diagnostics.estimatedMemoryBytes
-    )}). Reduce bounds or use edgeLength >= ${formatMm(suggestedEdge)}.`
+function emitDiamondValueAndGradient(b, x2, y2, z2, cellSize) {
+  const t = emitScaledTrig(b, x2, y2, z2, cellSize);
+  return {
+    value: b.add(
+      b.add(b.mul(b.mul(t.sx, t.sy), t.sz), b.mul(b.mul(t.sx, t.cy), t.cz)),
+      b.add(b.mul(b.mul(t.cx, t.sy), t.cz), b.mul(b.mul(t.cx, t.cy), t.sz))
+    ),
+    gx: b.mul(
+      t.scale,
+      b.add(
+        b.add(b.mul(b.mul(t.cx, t.sy), t.sz), b.mul(b.mul(t.cx, t.cy), t.cz)),
+        b.add(b.neg(b.mul(b.mul(t.sx, t.sy), t.cz)), b.neg(b.mul(b.mul(t.sx, t.cy), t.sz)))
+      )
+    ),
+    gy: b.mul(
+      t.scale,
+      b.add(
+        b.add(b.mul(b.mul(t.sx, t.cy), t.sz), b.neg(b.mul(b.mul(t.sx, t.sy), t.cz))),
+        b.add(b.mul(b.mul(t.cx, t.cy), t.cz), b.neg(b.mul(b.mul(t.cx, t.sy), t.sz)))
+      )
+    ),
+    gz: b.mul(
+      t.scale,
+      b.add(
+        b.add(b.mul(b.mul(t.sx, t.sy), t.cz), b.neg(b.mul(b.mul(t.sx, t.cy), t.sz))),
+        b.add(b.neg(b.mul(b.mul(t.cx, t.sy), t.sz)), b.mul(b.mul(t.cx, t.cy), t.cz))
+      )
+    )
+  };
+}
+function emitLidinoidValueAndGradient(b, x2, y2, z2, cellSize) {
+  const t = emitScaledTrig(b, x2, y2, z2, cellSize);
+  const value = b.add(
+    b.sub(
+      b.add(b.add(b.mul(b.mul(t.sx2, t.cy), t.sz), b.mul(b.mul(t.sy2, t.cz), t.sx)), b.mul(b.mul(t.sz2, t.cx), t.sy)),
+      b.add(b.add(b.mul(t.cx2, t.cy2), b.mul(t.cy2, t.cz2)), b.mul(t.cz2, t.cx2))
+    ),
+    b.constant(0.3)
   );
+  return {
+    value,
+    gx: b.mul(
+      t.scale,
+      b.add(
+        b.add(
+          b.add(b.mul(b.mul(b.constant(2), t.cx2), b.mul(t.cy, t.sz)), b.mul(b.mul(t.sy2, t.cz), t.cx)),
+          b.neg(b.mul(b.mul(t.sz2, t.sx), t.sy))
+        ),
+        b.add(b.mul(b.mul(b.constant(2), t.sx2), t.cy2), b.mul(b.mul(b.constant(2), t.cz2), t.sx2))
+      )
+    ),
+    gy: b.mul(
+      t.scale,
+      b.add(
+        b.add(
+          b.add(b.neg(b.mul(b.mul(t.sx2, t.sy), t.sz)), b.mul(b.mul(b.constant(2), t.cy2), b.mul(t.cz, t.sx))),
+          b.mul(b.mul(t.sz2, t.cx), t.cy)
+        ),
+        b.add(b.mul(b.mul(b.constant(2), t.cx2), t.sy2), b.mul(b.mul(b.constant(2), t.sy2), t.cz2))
+      )
+    ),
+    gz: b.mul(
+      t.scale,
+      b.add(
+        b.add(
+          b.add(b.mul(b.mul(t.sx2, t.cy), t.cz), b.neg(b.mul(b.mul(t.sy2, t.sz), t.sx))),
+          b.mul(b.mul(b.constant(2), t.cz2), b.mul(t.cx, t.sy))
+        ),
+        b.add(b.mul(b.mul(b.constant(2), t.cy2), t.sz2), b.mul(b.mul(b.constant(2), t.sz2), t.cx2))
+      )
+    )
+  };
 }
-function estimateSdfGridDimensions(bounds, edgeLength2) {
-  const dx = bounds.max[0] - bounds.min[0];
-  const dy = bounds.max[1] - bounds.min[1];
-  const dz = bounds.max[2] - bounds.min[2];
-  return [
-    Math.max(2, Math.ceil(dx / edgeLength2) + 1),
-    Math.max(2, Math.ceil(dy / edgeLength2) + 1),
-    Math.max(2, Math.ceil(dz / edgeLength2) + 1)
-  ];
+function emitTpmsDistance(b, { value, gx, gy, gz }, thickness, thicknessMode) {
+  if (thicknessMode !== "metric-approx") return b.sub(b.abs(value), b.constant(thickness));
+  const grad = length3(b, gx, gy, gz);
+  return b.sub(b.div(b.abs(value), b.max(grad, b.constant(GRAD_EPS))), b.constant(thickness * 0.5));
 }
-function logSdfMeshingDiagnostics(prefix, diagnostics) {
-  const warnings = diagnostics.warnings.length > 0 ? `, warnings=${diagnostics.warnings.join(" | ")}` : "";
-  console.info(
-    `${prefix}: bounds=${formatBounds(diagnostics.bounds)}, paddedBounds=${formatBounds(diagnostics.paddedBounds)}, edgeLength=${formatMm(diagnostics.edgeLength)}, grid=${diagnostics.grid.join("x")}, estimatedSamples=${formatCount(diagnostics.estimatedSamples)}, treeRisk=${diagnostics.treeRiskFlags.join("+") || "none"}, simplify=${diagnostics.simplification}, capMode=${diagnostics.capMode}, capInset=${formatMm(diagnostics.capInset)}${warnings}`
-  );
+const { cos, max, sin, sqrt } = Math;
+function emitSdfProgramNode(b, node, x2, y2, z2) {
+  switch (node.kind) {
+    case "sdf:sphere":
+      return sdSphere(b, x2, y2, z2, node.radius);
+    case "sdf:box": {
+      const [hx, hy, hz] = node.halfExtents;
+      return sdBox(b, x2, y2, z2, hx, hy, hz);
+    }
+    case "sdf:cylinder":
+      return sdCylinder(b, x2, y2, z2, node.height, node.radius);
+    case "sdf:torus":
+      return sdTorus(b, x2, y2, z2, node.majorRadius, node.minorRadius);
+    case "sdf:capsule":
+      return sdCapsule(b, x2, y2, z2, node.height, node.radius);
+    case "sdf:cone":
+      return sdCone(b, x2, y2, z2, node.height, node.radius);
+    case "sdf:polylineSweep":
+      return sdPolylineSweep(b, node, x2, y2, z2);
+    case "sdf:union":
+      return foldChildren(b, node.children, x2, y2, z2, (a2, child) => b.min(a2, child));
+    case "sdf:difference":
+      return foldChildren(b, node.children, x2, y2, z2, (a2, child) => b.max(a2, b.neg(child)));
+    case "sdf:intersection":
+      return foldChildren(b, node.children, x2, y2, z2, (a2, child) => b.max(a2, child));
+    case "sdf:smoothUnion":
+      return foldChildren(b, node.children, x2, y2, z2, (a2, child) => smin(b, a2, child, node.radius));
+    case "sdf:smoothDifference":
+      return foldChildren(b, node.children, x2, y2, z2, (a2, child) => smax(b, a2, b.neg(child), node.radius));
+    case "sdf:smoothIntersection":
+      return foldChildren(b, node.children, x2, y2, z2, (a2, child) => smax(b, a2, child, node.radius));
+    case "sdf:morph": {
+      const a2 = emitSdfProgramNode(b, node.a, x2, y2, z2);
+      const childB = emitSdfProgramNode(b, node.b, x2, y2, z2);
+      return b.add(b.mul(a2, b.constant(1 - node.t)), b.mul(childB, b.constant(node.t)));
+    }
+    case "sdf:translate": {
+      const [ox, oy, oz] = node.offset;
+      return emitSdfProgramNode(b, node.child, b.sub(x2, b.constant(ox)), b.sub(y2, b.constant(oy)), b.sub(z2, b.constant(oz)));
+    }
+    case "sdf:rotate":
+      return emitRotated(b, node, x2, y2, z2);
+    case "sdf:scale": {
+      const inv = 1 / node.factor;
+      const child = emitSdfProgramNode(b, node.child, b.mul(x2, b.constant(inv)), b.mul(y2, b.constant(inv)), b.mul(z2, b.constant(inv)));
+      return b.mul(child, b.constant(node.factor));
+    }
+    case "sdf:twist": {
+      const angle = b.mul(b.constant(node.degreesPerUnit * DEG$1), z2);
+      const c2 = b.cos(angle);
+      const s = b.sin(angle);
+      return emitSdfProgramNode(b, node.child, b.sub(b.mul(c2, x2), b.mul(s, y2)), b.add(b.mul(s, x2), b.mul(c2, y2)), z2);
+    }
+    case "sdf:bend": {
+      const angle = b.div(x2, b.constant(node.radius));
+      const c2 = b.cos(angle);
+      const s = b.sin(angle);
+      const radiusPlusY = b.add(b.constant(node.radius), y2);
+      return emitSdfProgramNode(b, node.child, b.mul(radiusPlusY, s), b.sub(b.mul(radiusPlusY, c2), b.constant(node.radius)), z2);
+    }
+    case "sdf:repeat": {
+      const [sx, sy, sz] = node.spacing;
+      const [cx, cy, cz] = node.count;
+      return emitSdfProgramNode(b, node.child, repeatCoord(b, x2, sx, cx), repeatCoord(b, y2, sy, cy), repeatCoord(b, z2, sz, cz));
+    }
+    case "sdf:shell": {
+      const child = emitSdfProgramNode(b, node.child, x2, y2, z2);
+      return b.sub(b.abs(child), b.constant(node.thickness * 0.5));
+    }
+    case "sdf:onion": {
+      let d2 = emitSdfProgramNode(b, node.child, x2, y2, z2);
+      for (let i = 0; i < node.layers; i++) d2 = b.sub(b.abs(d2), b.constant(node.thickness));
+      return d2;
+    }
+    case "sdf:gyroid":
+      return emitTpmsDistance(b, emitGyroidValueAndGradient(b, x2, y2, z2, node.cellSize), node.thickness, node.thicknessMode);
+    case "sdf:schwarzP":
+      return emitTpmsDistance(b, emitSchwarzPValueAndGradient(b, x2, y2, z2, node.cellSize), node.thickness, node.thicknessMode);
+    case "sdf:diamond":
+      return emitTpmsDistance(b, emitDiamondValueAndGradient(b, x2, y2, z2, node.cellSize), node.thickness, node.thicknessMode);
+    case "sdf:lidinoid":
+      return emitTpmsDistance(b, emitLidinoidValueAndGradient(b, x2, y2, z2, node.cellSize), node.thickness, node.thicknessMode);
+    default:
+      throw new UnsupportedSdfProgramNodeError(`SdfProgram does not support node kind ${node.kind} yet.`);
+  }
 }
-function resolveDefaultEdgeLength(bounds, quality, minEdgeLength, analysis, options) {
-  const dx = bounds.max[0] - bounds.min[0];
-  const dy = bounds.max[1] - bounds.min[1];
-  const dz = bounds.max[2] - bounds.min[2];
-  const maxDim = Math.max(dx, dy, dz, minEdgeLength);
-  const divisor = quality === "draft" ? 60 : quality === "export" ? 160 : 100;
-  const candidates = [maxDim / divisor];
-  if (options.tolerance !== void 0) candidates.push(requirePositiveFinite$2(options.tolerance, "SDF tolerance") * 2);
-  if (options.minFeatureSize !== void 0) candidates.push(requirePositiveFinite$2(options.minFeatureSize, "SDF minFeatureSize") / 2.5);
-  if (analysis.minMetricTpmsThickness < Infinity) candidates.push(analysis.minMetricTpmsThickness / 2);
-  if (analysis.minTpmsCellSize < Infinity) candidates.push(analysis.minTpmsCellSize / 10);
-  if (analysis.minRepeatSpacing < Infinity) candidates.push(analysis.minRepeatSpacing / 8);
-  if (analysis.minWallThickness < Infinity) candidates.push(analysis.minWallThickness / 2.5);
-  return Math.max(minEdgeLength, Math.min(...candidates.filter((v) => Number.isFinite(v) && v > 0)));
+function foldChildren(b, children, x2, y2, z2, combine2) {
+  let d2 = emitSdfProgramNode(b, children[0], x2, y2, z2);
+  for (let i = 1; i < children.length; i++) d2 = combine2(d2, emitSdfProgramNode(b, children[i], x2, y2, z2));
+  return d2;
 }
-function resolveSimplificationMode(simplify, quality, riskFlags) {
-  if (simplify === false) return "off";
-  if (simplify === true || simplify === "safe") return "safe";
-  if (quality === "export" && riskFlags.size > 0) return "off";
-  return "safe";
+function emitRotated(b, node, x2, y2, z2) {
+  const [rx, ry, rz] = node.degrees.map((d2) => d2 * DEG$1);
+  const cx = cos(rx);
+  const sx = sin(rx);
+  const cy = cos(ry);
+  const sy = sin(ry);
+  const cz = cos(rz);
+  const sz = sin(rz);
+  const x1 = b.add(b.mul(b.constant(cz), x2), b.mul(b.constant(sz), y2));
+  const y1 = b.sub(b.mul(b.constant(cz), y2), b.mul(b.constant(sz), x2));
+  const x22 = b.sub(b.mul(b.constant(cy), x1), b.mul(b.constant(sy), z2));
+  const z22 = b.add(b.mul(b.constant(sy), x1), b.mul(b.constant(cy), z2));
+  const y22 = b.add(b.mul(b.constant(cx), y1), b.mul(b.constant(sx), z22));
+  const z3 = b.sub(b.mul(b.constant(cx), z22), b.mul(b.constant(sx), y1));
+  return emitSdfProgramNode(b, node.child, x22, y22, z3);
+}
+function sdSphere(b, x2, y2, z2, r) {
+  return b.sub(length3(b, x2, y2, z2), b.constant(r));
+}
+function sdBox(b, x2, y2, z2, hx, hy, hz) {
+  const dx = b.sub(b.abs(x2), b.constant(hx));
+  const dy = b.sub(b.abs(y2), b.constant(hy));
+  const dz = b.sub(b.abs(z2), b.constant(hz));
+  const outside = length3(b, b.max(dx, b.constant(0)), b.max(dy, b.constant(0)), b.max(dz, b.constant(0)));
+  const inside = b.min(b.max(b.max(dx, dy), dz), b.constant(0));
+  return b.add(outside, inside);
+}
+function sdCylinder(b, x2, y2, z2, h, r) {
+  const dx = b.sub(length2(b, x2, y2), b.constant(r));
+  const dz = b.sub(b.abs(z2), b.constant(h * 0.5));
+  return b.add(length2(b, b.max(dx, b.constant(0)), b.max(dz, b.constant(0))), b.min(b.max(dx, dz), b.constant(0)));
+}
+function sdTorus(b, x2, y2, z2, majorRadius, minorRadius) {
+  return b.sub(length2(b, b.sub(length2(b, x2, y2), b.constant(majorRadius)), z2), b.constant(minorRadius));
+}
+function sdCapsule(b, x2, y2, z2, h, r) {
+  const cz = clampSlot(b, z2, -h * 0.5, h * 0.5);
+  return b.sub(length3(b, x2, y2, b.sub(z2, cz)), b.constant(r));
+}
+function sdCone(b, x2, y2, z2, h, r) {
+  const q = length2(b, x2, y2);
+  const cLen = sqrt(h * h + r * r);
+  const side = b.add(b.mul(b.constant(h / cLen), q), b.mul(b.constant(-r / cLen), b.sub(z2, b.constant(h))));
+  return b.max(b.max(side, b.neg(z2)), b.sub(z2, b.constant(h)));
+}
+function sdPolylineSweep(b, node, x2, y2, z2) {
+  let d2 = sdTaperedSegment(b, x2, y2, z2, node.points[0], node.points[1], node.radii[0], node.radii[1]);
+  for (let i = 1; i < node.points.length - 1; i++) {
+    const segment = sdTaperedSegment(b, x2, y2, z2, node.points[i], node.points[i + 1], node.radii[i], node.radii[i + 1]);
+    d2 = smin(b, d2, segment, node.blend);
+  }
+  return d2;
 }
-function analyzeSdfTree(tree) {
-  const analysis = {
-    riskFlags: /* @__PURE__ */ new Set(),
-    minTpmsCellSize: Infinity,
-    minMetricTpmsThickness: Infinity,
-    minRepeatSpacing: Infinity,
-    minWallThickness: Infinity,
-    hasInfiniteRepeat: false,
-    hasLegacyTpmsThreshold: false
-  };
-  visitSdfNode(tree, analysis);
-  return analysis;
+function sdTaperedSegment(b, x2, y2, z2, a2, end, ra, rb) {
+  const vx = end[0] - a2[0];
+  const vy = end[1] - a2[1];
+  const vz = end[2] - a2[2];
+  const len2 = vx * vx + vy * vy + vz * vz;
+  if (len2 <= 1e-12) return sdSphere(b, b.sub(x2, b.constant(a2[0])), b.sub(y2, b.constant(a2[1])), b.sub(z2, b.constant(a2[2])), max(ra, rb));
+  const h = clampSlot(
+    b,
+    b.div(
+      b.add(
+        b.add(b.mul(b.sub(x2, b.constant(a2[0])), b.constant(vx)), b.mul(b.sub(y2, b.constant(a2[1])), b.constant(vy))),
+        b.mul(b.sub(z2, b.constant(a2[2])), b.constant(vz))
+      ),
+      b.constant(len2)
+    ),
+    0,
+    1
+  );
+  const sx = b.sub(x2, b.add(b.constant(a2[0]), b.mul(b.constant(vx), h)));
+  const sy = b.sub(y2, b.add(b.constant(a2[1]), b.mul(b.constant(vy), h)));
+  const sz = b.sub(z2, b.add(b.constant(a2[2]), b.mul(b.constant(vz), h)));
+  const radius = b.add(b.constant(ra), b.mul(b.constant(rb - ra), h));
+  return b.sub(length3(b, sx, sy, sz), radius);
 }
-function visitSdfNode(node, analysis) {
+function repeatCoord(b, v, spacing, count) {
+  if (spacing <= 0) return v;
+  if (count > 0) {
+    const center = (count - 1) * 0.5;
+    const index2 = clampSlot(b, b.round(b.add(b.div(v, b.constant(spacing)), b.constant(center))), 0, count - 1);
+    return b.sub(v, b.mul(b.sub(index2, b.constant(center)), b.constant(spacing)));
+  }
+  return b.sub(v, b.mul(b.constant(spacing), b.round(b.div(v, b.constant(spacing)))));
+}
+function getUnsupportedSdfProgramReason(node) {
   switch (node.kind) {
+    case "sdf:displace":
+      return "displace uses a dynamic JavaScript function body";
+    case "sdf:surfaceDisplace":
+      return "surfaceDisplace uses dynamic UV/pattern evaluation";
+    case "sdf:spatialBlend":
+      return "spatialBlend uses a dynamic JavaScript blend function";
+    case "sdf:noise":
+      return "noise depends on table-based simplex evaluation";
+    case "sdf:voronoi":
+      return "voronoi depends on table-based Worley evaluation";
+    case "sdf:custom":
+      return "custom uses a dynamic JavaScript function body";
+    case "sdf:polylineSweep":
+      if (node.points.length < 2) return "polylineSweep needs at least two points";
+      if (node.points.length !== node.radii.length) return "polylineSweep point/radius counts differ";
+      return void 0;
     case "sdf:union":
     case "sdf:difference":
     case "sdf:intersection":
     case "sdf:smoothUnion":
     case "sdf:smoothDifference":
     case "sdf:smoothIntersection":
-      for (const child of node.children) visitSdfNode(child, analysis);
-      break;
+      for (const child of node.children) {
+        const reason = getUnsupportedSdfProgramReason(child);
+        if (reason) return reason;
+      }
+      return void 0;
     case "sdf:morph":
-    case "sdf:spatialBlend":
-      visitSdfNode(node.a, analysis);
-      visitSdfNode(node.b, analysis);
-      break;
+      return getUnsupportedSdfProgramReason(node.a) ?? getUnsupportedSdfProgramReason(node.b);
     case "sdf:translate":
     case "sdf:rotate":
     case "sdf:scale":
     case "sdf:twist":
     case "sdf:bend":
-    case "sdf:onion":
-      visitSdfNode(node.child, analysis);
-      break;
     case "sdf:repeat":
-      analysis.riskFlags.add("repeat");
-      for (let i = 0; i < 3; i++) {
-        const spacing = node.spacing[i];
-        if (spacing > 0) {
-          analysis.minRepeatSpacing = Math.min(analysis.minRepeatSpacing, spacing);
-          if (node.count[i] <= 0) analysis.hasInfiniteRepeat = true;
-        }
-      }
-      visitSdfNode(node.child, analysis);
-      break;
     case "sdf:shell":
-      analysis.minWallThickness = Math.min(analysis.minWallThickness, node.thickness);
-      visitSdfNode(node.child, analysis);
-      break;
-    case "sdf:displace":
-    case "sdf:surfaceDisplace":
-      analysis.riskFlags.add("displacement");
-      visitSdfNode(node.child, analysis);
-      break;
-    case "sdf:gyroid":
-    case "sdf:schwarzP":
-    case "sdf:diamond":
-    case "sdf:lidinoid":
-      analysis.riskFlags.add("tpms");
-      analysis.minTpmsCellSize = Math.min(analysis.minTpmsCellSize, node.cellSize);
-      if (node.thicknessMode === "metric-approx") {
-        analysis.minMetricTpmsThickness = Math.min(analysis.minMetricTpmsThickness, node.thickness);
-        analysis.minWallThickness = Math.min(analysis.minWallThickness, node.thickness);
-      } else {
-        analysis.hasLegacyTpmsThreshold = true;
-      }
-      break;
-    case "sdf:noise":
-      analysis.riskFlags.add("noise");
-      break;
-    case "sdf:voronoi":
-      analysis.riskFlags.add("voronoi");
-      analysis.minWallThickness = Math.min(analysis.minWallThickness, node.wallThickness);
-      if (node.surfaceChild) visitSdfNode(node.surfaceChild, analysis);
-      break;
-    case "sdf:custom":
-      analysis.riskFlags.add("custom");
-      break;
+    case "sdf:onion":
+      return getUnsupportedSdfProgramReason(node.child);
+    default:
+      return void 0;
   }
 }
-function positiveOrDefault(value, fallback) {
-  if (value === void 0) return fallback;
-  return requirePositiveFinite$2(value, "SDF meshing option");
-}
-function requirePositiveFinite$2(value, name) {
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new Error(`${name} must be a positive finite number.`);
+function compileSdfProgram(node) {
+  const unsupportedReason = getUnsupportedSdfProgramReason(node);
+  if (unsupportedReason) {
+    throw new UnsupportedSdfProgramNodeError(`SdfProgram does not support this tree yet: ${unsupportedReason}.`);
   }
-  return value;
-}
-function cloneBounds$2(bounds) {
-  return { min: [...bounds.min], max: [...bounds.max] };
-}
-function suggestEdgeLengthForSampleBudget(bounds, maxGridPoints) {
-  const dx = bounds.max[0] - bounds.min[0];
-  const dy = bounds.max[1] - bounds.min[1];
-  const dz = bounds.max[2] - bounds.min[2];
-  const volume = Math.max(dx * dy * dz, 1);
-  return Math.cbrt(volume / Math.max(maxGridPoints, 8));
+  const builder = new SdfProgramBuilder();
+  return builder.finalize(emitSdfProgramNode(builder, node, builder.x, builder.y, builder.z));
 }
-function formatBounds(bounds) {
-  return `[${bounds.min.map(formatNumber).join(",")}]-[${bounds.max.map(formatNumber).join(",")}]`;
-}
-function formatMm(value) {
-  return `${formatNumber(value)}mm`;
-}
-function formatNumber(value) {
-  return Number.isInteger(value) ? String(value) : value.toFixed(3).replace(/0+$/, "").replace(/\.$/, "");
-}
-function formatCount(value) {
-  return Math.round(value).toLocaleString("en-US");
+function compileSdfProgram3(node) {
+  return compileSdfProgramEvaluator3(compileSdfProgram(node));
 }
-function formatBytes(bytes) {
-  if (bytes < 1024 * 1024) return `${Math.ceil(bytes / 1024)} KB`;
-  return `${Math.ceil(bytes / (1024 * 1024))} MB`;
+function compileSdfMaterializationEvaluator3(node) {
+  const unsupportedReason = getUnsupportedSdfProgramReason(node);
+  if (unsupportedReason) {
+    return {
+      fn: compileSdfNode3(node),
+      engine: "closure",
+      unsupportedReason
+    };
+  }
+  return {
+    fn: compileSdfProgram3(node),
+    engine: "program"
+  };
 }
 function midpoint$3(a2, b) {
   return [(a2[0] + b[0]) / 2, (a2[1] + b[1]) / 2, (a2[2] + b[2]) / 2];
@@ -7530,7 +8286,7 @@ function scale$6(v, s) {
 function sub$7(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
-function cross$7(a2, b) {
+function cross$8(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
 function makeEdge(name, start, end, faceName, curve) {
@@ -7566,7 +8322,7 @@ function buildSurfaceSheetTopology(boundaries, options = {}) {
   const center = options.center ?? average$1(corners);
   const uAxis = normalizeAxis$1(sub$7(midpoint$3(u1Start, u1End), midpoint$3(u0Start, u0End)));
   const vAxis = normalizeAxis$1(sub$7(midpoint$3(v1Start, v1End), midpoint$3(v0Start, v0End)));
-  const normal = normalizeAxis$1(options.normal ?? cross$7(uAxis, vAxis));
+  const normal = normalizeAxis$1(options.normal ?? cross$8(uAxis, vAxis));
   const faces = /* @__PURE__ */ new Map();
   faces.set(faceName, {
     name: faceName,
@@ -7982,7 +8738,7 @@ function buildCircleExtrusionTopology(circ, height, center = false) {
   );
   return { faces, edges };
 }
-function requireFinite$8(v, label) {
+function requireFinite$9(v, label) {
   if (!Number.isFinite(v)) throw new Error(`nurbsSurface: ${label} must be finite, got ${v}`);
 }
 function normalizeSurfaceTessellation(tessellation) {
@@ -7992,11 +8748,11 @@ function normalizeSurfaceTessellation(tessellation) {
     throw new Error(`nurbsSurface: tessellation.mode must be "uniform" or "adaptive", got ${mode}`);
   }
   if (tessellation.tolerance !== void 0) {
-    requireFinite$8(tessellation.tolerance, "tessellation.tolerance");
+    requireFinite$9(tessellation.tolerance, "tessellation.tolerance");
     if (tessellation.tolerance <= 0) throw new Error("nurbsSurface: tessellation.tolerance must be > 0");
   }
-  if (tessellation.minResolution !== void 0) requireFinite$8(tessellation.minResolution, "tessellation.minResolution");
-  if (tessellation.maxResolution !== void 0) requireFinite$8(tessellation.maxResolution, "tessellation.maxResolution");
+  if (tessellation.minResolution !== void 0) requireFinite$9(tessellation.minResolution, "tessellation.minResolution");
+  if (tessellation.maxResolution !== void 0) requireFinite$9(tessellation.maxResolution, "tessellation.maxResolution");
   const minResolution = tessellation.minResolution === void 0 ? void 0 : Math.max(2, Math.round(tessellation.minResolution));
   const maxResolution = tessellation.maxResolution === void 0 ? void 0 : Math.max(2, Math.round(tessellation.maxResolution));
   if (minResolution !== void 0 && maxResolution !== void 0 && minResolution > maxResolution) {
@@ -8015,10 +8771,10 @@ function normalizeSurfaceDomain(domain) {
   const uMax = domain.uMax ?? 1;
   const vMin = domain.vMin ?? 0;
   const vMax = domain.vMax ?? 1;
-  requireFinite$8(uMin, "domain.uMin");
-  requireFinite$8(uMax, "domain.uMax");
-  requireFinite$8(vMin, "domain.vMin");
-  requireFinite$8(vMax, "domain.vMax");
+  requireFinite$9(uMin, "domain.uMin");
+  requireFinite$9(uMax, "domain.uMax");
+  requireFinite$9(vMin, "domain.vMin");
+  requireFinite$9(vMax, "domain.vMax");
   if (uMin < 0 || uMax > 1 || vMin < 0 || vMax > 1) {
     throw new Error("nurbsSurface: domain bounds must stay within [0, 1]");
   }
@@ -8030,8 +8786,8 @@ function normalizeSurfaceDomain(domain) {
 function normalizeTrimLoop(loop, label) {
   if (loop.length < 3) throw new Error(`nurbsSurface: ${label} requires at least 3 points`);
   const normalized = loop.map(([u2, v], idx) => {
-    requireFinite$8(u2, `${label}[${idx}][0]`);
-    requireFinite$8(v, `${label}[${idx}][1]`);
+    requireFinite$9(u2, `${label}[${idx}][0]`);
+    requireFinite$9(v, `${label}[${idx}][1]`);
     if (u2 < 0 || u2 > 1 || v < 0 || v > 1) throw new Error(`nurbsSurface: ${label}[${idx}] must stay within [0, 1]`);
     return [u2, v];
   });
@@ -8054,8 +8810,8 @@ function normalizeTrimCurve(curve, label) {
     throw new Error(`nurbsSurface: ${label} needs at least ${degree + 1} control points for degree=${degree}`);
   }
   const normalizedControlPoints = controlPoints.map(([u2, v], idx) => {
-    requireFinite$8(u2, `${label}.controlPoints[${idx}][0]`);
-    requireFinite$8(v, `${label}.controlPoints[${idx}][1]`);
+    requireFinite$9(u2, `${label}.controlPoints[${idx}][0]`);
+    requireFinite$9(v, `${label}.controlPoints[${idx}][1]`);
     if (u2 < 0 || u2 > 1 || v < 0 || v > 1) {
       throw new Error(`nurbsSurface: ${label}.controlPoints[${idx}] must stay within [0, 1]`);
     }
@@ -8066,7 +8822,7 @@ function normalizeTrimCurve(curve, label) {
     throw new Error(`nurbsSurface: ${label}.weights length must match controlPoints length`);
   }
   for (let idx = 0; idx < weights.length; idx += 1) {
-    requireFinite$8(weights[idx], `${label}.weights[${idx}]`);
+    requireFinite$9(weights[idx], `${label}.weights[${idx}]`);
     if (weights[idx] <= 0) throw new Error(`nurbsSurface: ${label}.weights[${idx}] must be > 0`);
   }
   const knots = curve.knots ?? generateClampedKnots(controlPoints.length, degree);
@@ -8074,7 +8830,7 @@ function normalizeTrimCurve(curve, label) {
     throw new Error(`nurbsSurface: ${label}.knots.length should be ${controlPoints.length + degree + 1}, got ${knots.length}`);
   }
   for (let idx = 0; idx < knots.length; idx += 1) {
-    requireFinite$8(knots[idx], `${label}.knots[${idx}]`);
+    requireFinite$9(knots[idx], `${label}.knots[${idx}]`);
     if (idx > 0 && knots[idx] < knots[idx - 1]) throw new Error(`nurbsSurface: ${label}.knots must be non-decreasing`);
   }
   if (knots[degree] >= knots[controlPoints.length]) {
@@ -8254,16 +9010,16 @@ class NurbsSurface {
     for (let i = 0; i < nU; i++) {
       if (controlGrid[i].length !== nV) throw new Error(`nurbsSurface: row ${i} has ${controlGrid[i].length} points, expected ${nV}`);
       for (let j = 0; j < nV; j++) {
-        requireFinite$8(controlGrid[i][j][0], `controlGrid[${i}][${j}][0]`);
-        requireFinite$8(controlGrid[i][j][1], `controlGrid[${i}][${j}][1]`);
-        requireFinite$8(controlGrid[i][j][2], `controlGrid[${i}][${j}][2]`);
+        requireFinite$9(controlGrid[i][j][0], `controlGrid[${i}][${j}][0]`);
+        requireFinite$9(controlGrid[i][j][1], `controlGrid[${i}][${j}][1]`);
+        requireFinite$9(controlGrid[i][j][2], `controlGrid[${i}][${j}][2]`);
       }
     }
     const weightsGrid = options.weights ?? controlGrid.map((row) => row.map(() => 1));
     for (let i = 0; i < nU; i++) {
       if (weightsGrid[i].length !== nV) throw new Error(`nurbsSurface: weights row ${i} length mismatch`);
       for (let j = 0; j < nV; j++) {
-        requireFinite$8(weightsGrid[i][j], `weights[${i}][${j}]`);
+        requireFinite$9(weightsGrid[i][j], `weights[${i}][${j}]`);
         if (weightsGrid[i][j] <= 0) throw new Error(`nurbsSurface: weights[${i}][${j}] must be > 0`);
       }
     }
@@ -9468,6 +10224,7 @@ function buildSweepLevelSetInput(profilePolygons, pathInput, options) {
     edgeLength: options.edgeLength
   };
 }
+const EPS$9 = 1e-9;
 function resamplePolygon(poly, targetCount) {
   if (poly.length < 2) return poly;
   if (targetCount <= 0) return [];
@@ -9505,6 +10262,78 @@ function resamplePolygon(poly, targetCount) {
   }
   return out;
 }
+function resamplePolygonByAngle(poly, targetCount, center = polygonCentroid$2(poly)) {
+  if (poly.length < 3 || targetCount <= 0) return null;
+  if (!isConvexPolygon(poly)) return null;
+  const out = [];
+  for (let index2 = 0; index2 < targetCount; index2 += 1) {
+    const angle = index2 / targetCount * Math.PI * 2;
+    const point2 = rayPolygonIntersection(center, [Math.cos(angle), Math.sin(angle)], poly);
+    if (!point2) return null;
+    out.push(point2);
+  }
+  return out;
+}
+function rayPolygonIntersection(origin, direction2, poly) {
+  let bestT = Infinity;
+  let best = null;
+  for (let index2 = 0; index2 < poly.length; index2 += 1) {
+    const a2 = poly[index2];
+    const b = poly[(index2 + 1) % poly.length];
+    const edge = [b[0] - a2[0], b[1] - a2[1]];
+    const denom = cross$7(direction2, edge);
+    if (Math.abs(denom) < EPS$9) continue;
+    const delta = [a2[0] - origin[0], a2[1] - origin[1]];
+    const rayT = cross$7(delta, edge) / denom;
+    const edgeT = cross$7(delta, direction2) / denom;
+    if (rayT >= -EPS$9 && edgeT >= -EPS$9 && edgeT <= 1 + EPS$9 && rayT < bestT) {
+      bestT = rayT;
+      best = [origin[0] + direction2[0] * rayT, origin[1] + direction2[1] * rayT];
+    }
+  }
+  return best;
+}
+function polygonCentroid$2(poly) {
+  let area2 = 0;
+  let cx = 0;
+  let cy = 0;
+  for (let index2 = 0; index2 < poly.length; index2 += 1) {
+    const a2 = poly[index2];
+    const b = poly[(index2 + 1) % poly.length];
+    const crossValue = cross$7(a2, b);
+    area2 += crossValue;
+    cx += (a2[0] + b[0]) * crossValue;
+    cy += (a2[1] + b[1]) * crossValue;
+  }
+  if (Math.abs(area2) < EPS$9) return averagePoint(poly);
+  return [cx / (3 * area2), cy / (3 * area2)];
+}
+function averagePoint(poly) {
+  let x2 = 0;
+  let y2 = 0;
+  for (const point2 of poly) {
+    x2 += point2[0];
+    y2 += point2[1];
+  }
+  return [x2 / poly.length, y2 / poly.length];
+}
+function isConvexPolygon(poly) {
+  let sign2 = 0;
+  for (let index2 = 0; index2 < poly.length; index2 += 1) {
+    const a2 = poly[index2];
+    const b = poly[(index2 + 1) % poly.length];
+    const c2 = poly[(index2 + 2) % poly.length];
+    const turn = cross$7([b[0] - a2[0], b[1] - a2[1]], [c2[0] - b[0], c2[1] - b[1]]);
+    if (Math.abs(turn) < EPS$9) continue;
+    const currentSign = Math.sign(turn);
+    if (sign2 !== 0 && currentSign !== sign2) return false;
+    sign2 = currentSign;
+  }
+  return sign2 !== 0;
+}
+function cross$7(a2, b) {
+  return a2[0] * b[1] - a2[1] * b[0];
+}
 function loftStitched(profiles2, heights, wasm) {
   if (profiles2.length < 2) return null;
   const classified = profiles2.map((loops) => classifyLoops(loops));
@@ -9633,8 +10462,10 @@ function stitchSingleLoopLoft(loops, heights, wasm) {
     maxPoints = Math.max(maxPoints, loop.length);
   }
   const N = Math.max(maxPoints, 24);
+  const angularSamples = normalizedLoops.map((loop) => resamplePolygonByAngle(loop, N));
+  const useAngularSamples = angularSamples.every((samples) => samples != null);
   const resampled = normalizedLoops.map((loop, i) => {
-    const pts2d = resamplePolygon(loop, N);
+    const pts2d = useAngularSamples ? angularSamples[i] : resamplePolygon(loop, N);
     const z2 = heights[i];
     return pts2d.map(([x2, y2]) => [x2, y2, z2]);
   });
@@ -9653,8 +10484,8 @@ function stitchSingleLoopLoft(loops, heights, wasm) {
       const v0 = baseIdx + j;
       const v1 = nextIdx + j;
       const v2 = nextIdx + j1;
-      const v3 = baseIdx + j1;
-      triangles.push(v0, v3, v2);
+      const v32 = baseIdx + j1;
+      triangles.push(v0, v32, v2);
       triangles.push(v0, v2, v1);
     }
   }
@@ -9695,7 +10526,7 @@ let _wasm$1 = null;
 async function initManifoldWasm() {
   if (_wasm$1) return _wasm$1;
   performance.mark("manifold:start");
-  const Module = (await import("./manifold-CwDdMKyc.js")).default;
+  const Module = (await import("./manifold-B9QSr-qP.js")).default;
   performance.mark("manifold:imported");
   const wasm = await Module();
   wasm.setup();
@@ -9965,8 +10796,8 @@ function stitchLoopAlongPath(loop, _path, frames, wasm) {
       const v0 = baseIdx + j;
       const v1 = nextIdx + j;
       const v2 = nextIdx + j1;
-      const v3 = baseIdx + j1;
-      triangles.push(v0, v3, v2);
+      const v32 = baseIdx + j1;
+      triangles.push(v0, v32, v2);
       triangles.push(v0, v2, v1);
     }
   }
@@ -11312,8 +12143,16 @@ function lowerShapeCompilePlanToManifold(plan, wasm) {
     case "importedMesh":
       return lowerImportedMeshToManifold(plan.fileData, plan.format, plan.filePath, wasm);
     case "sdf": {
-      const evalFn = compileSdfNode3(plan.tree);
-      return lowerSdfToManifold(evalFn, plan.bounds, plan.edgeLength, wasm, plan.meshing);
+      const evaluator = compileSdfMaterializationEvaluator3(plan.tree);
+      return lowerSdfToManifold(
+        evaluator.fn,
+        plan.bounds,
+        plan.edgeLength,
+        wasm,
+        plan.meshing,
+        evaluator.engine,
+        evaluator.unsupportedReason
+      );
     }
     case "fromSlices":
       return lowerFromSlicesToManifold(plan, wasm);
@@ -11331,8 +12170,12 @@ function lowerShapeCompilePlanToManifold(plan, wasm) {
       assertExhaustive(plan);
   }
 }
-function lowerSdfToManifold(evalFn, bounds, edgeLength2, wasm, meshing) {
+function lowerSdfToManifold(evalFn, bounds, edgeLength2, wasm, meshing, evaluatorEngine, evaluatorUnsupportedReason) {
   const diagnostics = (meshing == null ? void 0 : meshing.diagnostics) ? { ...meshing.diagnostics } : void 0;
+  if (diagnostics && evaluatorEngine) {
+    diagnostics.evaluator = evaluatorEngine;
+    if (evaluatorUnsupportedReason) diagnostics.evaluatorUnsupportedReason = evaluatorUnsupportedReason;
+  }
   const inset = edgeLength2;
   const cappedEvalFn = (x2, y2, z2) => {
     const bx = Math.max(bounds.min[0] + inset - x2, x2 - bounds.max[0] + inset);
@@ -16783,9 +17626,9 @@ function requireClipper() {
         if (ClipperLib2.use_xyz) j.OffPt.Z = OffPt.Z;
         this.m_Joins.push(j);
       };
-      ClipperLib2.Clipper.prototype.AddGhostJoin = function(Op, OffPt) {
+      ClipperLib2.Clipper.prototype.AddGhostJoin = function(Op2, OffPt) {
         var j = new ClipperLib2.Join();
-        j.OutPt1 = Op;
+        j.OutPt1 = Op2;
         j.OffPt.X = OffPt.X;
         j.OffPt.Y = OffPt.Y;
         if (ClipperLib2.use_xyz) j.OffPt.Z = OffPt.Z;
@@ -19687,7 +20530,7 @@ function requireClipper() {
 }
 var clipperExports = requireClipper();
 var ClipperLib = /* @__PURE__ */ getDefaultExportFromCjs(clipperExports);
-let f$1 = class f {
+let f$3 = class f {
   constructor(t, e) {
     this.next = null, this.key = t, this.data = e, this.left = null, this.right = null;
   }
@@ -19696,7 +20539,7 @@ function d(n, t) {
   return n > t ? 1 : n < t ? -1 : 0;
 }
 function u$1(n, t, e) {
-  const r = new f$1(null, null);
+  const r = new f$3(null, null);
   let l = r, i = r;
   for (; ; ) {
     const o = e(n, t.key);
@@ -19719,7 +20562,7 @@ function u$1(n, t, e) {
   return l.right = t.left, i.left = t.right, t.left = r.right, t.right = r.left, t;
 }
 function c(n, t, e, r) {
-  const l = new f$1(n, t);
+  const l = new f$3(n, t);
   if (e === null)
     return l.left = l.right = null, l;
   e = u$1(n, e, r);
@@ -19760,7 +20603,7 @@ class z {
    * Adds a key, if it is not present in the tree
    */
   add(t, e) {
-    const r = new f$1(t, e);
+    const r = new f$3(t, e);
     this._root === null && (r.left = r.right = null, this._size++, this._root = r);
     const l = this._comparator, i = u$1(t, this._root, l), o = l(t, i.key);
     return o === 0 ? this._root = i : (o < 0 ? (r.left = i.left, r.right = i, i.left = null) : o > 0 && (r.right = i.right, r.left = i, i.right = null), this._size++, this._root = r), this._root;
@@ -19973,23 +20816,23 @@ class z {
 function a(n, t, e, r) {
   const l = r - e;
   if (l > 0) {
-    const i = e + Math.floor(l / 2), o = n[i], s = t[i], h = new f$1(o, s);
+    const i = e + Math.floor(l / 2), o = n[i], s = t[i], h = new f$3(o, s);
     return h.left = a(n, t, e, i), h.right = a(n, t, i + 1, r), h;
   }
   return null;
 }
 function x(n, t) {
-  const e = new f$1(null, null);
+  const e = new f$3(null, null);
   let r = e;
   for (let l = 0; l < n.length; l++)
-    r = r.next = new f$1(n[l], t[l]);
+    r = r.next = new f$3(n[l], t[l]);
   return r.next = null, e.next;
 }
 function k(n) {
   let t = n;
   const e = [];
   let r = false;
-  const l = new f$1(null, null);
+  const l = new f$3(null, null);
   let i = l;
   for (; !r; )
     t ? (e.push(t), t = t.left) : e.length > 0 ? (t = i = i.next = e.pop(), t = t.right) : r = true;
@@ -20004,7 +20847,7 @@ function p(n, t, e) {
   return null;
 }
 function y(n, t, e) {
-  const r = new f$1(null, null);
+  const r = new f$3(null, null);
   let l = r, i = n, o = t;
   for (; i !== null && o !== null; )
     e(i.key, o.key) < 0 ? (l.next = i, i = i.next) : (l.next = o, o = o.next), l = l.next;
@@ -24992,7 +25835,13 @@ function normalizeTruckShapeForBooleanInput(shape) {
   return normalized;
 }
 function lowerSdfPlan(plan) {
-  const evalFn = compileSdfNode3(plan.tree);
+  var _a3, _b3, _c2;
+  const evaluator = compileSdfMaterializationEvaluator3(plan.tree);
+  if ((_a3 = plan.meshing) == null ? void 0 : _a3.diagnostics) {
+    plan.meshing.diagnostics.evaluator = evaluator.engine;
+    if (evaluator.unsupportedReason) plan.meshing.diagnostics.evaluatorUnsupportedReason = evaluator.unsupportedReason;
+  }
+  const evalFn = evaluator.fn;
   const inset = plan.edgeLength;
   const cappedEvalFn = (x2, y2, z2) => {
     const bx = Math.max(plan.bounds.min[0] + inset - x2, x2 - plan.bounds.max[0] + inset);
@@ -25004,14 +25853,18 @@ function lowerSdfPlan(plan) {
   assertSdfMeshBudget(mesh, plan);
   let surfaceNetsError;
   try {
-    return lowerExtractedSdfMesh(mesh, cappedEvalFn, true);
+    const shape = lowerExtractedSdfMesh(mesh, cappedEvalFn, true);
+    if ((_b3 = plan.meshing) == null ? void 0 : _b3.diagnostics) logSdfMeshingDiagnostics("SDF meshing result", plan.meshing.diagnostics);
+    return shape;
   } catch (error) {
     surfaceNetsError = error;
   }
   const tetraMesh = marchingTetrahedra(cappedEvalFn, plan.bounds, plan.edgeLength);
   assertSdfMeshBudget(tetraMesh, plan);
   try {
-    return lowerExtractedSdfMesh(tetraMesh, cappedEvalFn, false);
+    const shape = lowerExtractedSdfMesh(tetraMesh, cappedEvalFn, false);
+    if ((_c2 = plan.meshing) == null ? void 0 : _c2.diagnostics) logSdfMeshingDiagnostics("SDF meshing result", plan.meshing.diagnostics);
+    return shape;
   } catch (error) {
     throw new Error(
       `Truck backend does not support compile plan "sdf" for this materialized field yet: Surface Nets failed with ${surfaceNetsError instanceof Error ? surfaceNetsError.message : String(surfaceNetsError)}; marching tetrahedra failed with ${error instanceof Error ? error.message : String(error)}`
@@ -25375,7 +26228,9 @@ function lowerOffsetSolidPlan(plan) {
   if (base.kind === "transform") {
     return lowerTransformedOffsetSolidPlan(base, plan.thickness);
   }
-  return truckUnsupported(`compile plan "${plan.kind}" for non-vertical-prism/non-revolved/non-loft/non-straight-sweep/non-straight-variable-sweep solids`);
+  return truckUnsupported(
+    `compile plan "${plan.kind}" for non-vertical-prism/non-revolved/non-loft/non-straight-sweep/non-straight-variable-sweep solids`
+  );
 }
 function lowerLoftPlan(plan) {
   return wrapTruckShapeBackend(
@@ -32677,6 +33532,37 @@ function mergeSketchPlacementModel(sketches) {
   }
   return first;
 }
+function normalizeSceneTags(value, label = "tags") {
+  if (value == null) return [];
+  const rawTags = typeof value === "string" ? [value] : value;
+  if (!Array.isArray(rawTags)) {
+    throw new Error(`${label} must be a string or array of strings`);
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  rawTags.forEach((tag, index2) => {
+    if (typeof tag !== "string") {
+      throw new Error(`${label}[${index2}] must be a string`);
+    }
+    const trimmed = tag.trim();
+    if (!trimmed || seen.has(trimmed)) return;
+    seen.add(trimmed);
+    out.push(trimmed);
+  });
+  return out;
+}
+function mergeSceneTags(...values) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  values.forEach((value) => {
+    normalizeSceneTags(value).forEach((tag) => {
+      if (seen.has(tag)) return;
+      seen.add(tag);
+      out.push(tag);
+    });
+  });
+  return out;
+}
 const _groupPlacementRefs = /* @__PURE__ */ new WeakMap();
 const _groupExplodeHint = /* @__PURE__ */ new WeakMap();
 function getGroupRefs(g2) {
@@ -32700,7 +33586,7 @@ function transformGroupRefs(source, dest, matrix) {
   }
   return dest;
 }
-function requireFiniteAngle(v, method) {
+function requireFiniteAngle$1(v, method) {
   if (typeof v !== "number" || !Number.isFinite(v))
     throw new Error(`${method} angleDeg must be a finite number, got ${typeof v === "number" ? v : typeof v}`);
 }
@@ -32761,31 +33647,46 @@ function resolveNamedGroupChild(item) {
 function normalizeGroupInputs(items) {
   const children = [];
   const childNames = [];
+  const childTags = [];
   items.forEach((item) => {
     if (isNamedGroupChild(item)) {
       children.push(resolveNamedGroupChild(item));
       childNames.push(normalizeChildName(item.name));
+      childTags.push(normalizeSceneTags(item.tags, `group(...) named item "${item.name}" tags`));
       return;
     }
     children.push(item);
     childNames.push(void 0);
+    childTags.push([]);
   });
-  return { children, childNames };
+  return { children, childNames, childTags };
 }
 class ShapeGroup {
-  constructor(children, childNames) {
+  constructor(children, childNames, childTags) {
     __publicField(this, "children");
     __publicField(this, "childNames");
+    __publicField(this, "childTags");
     if (childNames && childNames.length !== children.length) {
       throw new Error("ShapeGroup childNames must match children length");
     }
+    if (childTags && childTags.length !== children.length) {
+      throw new Error("ShapeGroup childTags must match children length");
+    }
     this.children = [...children];
     this.childNames = this.children.map((_2, index2) => normalizeChildName(childNames == null ? void 0 : childNames[index2]));
+    this.childTags = this.children.map((_2, index2) => normalizeSceneTags(childTags == null ? void 0 : childTags[index2], "ShapeGroup childTags"));
   }
   /** Return the optional name of the child at `index`. */
   childName(index2) {
     return this.childNames[index2];
   }
+  /**
+   * Return tags attached to the child at `index`.
+   * @internal
+   */
+  tagsForChild(index2) {
+    return [...this.childTags[index2] ?? []];
+  }
   /**
    * Return the named child by name. Throws if not found.
    * Useful when importing a multipart group and working on components individually.
@@ -32800,13 +33701,13 @@ class ShapeGroup {
   }
   /** Apply fn to all children, producing a new ShapeGroup that also copies placement refs. */
   mapChildren(fn) {
-    const next = new ShapeGroup(this.children.map(fn), this.childNames);
+    const next = new ShapeGroup(this.children.map(fn), this.childNames, this.childTags);
     copyGroupPorts(this, next);
     return copyGroupRefs(this, next);
   }
   /** Apply fn to all children and also transform placement refs by the given matrix. */
   mapChildrenTransform(fn, matrix) {
-    const next = new ShapeGroup(this.children.map(fn), this.childNames);
+    const next = new ShapeGroup(this.children.map(fn), this.childNames, this.childTags);
     transformGroupPortsHelper(this, next, matrix);
     return transformGroupRefs(this, next, matrix);
   }
@@ -32933,25 +33834,25 @@ class ShapeGroup {
   /** Rotate the group around an arbitrary axis through the origin. */
   rotate(axis, angleDeg, options) {
     requireRotateAxis(axis, "ShapeGroup.rotate()");
-    requireFiniteAngle(angleDeg, "ShapeGroup.rotate()");
+    requireFiniteAngle$1(angleDeg, "ShapeGroup.rotate()");
     if (options == null ? void 0 : options.pivot) requireVec3Pivot(options.pivot, "ShapeGroup.rotate()");
     return this.rotateAroundAxis(axis, angleDeg, options == null ? void 0 : options.pivot);
   }
   /** Rotate the group around the X axis. */
   rotateX(angleDeg, options) {
-    requireFiniteAngle(angleDeg, "ShapeGroup.rotateX()");
+    requireFiniteAngle$1(angleDeg, "ShapeGroup.rotateX()");
     if (options == null ? void 0 : options.pivot) requireVec3Pivot(options.pivot, "ShapeGroup.rotateX()");
     return this.rotateAroundAxis([1, 0, 0], angleDeg, options == null ? void 0 : options.pivot);
   }
   /** Rotate the group around the Y axis. */
   rotateY(angleDeg, options) {
-    requireFiniteAngle(angleDeg, "ShapeGroup.rotateY()");
+    requireFiniteAngle$1(angleDeg, "ShapeGroup.rotateY()");
     if (options == null ? void 0 : options.pivot) requireVec3Pivot(options.pivot, "ShapeGroup.rotateY()");
     return this.rotateAroundAxis([0, 1, 0], angleDeg, options == null ? void 0 : options.pivot);
   }
   /** Rotate the group around the Z axis. */
   rotateZ(angleDeg, options) {
-    requireFiniteAngle(angleDeg, "ShapeGroup.rotateZ()");
+    requireFiniteAngle$1(angleDeg, "ShapeGroup.rotateZ()");
     if (options == null ? void 0 : options.pivot) requireVec3Pivot(options.pivot, "ShapeGroup.rotateZ()");
     return this.rotateAroundAxis([0, 0, 1], angleDeg, options == null ? void 0 : options.pivot);
   }
@@ -32994,7 +33895,8 @@ class ShapeGroup {
           "ShapeGroup.transform only supports 3D children (Shape/ShapeGroup). For Sketch children, use 2D transforms (translate/rotate/scale/mirror)."
         );
       }),
-      this.childNames
+      this.childNames,
+      this.childTags
     );
     transformGroupPortsHelper(this, next, matrix);
     return transformGroupRefs(this, next, matrix);
@@ -33062,7 +33964,7 @@ class ShapeGroup {
    * ```
    */
   withReferences(refs) {
-    const next = new ShapeGroup(this.children, this.childNames);
+    const next = new ShapeGroup(this.children, this.childNames, this.childTags);
     const merged = applyPlacementReferenceInput(getGroupRefs(this), refs);
     return setGroupRefs(next, merged);
   }
@@ -33130,7 +34032,7 @@ class ShapeGroup {
   /** Attach named connectors — attachment points that survive transforms.
    *  Connectors can be bare (position + orientation) or typed (with connectorType/gender for compatibility matching). */
   withConnectors(connectors) {
-    const next = new ShapeGroup(this.children, this.childNames);
+    const next = new ShapeGroup(this.children, this.childNames, this.childTags);
     copyGroupRefs(this, next);
     const existing = getGroupPorts(this);
     const incoming = normalizeConnectorMapInput(connectors);
@@ -33180,7 +34082,7 @@ class ShapeGroup {
 }
 function group(...items) {
   const normalized = normalizeGroupInputs(items);
-  return new ShapeGroup(normalized.children, normalized.childNames);
+  return new ShapeGroup(normalized.children, normalized.childNames, normalized.childTags);
 }
 function getTargetPortsForGroup(target) {
   if (target instanceof Shape) {
@@ -35355,7 +36257,7 @@ function buildSdfFunctionDefinition(source, options) {
     jsExpression: expression,
     ...shader.ok ? { shaderExpression: shader.expression } : { shaderUnsupportedReason: shader.reason },
     raymarchStepLimit: resolveRaymarchStepLimit(options.bounds, options.maxStep),
-    ...options.lipschitz !== void 0 ? { raymarchLipschitz: requirePositiveFinite$1(options.lipschitz, "sdf.fromFunction() lipschitz") } : {}
+    ...options.lipschitz !== void 0 ? { raymarchLipschitz: requirePositiveFinite$2(options.lipschitz, "sdf.fromFunction() lipschitz") } : {}
   };
 }
 function extractSdfExpression(source) {
@@ -35523,7 +36425,7 @@ function formatNumericLiteralsForGlsl(source) {
   return result;
 }
 function resolveRaymarchStepLimit(bounds, maxStep) {
-  if (maxStep !== void 0) return requirePositiveFinite$1(maxStep, "sdf.fromFunction() maxStep");
+  if (maxStep !== void 0) return requirePositiveFinite$2(maxStep, "sdf.fromFunction() maxStep");
   const dx = bounds.max[0] - bounds.min[0];
   const dy = bounds.max[1] - bounds.min[1];
   const dz = bounds.max[2] - bounds.min[2];
@@ -35531,7 +36433,7 @@ function resolveRaymarchStepLimit(bounds, maxStep) {
   if (!Number.isFinite(diagonal) || diagonal <= 0) return 0.1;
   return Math.max(0.025, Math.min(0.5, diagonal / 240));
 }
-function requirePositiveFinite$1(value, label) {
+function requirePositiveFinite$2(value, label) {
   if (!Number.isFinite(value) || value <= 0) throw new Error(`${label} must be a positive finite number.`);
   return value;
 }
@@ -35558,6 +36460,199 @@ class SurfacePattern {
     this.constants = constants;
   }
 }
+const typedSurfacePatterns = /* @__PURE__ */ new WeakMap();
+function getTypedSurfacePattern(pattern) {
+  return typedSurfacePatterns.get(pattern);
+}
+class Pattern2D extends SurfacePattern {
+  constructor(body) {
+    super(body);
+  }
+  /** Add this pattern to one or more patterns or constant height offsets. */
+  add(...patterns) {
+    throw new Error("Pattern2D values are created by sdf.pattern2d().");
+  }
+  /** Subtract another pattern or constant height offset from this pattern. */
+  subtract(pattern) {
+    throw new Error("Pattern2D values are created by sdf.pattern2d().");
+  }
+  /** Multiply this pattern by one or more patterns or numeric scale factors. */
+  multiply(...patterns) {
+    throw new Error("Pattern2D values are created by sdf.pattern2d().");
+  }
+  /** Keep the lower height between this pattern and one or more other patterns. */
+  min(...patterns) {
+    throw new Error("Pattern2D values are created by sdf.pattern2d().");
+  }
+  /** Keep the higher height between this pattern and one or more other patterns. */
+  max(...patterns) {
+    throw new Error("Pattern2D values are created by sdf.pattern2d().");
+  }
+  /** Limit pattern height to the inclusive `[min, max]` range in millimeters. */
+  clamp(min2, max2) {
+    throw new Error("Pattern2D values are created by sdf.pattern2d().");
+  }
+  /** Convert negative heights to positive heights. */
+  abs() {
+    throw new Error("Pattern2D values are created by sdf.pattern2d().");
+  }
+  /** Flip the pattern height sign. */
+  negate() {
+    throw new Error("Pattern2D values are created by sdf.pattern2d().");
+  }
+}
+class Pattern2DImpl extends Pattern2D {
+  constructor(node) {
+    super(emitSurfacePatternJsExpression(node));
+    __publicField(this, "node");
+    this.node = node;
+    typedSurfacePatterns.set(this, node);
+  }
+  add(...patterns) {
+    return new Pattern2DImpl({ kind: "surfacePattern:add", children: [this.node, ...patterns.map(patternNodeFromInput)] });
+  }
+  subtract(pattern) {
+    return this.add(new Pattern2DImpl({ kind: "surfacePattern:negate", child: patternNodeFromInput(pattern) }));
+  }
+  multiply(...patterns) {
+    return new Pattern2DImpl({ kind: "surfacePattern:multiply", children: [this.node, ...patterns.map(patternNodeFromInput)] });
+  }
+  min(...patterns) {
+    return new Pattern2DImpl({ kind: "surfacePattern:min", children: [this.node, ...patterns.map(patternNodeFromInput)] });
+  }
+  max(...patterns) {
+    return new Pattern2DImpl({ kind: "surfacePattern:max", children: [this.node, ...patterns.map(patternNodeFromInput)] });
+  }
+  clamp(min2, max2) {
+    const lo = requireFinite$8(min2, "Pattern2D.clamp() min");
+    const hi = requireFinite$8(max2, "Pattern2D.clamp() max");
+    if (lo > hi) throw new Error(`Pattern2D.clamp() min must be <= max. Received: ${lo} > ${hi}`);
+    return new Pattern2DImpl({ kind: "surfacePattern:clamp", child: this.node, min: lo, max: hi });
+  }
+  abs() {
+    return new Pattern2DImpl({ kind: "surfacePattern:abs", child: this.node });
+  }
+  negate() {
+    return new Pattern2DImpl({ kind: "surfacePattern:negate", child: this.node });
+  }
+}
+class Pattern2DBuilder {
+  /** Create a constant-height pattern in millimeters. */
+  constant(value = 0) {
+    return new Pattern2DImpl({ kind: "surfacePattern:constant", value: requireFinite$8(value, "sdf.pattern2d().constant() value") });
+  }
+  /** Create a sinusoidal wave pattern in UV space. */
+  sineWave(options) {
+    return new Pattern2DImpl({
+      kind: "surfacePattern:sineWave",
+      direction: normalizeDirection$1(options.direction ?? [1, 0], "sdf.pattern2d().sineWave() direction"),
+      wavelength: requirePositiveFinite$1(options.wavelength, "sdf.pattern2d().sineWave() wavelength"),
+      amplitude: requireFinite$8(options.amplitude ?? 1, "sdf.pattern2d().sineWave() amplitude"),
+      phase: requireFinite$8(options.phase ?? 0, "sdf.pattern2d().sineWave() phase"),
+      bias: requireFinite$8(options.bias ?? 0, "sdf.pattern2d().sineWave() bias")
+    });
+  }
+  /** Create recessed stripe bands in UV space. */
+  stripes(options) {
+    return new Pattern2DImpl({
+      kind: "surfacePattern:stripes",
+      direction: normalizeDirection$1(options.direction ?? [1, 0], "sdf.pattern2d().stripes() direction"),
+      spacing: requirePositiveFinite$1(options.spacing, "sdf.pattern2d().stripes() spacing"),
+      width: requirePositiveFinite$1(options.width, "sdf.pattern2d().stripes() width"),
+      depth: requireNonNegativeFinite$1(options.depth ?? 1, "sdf.pattern2d().stripes() depth")
+    });
+  }
+  /** Create an over-under woven relief pattern in UV space. */
+  overUnderWeave(options) {
+    return new Pattern2DImpl({
+      kind: "surfacePattern:overUnderWeave",
+      spacing: normalizeVec2(options.spacing, "sdf.pattern2d().overUnderWeave() spacing", requirePositiveFinite$1),
+      threadWidth: normalizeVec2(options.threadWidth, "sdf.pattern2d().overUnderWeave() threadWidth", requirePositiveFinite$1),
+      depth: requireNonNegativeFinite$1(options.depth ?? 0.8, "sdf.pattern2d().overUnderWeave() depth"),
+      underScale: requireNonNegativeFinite$1(options.underScale ?? 0.15, "sdf.pattern2d().overUnderWeave() underScale")
+    });
+  }
+}
+function pattern2d() {
+  return new Pattern2DBuilder();
+}
+function patternNodeFromInput(input) {
+  if (input instanceof SurfacePattern) {
+    const node = getTypedSurfacePattern(input);
+    if (node) return node;
+  }
+  if (typeof input === "number") {
+    return { kind: "surfacePattern:constant", value: requireFinite$8(input, "Pattern2D numeric input") };
+  }
+  throw new Error("Pattern2D composition expects another typed Pattern2D or a number.");
+}
+function requireFinite$8(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${label} must be a finite number. Received: ${String(value)}`);
+  }
+  return value;
+}
+function requirePositiveFinite$1(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw new Error(`${label} must be a positive finite number. Received: ${String(value)}`);
+  }
+  return value;
+}
+function requireNonNegativeFinite$1(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative finite number. Received: ${String(value)}`);
+  }
+  return value;
+}
+function normalizeVec2(value, label, validate) {
+  if (typeof value === "number") {
+    const n = validate(value, label);
+    return [n, n];
+  }
+  return [validate(value[0], `${label}[0]`), validate(value[1], `${label}[1]`)];
+}
+function normalizeDirection$1(value, label) {
+  const x2 = requireFinite$8(value[0], `${label}[0]`);
+  const y2 = requireFinite$8(value[1], `${label}[1]`);
+  const length4 = Math.hypot(x2, y2);
+  if (length4 <= 0) throw new Error(`${label} must not be the zero vector.`);
+  return [x2 / length4, y2 / length4];
+}
+function f$2(value) {
+  if (!Number.isFinite(value)) return "0";
+  return Number(value.toPrecision(12)).toString();
+}
+function emitSurfacePatternJsExpression(node) {
+  switch (node.kind) {
+    case "surfacePattern:constant":
+      return f$2(node.value);
+    case "surfacePattern:sineWave": {
+      const coord = `(u * ${f$2(node.direction[0])} + v * ${f$2(node.direction[1])})`;
+      const phase = `(${coord} * ${f$2(2 * Math.PI / node.wavelength)} + ${f$2(node.phase)})`;
+      return `(${f$2(node.bias)} + Math.sin(${phase}) * ${f$2(node.amplitude)})`;
+    }
+    case "surfacePattern:stripes": {
+      const coord = `(u * ${f$2(node.direction[0])} + v * ${f$2(node.direction[1])})`;
+      return `(function(){var c=${coord};var d=Math.abs(c - Math.round(c / ${f$2(node.spacing)}) * ${f$2(node.spacing)});var p=Math.max(0, 1 - d / ${f$2(node.width * 0.5)});return -(p * p) * ${f$2(node.depth)};})()`;
+    }
+    case "surfacePattern:overUnderWeave":
+      return `(function(){var su=u/${f$2(node.spacing[0])};var sv=v/${f$2(node.spacing[1])};var du=Math.abs(su - Math.round(su))*${f$2(node.spacing[0])};var dv=Math.abs(sv - Math.round(sv))*${f$2(node.spacing[1])};var pU=Math.max(0,1-du/${f$2(node.threadWidth[0] * 0.5)});pU*=pU;var pV=Math.max(0,1-dv/${f$2(node.threadWidth[1] * 0.5)});pV*=pV;var checker=((Math.round(su)&65535)+(Math.round(sv)&65535))&1;var top=checker?pV:pU;var bot=checker?pU:pV;return -Math.max(top,bot*${f$2(node.underScale)})*${f$2(node.depth)};})()`;
+    case "surfacePattern:abs":
+      return `Math.abs(${emitSurfacePatternJsExpression(node.child)})`;
+    case "surfacePattern:negate":
+      return `(-(${emitSurfacePatternJsExpression(node.child)}))`;
+    case "surfacePattern:add":
+      return node.children.length === 0 ? "0" : `(${node.children.map(emitSurfacePatternJsExpression).join(" + ")})`;
+    case "surfacePattern:multiply":
+      return node.children.length === 0 ? "1" : `(${node.children.map(emitSurfacePatternJsExpression).join(" * ")})`;
+    case "surfacePattern:min":
+      return node.children.length === 0 ? "0" : `Math.min(${node.children.map(emitSurfacePatternJsExpression).join(", ")})`;
+    case "surfacePattern:max":
+      return node.children.length === 0 ? "0" : `Math.max(${node.children.map(emitSurfacePatternJsExpression).join(", ")})`;
+    case "surfacePattern:clamp":
+      return `Math.min(${f$2(node.max)}, Math.max(${f$2(node.min)}, ${emitSurfacePatternJsExpression(node.child)}))`;
+  }
+}
 const SCULPT_MATERIAL_PRESETS = {
   ceramic: {
     color: "#f4f0e6",
@@ -35627,6 +36722,18 @@ function requirePositiveFinite(value, label) {
   }
   return value;
 }
+function requirePositiveInteger(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value < 1) {
+    throw new Error(`${label} must be a positive integer. Received: ${String(value)}`);
+  }
+  return value;
+}
+function requireNonNegativeFinite(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative finite number. Received: ${String(value)}`);
+  }
+  return value;
+}
 function resolveBlendRadius(input, label, fallback = 4) {
   if (typeof input === "number") return requirePositiveFinite(input, `${label} radius`);
   if ((input == null ? void 0 : input.radius) !== void 0) return requirePositiveFinite(input.radius, `${label} radius`);
@@ -35873,6 +36980,29 @@ class SdfShape {
   clipBox(x2, y2, z2) {
     return this.intersect(box$1(x2, y2, z2));
   }
+  /** Keep only the material where this shape overlaps another SDF pattern. */
+  fillWith(pattern) {
+    if (!(pattern instanceof SdfShape)) {
+      throw new Error("SdfShape.fillWith() expects an SdfShape pattern, such as sdf.gyroid({ cellSize, wallThickness }).");
+    }
+    return this.intersect(pattern);
+  }
+  /** Keep only the gyroid lattice inside this shape. */
+  fillWithGyroid(options) {
+    return this.fillWith(gyroid(options));
+  }
+  /** Keep only the Schwarz-P lattice inside this shape. */
+  fillWithSchwarzP(options) {
+    return this.fillWith(schwarzP(options));
+  }
+  /** Keep only the diamond TPMS lattice inside this shape. */
+  fillWithDiamond(options) {
+    return this.fillWith(diamond(options));
+  }
+  /** Keep only the lidinoid TPMS lattice inside this shape. */
+  fillWithLidinoid(options) {
+    return this.fillWith(lidinoid(options));
+  }
   /** Smooth union — blends shapes together with a smooth radius. */
   smoothUnion(other, radius) {
     return this.withNode({ kind: "sdf:smoothUnion", children: [this._node, other._node], radius });
@@ -35933,6 +37063,21 @@ class SdfShape {
   repeat(spacing, count) {
     return this.withNode({ kind: "sdf:repeat", child: this._node, spacing, count: count ?? [0, 0, 0] });
   }
+  /**
+   * Arrange this SDF in a circular array around the Z axis.
+   *
+   * The source shape is translated by `offset` in +X before arraying. This uses
+   * angular domain folding, so evaluation stays O(1): the source SDF is sampled
+   * twice no matter how many copies are requested.
+   */
+  circularArray(count, offset2 = 0) {
+    return this.withNode({
+      kind: "sdf:circularArray",
+      child: this._node,
+      count: requirePositiveInteger(count, "SdfShape.circularArray() count"),
+      offset: requireNonNegativeFinite(offset2, "SdfShape.circularArray() offset")
+    });
+  }
   /** Hollow out, keeping only a shell of given thickness. */
   shell(thickness) {
     return this.withNode({ kind: "sdf:shell", child: this._node, thickness });
@@ -35944,8 +37089,8 @@ class SdfShape {
    * // Function displacement
    * shape.displace((x, y, z) => Math.sin(x) * 0.5)
    *
-   * // Pattern displacement (e.g. basketWeave)
-   * shape.displace(sdf.basketWeave({ threads: 16, spacing: 3 }))
+   * // Pattern displacement from a 3D SDF field
+   * shape.displace(sdf.knurl({ pitch: 2, depth: 0.3 }))
    * ```
    */
   displace(fn, constants) {
@@ -35969,10 +37114,18 @@ class SdfShape {
    * UV coordinates are in **surface millimeters** — patterns defined with `spacing: 3`
    * always produce 3mm spacing, regardless of shape size.
    *
+   * Prefer `sdf.pattern2d()` or built-in surface patterns when the relief should
+   * stay on the native shader and meshing path. Callback functions are supported
+   * for experimentation, but they are opaque to the typed pattern optimizer.
+   *
    * ```js
-   * // Surface-following basket weave — auto-detects sphere UV
+   * // Native typed pattern — auto-detects sphere UV
+   * const p = sdf.pattern2d()
+   * const ribs = p.stripes({ spacing: 3, width: 0.8, depth: 0.35 })
+   *   .add(p.sineWave({ direction: [0, 1], wavelength: 14, amplitude: 0.08 }))
+   *
    * sdf.sphere(27).shell(3)
-   *   .surfaceDisplace(sdf.basketWeave({ spacing: 3, depth: 0.8 }))
+   *   .surfaceDisplace(ribs)
    *   .toShape()
    *
    * // Custom 2D pattern via function
@@ -35982,15 +37135,18 @@ class SdfShape {
   surfaceDisplace(pattern, options) {
     let body;
     let constants;
+    let typedPattern;
     if (pattern instanceof SurfacePattern) {
       body = pattern.body;
       constants = pattern.constants;
+      typedPattern = getTypedSurfacePattern(pattern);
     } else {
       body = extractFunctionBody(pattern);
     }
     return this.withNode({
       kind: "sdf:surfaceDisplace",
       child: this._node,
+      ...typedPattern ? { pattern: typedPattern } : {},
       patternBody: body,
       constants,
       ...(options == null ? void 0 : options.uv) ? { uvMode: options.uv } : {},
@@ -36209,24 +37365,10 @@ function weave(options) {
   });
 }
 function basketWeave(options) {
-  const SP = (options == null ? void 0 : options.spacing) ?? 3;
-  const TW = (options == null ? void 0 : options.threadWidth) ?? 1.5;
-  const D2 = (options == null ? void 0 : options.depth) ?? 0.8;
-  const hw = TW * 0.5;
-  const body = `(function() {
-  var su = u / ${SP};
-  var sv = v / ${SP};
-  var du = Math.abs(su - Math.round(su)) * ${SP};
-  var dv = Math.abs(sv - Math.round(sv)) * ${SP};
-  var hw = ${hw};
-  var pU = Math.max(0, 1 - du / hw); pU *= pU;
-  var pV = Math.max(0, 1 - dv / hw); pV *= pV;
-  var checker = ((Math.round(su) & 65535) + (Math.round(sv) & 65535)) & 1;
-  var top = checker ? pV : pU;
-  var bot = checker ? pU : pV;
-  return -(top > bot * 0.15 ? top : bot * 0.15) * ${D2};
-})()`;
-  return new SurfacePattern(body);
+  const SP = requirePositiveFinite((options == null ? void 0 : options.spacing) ?? 3, "sdf.basketWeave() spacing");
+  const TW = requirePositiveFinite((options == null ? void 0 : options.threadWidth) ?? 1.5, "sdf.basketWeave() threadWidth");
+  const D2 = requireNonNegativeFinite((options == null ? void 0 : options.depth) ?? 0.8, "sdf.basketWeave() depth");
+  return pattern2d().overUnderWeave({ spacing: SP, threadWidth: TW, depth: D2 });
 }
 function fromFunction(fn, options) {
   if (!options || typeof options !== "object") {
@@ -36259,6 +37401,9 @@ function bend(shape, radius) {
 function repeat(shape, spacing, count) {
   return shape.repeat(spacing, count);
 }
+function circularArray(shape, count, offset2 = 0) {
+  return shape.circularArray(count, offset2);
+}
 function resolveTpmsOptions(options) {
   const wallThickness = options.wallThickness;
   const thickness = wallThickness ?? options.thickness;
@@ -36699,12 +37844,16 @@ const sdf = {
   weave,
   /** Basket weave surface pattern — threads with over-under crossings in UV space. Returns a SurfacePattern for use with `.surfaceDisplace()`. */
   basketWeave,
+  /** Create typed, composable 2D surface patterns for `.surfaceDisplace()`. */
+  pattern2d,
   /** Twist an SDF shape around the Z axis. */
   twist,
   /** Bend an SDF shape around the Z axis. */
   bend,
   /** Repeat an SDF shape in space. */
   repeat,
+  /** Arrange an SDF shape in a circular array around the Z axis with O(1) folded-domain evaluation. */
+  circularArray,
   /** A 2D surface pattern — a heightmap function for use with `.surfaceDisplace()`. */
   SurfacePattern,
   /** Create a custom SDF from one expression; shader-safe expressions raymarch directly. */
@@ -41638,13 +42787,16 @@ class SolvedAssembly {
    * @category Assembly
    */
   toGroup() {
+    var _a3;
     const children = [];
     const childNames = [];
-    for (const [name] of this.parts) {
+    const childTags = [];
+    for (const [name, rec] of this.parts) {
       children.push(this.getPart(name));
       childNames.push(name);
+      childTags.push(normalizeSceneTags((_a3 = rec.metadata) == null ? void 0 : _a3.tags, `Assembly part "${name}" metadata.tags`));
     }
-    return new ShapeGroup(children, childNames);
+    return new ShapeGroup(children, childNames, childTags);
   }
   /**
    * Return an array of named scene objects for the viewport renderer.
@@ -41678,17 +42830,18 @@ class SolvedAssembly {
       const used = usedByPart.get(partName);
       if (used && used.length > 0) markShapePortsUsed(shape, used);
     };
-    const appendGroupChildren = (grp, prefix, partName, out2) => {
+    const appendGroupChildren = (grp, prefix, partName, out2, inheritedTags = []) => {
       grp.children.forEach((child, index2) => {
         const childName = grp.childName(index2);
         const label = childName ? `${prefix}.${childName}` : `${prefix}.${index2 + 1}`;
+        const tags = mergeSceneTags(inheritedTags, grp.tagsForChild(index2));
         if (child instanceof ShapeGroup) {
-          appendGroupChildren(child, label, partName, out2);
+          appendGroupChildren(child, label, partName, out2, tags);
           return;
         }
         if (child instanceof Shape) {
           markUsedOnShape(child, partName);
-          out2.push({ name: label, shape: child });
+          out2.push({ name: label, shape: child, ...tags.length > 0 ? { tags } : {} });
         }
       });
     };
@@ -42054,7 +43207,7 @@ class Assembly {
    *
    * @param name - Unique part name (must not already exist)
    * @param part - The `Shape` or `ShapeGroup` geometry
-   * @param options - Optional `{ transform, metadata }` (material, process, qty, etc.)
+   * @param options - Optional `{ transform, metadata }` (material, process, qty, tags, etc.)
    * @returns `this` for chaining
    * @category Assembly
    */
@@ -43008,15 +44161,18 @@ class ImportedAssembly {
    * Any stored placement offset and placement references are forwarded to the group.
    */
   toGroup(state) {
+    var _a3;
     const solved = this._assembly.solve(state);
     const def = this._assembly.describe();
     const children = [];
     const childNames = [];
+    const childTags = [];
     for (const p2 of def.parts) {
       children.push(solved.getPart(p2.name));
       childNames.push(p2.name);
+      childTags.push(normalizeSceneTags((_a3 = p2.metadata) == null ? void 0 : _a3.tags, `Assembly part "${p2.name}" metadata.tags`));
     }
-    let result = new ShapeGroup(children, childNames);
+    let result = new ShapeGroup(children, childNames, childTags);
     const [dx, dy, dz] = this._offset;
     if (dx !== 0 || dy !== 0 || dz !== 0) {
       result = result.translate(dx, dy, dz);
@@ -43386,8 +44542,8 @@ function buildPure3mfBuffer(objects, options = {}) {
     for (let t = 0; t < numTri; t++) {
       const v1 = triVerts[t * 3];
       const v2 = triVerts[t * 3 + 1];
-      const v3 = triVerts[t * 3 + 2];
-      xmlParts.push(`          <triangle v1="${v1}" v2="${v2}" v3="${v3}" />`);
+      const v32 = triVerts[t * 3 + 2];
+      xmlParts.push(`          <triangle v1="${v1}" v2="${v2}" v3="${v32}" />`);
     }
     xmlParts.push("        </triangles>");
     xmlParts.push("      </mesh>");
@@ -43813,7 +44969,7 @@ class GCodeBuilder {
     this.lines.push("G1 E-0.8 F1800 ; retract");
     this.lines.push("");
     const safeZ = Math.min(maxZ + 5, p2.bedZ - 1);
-    this.lines.push(`G1 Z${f2(safeZ)} F900 ; lift nozzle above print`);
+    this.lines.push(`G1 Z${f$1(safeZ)} F900 ; lift nozzle above print`);
     this.lines.push("");
     this.lines.push("M140 S0 ; bed off");
     this.lines.push("M104 S0 ; hotend off");
@@ -43857,7 +45013,7 @@ class GCodeBuilder {
   travelTo(x2, y2, z2) {
     this.retract();
     const from = [...this.pos];
-    this.lines.push(`G0 X${f2(x2)} Y${f2(y2)} Z${f2(z2)} F${Math.round(this.profile.travelSpeed)}`);
+    this.lines.push(`G0 X${f$1(x2)} Y${f$1(y2)} Z${f$1(z2)} F${Math.round(this.profile.travelSpeed)}`);
     if (this.posInitialized) {
       this._segments.push({ from, to: [x2, y2, z2], extrude: false, speed: this.profile.travelSpeed });
     }
@@ -43889,7 +45045,7 @@ class GCodeBuilder {
     const beadArea = this.profile.layerHeight * this.profile.nozzle;
     const eIncrement = beadArea * dist4 / this.filamentArea;
     this.e += eIncrement;
-    this.lines.push(`G1 X${f2(x2)} Y${f2(y2)} Z${f2(z2)} E${f2(this.e)} F${Math.round(this.currentSpeed)}`);
+    this.lines.push(`G1 X${f$1(x2)} Y${f$1(y2)} Z${f$1(z2)} E${f$1(this.e)} F${Math.round(this.currentSpeed)}`);
     if (this.posInitialized) {
       this._segments.push({ from, to: [x2, y2, z2], extrude: true, speed: this.currentSpeed });
     }
@@ -43987,13 +45143,13 @@ class GCodeBuilder {
   retract() {
     if (this.retracted) return;
     this.e -= this.profile.retractionDistance;
-    this.lines.push(`G1 E${f2(this.e)} F${Math.round(this.profile.retractionSpeed)}`);
+    this.lines.push(`G1 E${f$1(this.e)} F${Math.round(this.profile.retractionSpeed)}`);
     this.retracted = true;
   }
   unretract() {
     if (!this.retracted) return;
     this.e += this.profile.retractionDistance;
-    this.lines.push(`G1 E${f2(this.e)} F${Math.round(this.profile.retractionSpeed)}`);
+    this.lines.push(`G1 E${f$1(this.e)} F${Math.round(this.profile.retractionSpeed)}`);
     this.retracted = false;
   }
   // ---- Bounds tracking ----
@@ -44064,7 +45220,7 @@ class GCodeBuilder {
     return this.lines.join("\n") + "\n";
   }
 }
-function f2(n) {
+function f$1(n) {
   return n.toFixed(5).replace(/\.?0+$/, "");
 }
 function bambuModelName(preset) {
@@ -46208,10 +47364,8 @@ class PathBuilder {
     if (radius <= 0) throw new Error("fillet: radius must be positive");
     const n = this.segs.length;
     if (n < 2) throw new Error("fillet: need at least 2 segments before a fillet");
-    const prev = this.segs[n - 2];
     const curr = this.segs[n - 1];
-    curr.kind === "line" || curr.kind === "move" ? prev.kind === "line" || prev.kind === "move" ? 0 : 0 : 0;
-    const { trimA, trimB, arcSeg } = this.computeFilletGeom(radius);
+    const { trimA, arcSeg } = this.computeFilletGeom(radius);
     if (!arcSeg) throw new Error("fillet: cannot fillet these segments (parallel or degenerate)");
     this.trimLastSegEnd(n - 2, trimA[0], trimA[1]);
     const trimmedSeg = { ...curr };
@@ -46283,7 +47437,6 @@ class PathBuilder {
   }
   getSegDirAt(seg, which) {
     if (seg.kind === "line" || seg.kind === "move") {
-      this.segs.length;
       const idx = this.segs.indexOf(seg);
       if (seg.kind === "line") {
         let sx, sy;
@@ -46525,6 +47678,41 @@ class PathBuilder {
     }
     return pts;
   }
+  /**
+   * Return the open path as a sampled 2D polyline.
+   *
+   * This is for construction geometry such as guide rails, measured centerlines,
+   * and curve-driven helpers where the authored path should stay open instead of
+   * becoming a filled sketch or stroked profile.
+   *
+   * **Example**
+   *
+   * ```ts
+   * const rail = path()
+   *   .moveTo(24, 0)
+   *   .bezierTo(32, 44, 28, 92, 18, 120)
+   *   .toPolyline();
+   * ```
+   *
+   * @returns A sampled open polyline.
+   * @category Path Builder
+   */
+  toPolyline() {
+    const moveCount = this.segs.filter((seg) => seg.kind === "move").length;
+    if (moveCount > 1) {
+      throw new Error("path().toPolyline() supports one continuous open path. Use separate path() builders for separate rails.");
+    }
+    const pts = [];
+    for (const point2 of this.tessellate()) {
+      if (!point2.every(Number.isFinite)) throw new Error("path().toPolyline() produced a non-finite point");
+      const previous = pts[pts.length - 1];
+      if (!previous || Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-9) {
+        pts.push(point2);
+      }
+    }
+    if (pts.length < 2) throw new Error("path().toPolyline() needs at least 2 points");
+    return pts;
+  }
   // ── Output ────────────────────────────────────────────────────────────────
   /**
    * Close the path and return a filled `Sketch`.
@@ -47575,7 +48763,8 @@ function explode(items, options = {}) {
         if (child instanceof ShapeGroup) return explodeGroup(child, p2, depth + 1, total, groupCenter, motion.branchDirection);
         return explodeLeaf(child, explodeAdd(total, leafMotion(child, p2, depth + 1, groupCenter, motion.branchDirection).offset));
       }),
-      grp.childNames
+      grp.childNames,
+      grp.children.map((_2, i) => grp.tagsForChild(i))
     );
   };
   const explodeItemNode = (item, path2, depth, inherited, parentCenter, parentDirection) => {
@@ -47611,7 +48800,8 @@ function explode(items, options = {}) {
         if (child instanceof ShapeGroup) return explodeGroup(child, p2, 1, [0, 0, 0], rootCenter, void 0);
         return explodeLeaf(child, nodeMotion(child, p2, 1, rootCenter, void 0).offset);
       }),
-      items.childNames
+      items.childNames,
+      items.children.map((_2, i) => items.tagsForChild(i))
     );
   }
   return items.map((item, i) => {
@@ -48380,6 +49570,398 @@ function spurGear(options) {
   });
   return attachGearMeta(shapeWithConnectors, meta2);
 }
+function requirePositive$7(scope, name, value) {
+  if (!isFinitePositive(value)) throw new Error(`${scope}: "${name}" must be > 0`);
+}
+function requireOptionalBore(scope, boreDiameter, maxDiameter) {
+  const bore = boreDiameter ?? 0;
+  if (!Number.isFinite(bore) || bore < 0) throw new Error(`${scope}: "boreDiameter" must be >= 0`);
+  if (bore > 0 && bore >= maxDiameter) throw new Error(`${scope}: bore is too large for the body`);
+  return bore;
+}
+function resolveSegments(segments) {
+  if (segments === void 0) return void 0;
+  if (!Number.isInteger(segments) || segments < 12) throw new Error('gear body: "segments" must be an integer >= 12');
+  return segments;
+}
+function cutBore$1(shape, boreDiameter) {
+  if (boreDiameter <= 0) return shape;
+  const bounds = shape.boundingBox();
+  const height = bounds.max[2] - bounds.min[2] + 2;
+  const cutter = cylinder(height, boreDiameter * 0.5, void 0, 64).translate(0, 0, bounds.min[2] - 1);
+  return shape.subtract(cutter);
+}
+function gearBodyDisk(options) {
+  requirePositive$7("gearBodyDisk", "outerRadius", options.outerRadius);
+  requirePositive$7("gearBodyDisk", "faceWidth", options.faceWidth);
+  const bore = requireOptionalBore("gearBodyDisk", options.boreDiameter, options.outerRadius * 2);
+  const segments = resolveSegments(options.segments);
+  const outer = circle2d(options.outerRadius, segments);
+  const profile = bore > 0 ? difference2d(outer, circle2d(bore * 0.5, segments)) : outer;
+  return sketchExtrude(profile, options.faceWidth);
+}
+function gearBodyDiskWithHub(options) {
+  requirePositive$7("gearBodyDiskWithHub", "hubDiameter", options.hubDiameter);
+  if (options.hubDiameter >= options.outerRadius * 2) {
+    throw new Error('gearBodyDiskWithHub: "hubDiameter" must be smaller than the outer diameter');
+  }
+  const bore = requireOptionalBore("gearBodyDiskWithHub", options.boreDiameter, options.hubDiameter);
+  const base = gearBodyDisk({ ...options, boreDiameter: 0 });
+  const hubFaceWidth = options.hubFaceWidth ?? options.faceWidth * 1.5;
+  requirePositive$7("gearBodyDiskWithHub", "hubFaceWidth", hubFaceWidth);
+  const hub = cylinder(hubFaceWidth, options.hubDiameter * 0.5, void 0, options.segments).translate(
+    0,
+    0,
+    (options.faceWidth - hubFaceWidth) * 0.5
+  );
+  return cutBore$1(base.add(hub), bore);
+}
+function gearBodySpoked(options) {
+  requirePositive$7("gearBodySpoked", "outerRadius", options.outerRadius);
+  requirePositive$7("gearBodySpoked", "faceWidth", options.faceWidth);
+  requirePositive$7("gearBodySpoked", "rimWidth", options.rimWidth);
+  requirePositive$7("gearBodySpoked", "hubDiameter", options.hubDiameter);
+  requirePositive$7("gearBodySpoked", "spokeWidth", options.spokeWidth);
+  if (!Number.isInteger(options.spokeCount) || options.spokeCount < 2) {
+    throw new Error('gearBodySpoked: "spokeCount" must be an integer >= 2');
+  }
+  const hubRadius = options.hubDiameter * 0.5;
+  const rimInnerRadius = options.outerRadius - options.rimWidth;
+  if (rimInnerRadius <= hubRadius) throw new Error("gearBodySpoked: rim overlaps the hub");
+  const bore = requireOptionalBore("gearBodySpoked", options.boreDiameter, options.hubDiameter);
+  const segments = resolveSegments(options.segments);
+  const rim = difference2d(circle2d(options.outerRadius, segments), circle2d(rimInnerRadius, segments));
+  const hub = circle2d(hubRadius, segments);
+  const spokeLength = rimInnerRadius - hubRadius + options.spokeWidth;
+  const spokeCenter = hubRadius + spokeLength * 0.5 - options.spokeWidth * 0.5;
+  const spoke = sketchTranslate(rect(spokeLength, options.spokeWidth), spokeCenter, 0);
+  const spokes = [];
+  for (let i = 0; i < options.spokeCount; i++) {
+    spokes.push(sketchRotateAround(spoke, 360 / options.spokeCount * i, [0, 0]));
+  }
+  const profile = bore > 0 ? difference2d(union2d(rim, hub, ...spokes), circle2d(bore * 0.5, segments)) : union2d(rim, hub, ...spokes);
+  return sketchExtrude(profile, options.faceWidth);
+}
+function gearBodyFromProfile(profile, options) {
+  if (!(profile instanceof Sketch)) throw new Error('gearBodyFromProfile: "profile" must be a Sketch');
+  requirePositive$7("gearBodyFromProfile", "faceWidth", options.faceWidth);
+  const bore = options.boreDiameter ?? 0;
+  if (!Number.isFinite(bore) || bore < 0) throw new Error('gearBodyFromProfile: "boreDiameter" must be >= 0');
+  return cutBore$1(sketchExtrude(profile, options.faceWidth), bore);
+}
+function requirePositive$6(scope, name, value) {
+  if (!isFinitePositive(value)) throw new Error(`${scope}: "${name}" must be > 0`);
+}
+function requireFiniteAngle(scope, name, value) {
+  if (value !== void 0 && !Number.isFinite(value)) throw new Error(`${scope}: "${name}" must be finite`);
+}
+function cutBore(shape, boreDiameter) {
+  if (boreDiameter <= 0) return shape;
+  const bounds = shape.boundingBox();
+  const height = bounds.max[2] - bounds.min[2] + 2;
+  const cutter = cylinder(height, boreDiameter * 0.5, void 0, 64).translate(0, 0, bounds.min[2] - 1);
+  return shape.subtract(cutter);
+}
+function bodyOuterRadius(shape) {
+  const bounds = shape.boundingBox();
+  return Math.max(Math.abs(bounds.min[0]), Math.abs(bounds.max[0]), Math.abs(bounds.min[1]), Math.abs(bounds.max[1]));
+}
+function buildSpurTeethRegion(options, name, faceWidth) {
+  const scope = "driveWheel.addSpurTeethBetween";
+  const teethOnFullCircle = options.teethOnFullCircle;
+  if (!Number.isInteger(teethOnFullCircle) || teethOnFullCircle < 6) {
+    throw new Error(`${scope}: "teethOnFullCircle" must be an integer >= 6`);
+  }
+  const toothCount = options.toothCount;
+  if (!Number.isInteger(toothCount) || toothCount < 1 || toothCount > teethOnFullCircle) {
+    throw new Error(`${scope}: "toothCount" must be an integer in [1, teethOnFullCircle]`);
+  }
+  const firstTooth = options.firstTooth ?? 0;
+  if (!Number.isInteger(firstTooth) || firstTooth < 0 || firstTooth >= teethOnFullCircle) {
+    throw new Error(`${scope}: "firstTooth" must be an integer in [0, teethOnFullCircle)`);
+  }
+  let normalized;
+  try {
+    normalized = normalizeSpurGearOptions({ ...options, teeth: teethOnFullCircle, faceWidth, boreDiameter: 0 });
+  } catch (error) {
+    remapErrorPrefix(error, "spurGear", scope);
+  }
+  const gearMeta = buildSpurGearMeta(normalized);
+  const pitchStepDeg = 360 / teethOnFullCircle;
+  const fromAngleDeg = firstTooth * pitchStepDeg - pitchStepDeg * 0.5;
+  const toAngleDeg = (firstTooth + toothCount - 1) * pitchStepDeg + pitchStepDeg * 0.5;
+  const profile = buildSpurToothRegionProfile(gearMeta, firstTooth, toothCount, normalized.segmentsPerTooth);
+  return {
+    shape: sketchExtrude(profile, faceWidth),
+    gearMeta,
+    meta: {
+      name,
+      kind: "spurTeeth",
+      fromAngleDeg,
+      toAngleDeg,
+      outerRadius: gearMeta.outerRadius,
+      rootRadius: gearMeta.rootRadius,
+      pitchRadius: gearMeta.pitchRadius,
+      module: normalized.module,
+      teethOnFullCircle,
+      toothCount,
+      faceWidth
+    }
+  };
+}
+function buildSolidArcRegion(options, name, faceWidth) {
+  const scope = "driveWheel.addSolidArcBetween";
+  requirePositive$6(scope, "outerRadius", options.outerRadius);
+  const innerRadius = options.innerRadius ?? 0;
+  if (!Number.isFinite(innerRadius) || innerRadius < 0) throw new Error(`${scope}: "innerRadius" must be >= 0`);
+  if (innerRadius >= options.outerRadius) throw new Error(`${scope}: "innerRadius" must be smaller than "outerRadius"`);
+  const sweepDeg = normalizedSweep(scope, options.fromAngleDeg, options.toAngleDeg);
+  return {
+    shape: sketchExtrude(buildSolidArcProfile(options, sweepDeg), faceWidth),
+    meta: {
+      name,
+      kind: "solidArc",
+      fromAngleDeg: options.fromAngleDeg,
+      toAngleDeg: options.fromAngleDeg + sweepDeg,
+      innerRadius,
+      outerRadius: options.outerRadius,
+      faceWidth
+    }
+  };
+}
+function normalizedSweep(scope, fromAngleDeg, toAngleDeg) {
+  if (!Number.isFinite(fromAngleDeg)) throw new Error(`${scope}: "fromAngleDeg" must be finite`);
+  if (!Number.isFinite(toAngleDeg)) throw new Error(`${scope}: "toAngleDeg" must be finite`);
+  let sweep2 = toAngleDeg - fromAngleDeg;
+  while (sweep2 <= 0) sweep2 += 360;
+  if (sweep2 > 360 + EPSILON$1) throw new Error(`${scope}: angular sweep must be <= 360 degrees`);
+  return Math.min(360, sweep2);
+}
+function buildSpurToothRegionProfile(meta2, firstTooth, toothCount, segmentsPerTooth) {
+  const tooth = createSpurToothSketch(meta2, segmentsPerTooth);
+  const teeth = [];
+  for (let i = 0; i < toothCount; i++) {
+    teeth.push(sketchRotateAround(tooth, 360 / meta2.teeth * (firstTooth + i), [0, 0]));
+  }
+  return union2d(...teeth);
+}
+function buildSolidArcProfile(options, sweepDeg) {
+  const innerRadius = options.innerRadius ?? 0;
+  const segments = options.segments ?? Math.max(16, Math.ceil(sweepDeg / 6));
+  if (!Number.isInteger(segments) || segments < 4) throw new Error('driveWheel.addSolidArcBetween: "segments" must be an integer >= 4');
+  if (Math.abs(sweepDeg - 360) < EPSILON$1) {
+    const outer = circle2d(options.outerRadius, segments);
+    return innerRadius > 0 ? difference2d(outer, circle2d(innerRadius, segments)) : outer;
+  }
+  const start = options.fromAngleDeg * Math.PI / 180;
+  const end = start + sweepDeg * Math.PI / 180;
+  const pts = [];
+  if (innerRadius <= 0) pts.push([0, 0]);
+  addArcPoints(pts, options.outerRadius, start, end, segments, true, true);
+  if (innerRadius > 0) addArcPoints(pts, innerRadius, end, start, segments, true, true);
+  return polygon(pts);
+}
+const DRIVE_WHEEL_META_KEY = Symbol.for("forgecad.library.driveWheelMeta");
+function attachDriveWheelMeta(shape, meta2) {
+  shape[DRIVE_WHEEL_META_KEY] = meta2;
+  return shape;
+}
+function readDriveWheelMeta(shape) {
+  const meta2 = shape[DRIVE_WHEEL_META_KEY];
+  return meta2 ?? null;
+}
+class DriveWheelBuilder {
+  constructor(options = {}) {
+    __publicField(this, "body");
+    __publicField(this, "faceWidth");
+    __publicField(this, "boreDiameter");
+    __publicField(this, "regions", []);
+    if (options.body !== void 0 && !(options.body instanceof Shape)) throw new Error('driveWheel: "body" must be a Shape');
+    if (options.faceWidth !== void 0) requirePositive$6("driveWheel", "faceWidth", options.faceWidth);
+    const boreDiameter = options.boreDiameter ?? 0;
+    if (!Number.isFinite(boreDiameter) || boreDiameter < 0) throw new Error('driveWheel: "boreDiameter" must be >= 0');
+    this.body = options.body;
+    this.faceWidth = options.faceWidth;
+    this.boreDiameter = boreDiameter;
+  }
+  /**
+   * Add an involute spur-tooth window on part of the pitch circle.
+   */
+  addSpurTeethBetween(options) {
+    const faceWidth = this.resolveFaceWidth("driveWheel.addSpurTeethBetween", options.faceWidth);
+    this.regions.push(buildSpurTeethRegion(options, this.resolveName("teeth", options.name), faceWidth));
+    return this;
+  }
+  /**
+   * Add a constant-radius solid arc region such as a dwell, stop, or pusher.
+   */
+  addSolidArcBetween(options) {
+    const faceWidth = this.resolveFaceWidth("driveWheel.addSolidArcBetween", options.faceWidth);
+    this.regions.push(buildSolidArcRegion(options, this.resolveName("arc", options.name), faceWidth));
+    return this;
+  }
+  /**
+   * Add a fully custom region shape while preserving region metadata.
+   */
+  addShapeRegion(name, shape, options = {}) {
+    const scope = "driveWheel.addShapeRegion";
+    if (typeof name !== "string" || name.trim().length === 0) throw new Error(`${scope}: "name" must be a non-empty string`);
+    if (!(shape instanceof Shape)) throw new Error(`${scope}: "shape" must be a Shape`);
+    requireFiniteAngle(scope, "fromAngleDeg", options.fromAngleDeg);
+    requireFiniteAngle(scope, "toAngleDeg", options.toAngleDeg);
+    if (options.innerRadius !== void 0 && (!Number.isFinite(options.innerRadius) || options.innerRadius < 0)) {
+      throw new Error(`${scope}: "innerRadius" must be >= 0`);
+    }
+    if (options.outerRadius !== void 0) requirePositive$6(scope, "outerRadius", options.outerRadius);
+    this.regions.push({
+      shape: shape.clone(),
+      meta: {
+        name: this.resolveName("region", name),
+        kind: "custom",
+        ...options
+      }
+    });
+    return this;
+  }
+  /**
+   * Build the final wheel shape with a bore connector and region metadata.
+   */
+  build() {
+    var _a3, _b3;
+    if (this.regions.length === 0 && this.body === void 0) {
+      throw new Error("driveWheel: add a body or at least one region before build()");
+    }
+    const faceWidth = this.resolveBuildFaceWidth();
+    const firstGearRegion = (_a3 = this.regions.find((region) => region.gearMeta)) == null ? void 0 : _a3.gearMeta;
+    if (firstGearRegion && this.boreDiameter * 0.5 >= firstGearRegion.rootRadius - EPSILON$1) {
+      throw new Error("driveWheel: bore is too large for the first spur-tooth region");
+    }
+    const body = ((_b3 = this.body) == null ? void 0 : _b3.clone()) ?? gearBodyDisk({ outerRadius: (firstGearRegion == null ? void 0 : firstGearRegion.rootRadius) ?? this.defaultBodyRadius(), faceWidth });
+    let combined = body;
+    for (const region of this.regions) combined = combined.add(region.shape);
+    combined = cutBore(combined, this.boreDiameter);
+    const withConnectors = combined.withConnectors({
+      bore: connectorFactory(
+        "drive-wheel-bore",
+        { origin: [0, 0, faceWidth / 2], axis: [0, 0, 1], kind: "revolute" },
+        this.measurements(faceWidth)
+      )
+    });
+    return attachDriveWheelMeta(withConnectors, {
+      kind: "driveWheel",
+      faceWidth,
+      boreDiameter: this.boreDiameter,
+      regions: this.regionMetadata(body, faceWidth)
+    });
+  }
+  measurements(faceWidth) {
+    var _a3;
+    const firstGearRegion = (_a3 = this.regions.find((region) => region.gearMeta)) == null ? void 0 : _a3.gearMeta;
+    return {
+      faceWidth,
+      boreDiameter: this.boreDiameter,
+      regionCount: this.regions.length,
+      ...firstGearRegion ? {
+        module: firstGearRegion.module,
+        teethOnFullCircle: firstGearRegion.teeth,
+        pitchRadius: firstGearRegion.pitchRadius,
+        outerRadius: firstGearRegion.outerRadius
+      } : {}
+    };
+  }
+  regionMetadata(body, faceWidth) {
+    return [
+      { name: "body", kind: "body", outerRadius: bodyOuterRadius(body), faceWidth },
+      ...this.regions.map((region) => ({ ...region.meta }))
+    ];
+  }
+  resolveFaceWidth(scope, localFaceWidth) {
+    const faceWidth = localFaceWidth ?? this.faceWidth;
+    if (faceWidth === void 0) throw new Error(`${scope}: "faceWidth" is required unless driveWheel({ faceWidth }) was set`);
+    requirePositive$6(scope, "faceWidth", faceWidth);
+    if (this.faceWidth !== void 0 && localFaceWidth !== void 0 && Math.abs(this.faceWidth - localFaceWidth) > EPSILON$1) {
+      throw new Error(`${scope}: region faceWidth must match driveWheel faceWidth`);
+    }
+    return faceWidth;
+  }
+  resolveBuildFaceWidth() {
+    var _a3;
+    const faceWidth = this.faceWidth ?? ((_a3 = this.regions.find((region) => region.meta.faceWidth !== void 0)) == null ? void 0 : _a3.meta.faceWidth);
+    if (faceWidth === void 0) throw new Error('driveWheel: "faceWidth" is required before build()');
+    return faceWidth;
+  }
+  defaultBodyRadius() {
+    const outerRadius = this.regions.reduce((max2, region) => Math.max(max2, region.meta.outerRadius ?? 0), 0);
+    if (outerRadius <= 0) throw new Error('driveWheel: "body" is required when regions do not define an outer radius');
+    return outerRadius;
+  }
+  resolveName(prefix, requested) {
+    const base = (requested == null ? void 0 : requested.trim()) || prefix;
+    if (this.regions.every((region) => region.meta.name !== base)) return base;
+    for (let i = 2; ; i++) {
+      const candidate = `${base}${i}`;
+      if (this.regions.every((region) => region.meta.name !== candidate)) return candidate;
+    }
+  }
+}
+function driveWheel(options = {}) {
+  return new DriveWheelBuilder(options);
+}
+function normalizeSectorGearOptions(options) {
+  const teethOnFullCircle = options.teethOnFullCircle;
+  if (!Number.isInteger(teethOnFullCircle) || teethOnFullCircle < 6) {
+    throw new Error('sectorGear: "teethOnFullCircle" must be an integer >= 6');
+  }
+  const toothCount = options.toothCount;
+  if (!Number.isInteger(toothCount) || toothCount < 1 || toothCount > teethOnFullCircle) {
+    throw new Error('sectorGear: "toothCount" must be an integer in [1, teethOnFullCircle]');
+  }
+  const firstTooth = options.firstTooth ?? 0;
+  if (!Number.isInteger(firstTooth) || firstTooth < 0 || firstTooth >= teethOnFullCircle) {
+    throw new Error('sectorGear: "firstTooth" must be an integer in [0, teethOnFullCircle)');
+  }
+  return {
+    ...normalizeSpurGearOptions({ ...options, teeth: teethOnFullCircle }),
+    teethOnFullCircle,
+    toothCount,
+    firstTooth,
+    boreDiameter: options.boreDiameter ?? 0
+  };
+}
+function sectorGear(options) {
+  const normalized = normalizeSectorGearOptions(options);
+  if (options.body !== void 0 && !(options.body instanceof Shape)) {
+    throw new Error('sectorGear: "body" must be a Shape');
+  }
+  const spurMeta = buildSpurGearMeta(normalized);
+  const pitchStepDeg = 360 / normalized.teethOnFullCircle;
+  const activeAngleStartDeg = normalized.firstTooth * pitchStepDeg - pitchStepDeg * 0.5;
+  const activeAngleEndDeg = (normalized.firstTooth + normalized.toothCount - 1) * pitchStepDeg + pitchStepDeg * 0.5;
+  const meta2 = {
+    ...spurMeta,
+    kind: "sector",
+    teethOnFullCircle: normalized.teethOnFullCircle,
+    firstTooth: normalized.firstTooth,
+    toothCount: normalized.toothCount,
+    activeAngleStartDeg,
+    activeAngleEndDeg
+  };
+  const wheel = driveWheel({ body: options.body, faceWidth: normalized.faceWidth, boreDiameter: normalized.boreDiameter }).addSpurTeethBetween({
+    name: "teeth",
+    module: normalized.module,
+    teethOnFullCircle: normalized.teethOnFullCircle,
+    toothCount: normalized.toothCount,
+    firstTooth: normalized.firstTooth,
+    pressureAngleDeg: normalized.pressureAngleDeg,
+    faceWidth: normalized.faceWidth,
+    backlash: normalized.backlash,
+    clearance: normalized.clearance,
+    addendum: normalized.addendum,
+    dedendum: normalized.dedendum,
+    segmentsPerTooth: normalized.segmentsPerTooth
+  }).build();
+  return attachGearMeta(wheel, meta2);
+}
 function normalizeSideGearOptions(options) {
   let normalizedSpur;
   try {
@@ -49359,6 +50941,12 @@ function boltPattern(options) {
     }
   };
 }
+const gearBodies = {
+  disk: gearBodyDisk,
+  diskWithHub: gearBodyDiskWithHub,
+  spoked: gearBodySpoked,
+  fromProfile: gearBodyFromProfile
+};
 function thread(diameter, pitch, length4, options) {
   const r = diameter / 2;
   const depth = (options == null ? void 0 : options.depth) ?? pitch * 0.35;
@@ -49524,7 +51112,23 @@ const partLibrary = {
   gearRatio,
   rackRatio,
   planetaryRatio,
-  boltPattern
+  boltPattern,
+  /** Start a composable exceptional gear or drive wheel. */
+  driveWheel,
+  /** Read functional-region metadata from a drive wheel shape. */
+  readDriveWheelMeta,
+  /** Involute sector gear with teeth on only part of the pitch circle. */
+  sectorGear,
+  /** Gear body preset namespace: disk, diskWithHub, spoked, and fromProfile. */
+  gearBodies,
+  /** Solid disk/ring gear body, independent from any tooth geometry. */
+  gearBodyDisk,
+  /** Disk gear body with a raised center hub. */
+  gearBodyDiskWithHub,
+  /** Spoked gear body with an outer rim, center hub, and radial spokes. */
+  gearBodySpoked,
+  /** Extrude a custom 2D profile into a gear body. */
+  gearBodyFromProfile
 };
 /**
  * @license
@@ -50881,7 +52485,7 @@ function requireFinite$7(value, label) {
   }
   return value;
 }
-function requireVec3$2(value, label) {
+function requireVec3$3(value, label) {
   if (!Array.isArray(value) || value.length !== 3) {
     throw new Error(`${label} must be [x, y, z]`);
   }
@@ -50925,7 +52529,7 @@ function normalizeOptions(options) {
     out.size = requireFinite$7(options.size, "Viewport.label options.size");
     if (out.size <= 0) throw new Error("Viewport.label options.size must be positive");
   }
-  if (options.offset !== void 0) out.offset = requireVec3$2(options.offset, "Viewport.label options.offset");
+  if (options.offset !== void 0) out.offset = requireVec3$3(options.offset, "Viewport.label options.offset");
   if (options.anchor !== void 0) {
     if (!VALID_ANCHORS.has(options.anchor)) {
       throw new Error(`Viewport.label options.anchor must be one of: ${Array.from(VALID_ANCHORS).join(", ")}`);
@@ -50942,7 +52546,7 @@ function collectRenderLabel(text, at, options) {
   if (typeof text !== "string" || text.trim().length === 0) {
     throw new Error("Viewport.label text must be a non-empty string");
   }
-  const normalizedAt = requireVec3$2(at, "Viewport.label at");
+  const normalizedAt = requireVec3$3(at, "Viewport.label at");
   const normalizedOptions = normalizeOptions(options);
   _collected$4.push({
     id: `render-label-${_nextId++}`,
@@ -51137,7 +52741,7 @@ function requireFinite$6(value, label) {
   }
   return value;
 }
-function requireVec3$1(value, label) {
+function requireVec3$2(value, label) {
   if (!Array.isArray(value) || value.length !== 3) {
     throw new Error(`${label} must be [x, y, z]`);
   }
@@ -51165,9 +52769,9 @@ const VALID_ENVIRONMENT_PRESETS = /* @__PURE__ */ new Set([
 ]);
 function validateCamera(cam, label) {
   const out = {};
-  if (cam.position !== void 0) out.position = requireVec3$1(cam.position, `${label}.position`);
-  if (cam.target !== void 0) out.target = requireVec3$1(cam.target, `${label}.target`);
-  if (cam.up !== void 0) out.up = requireVec3$1(cam.up, `${label}.up`);
+  if (cam.position !== void 0) out.position = requireVec3$2(cam.position, `${label}.position`);
+  if (cam.target !== void 0) out.target = requireVec3$2(cam.target, `${label}.target`);
+  if (cam.up !== void 0) out.up = requireVec3$2(cam.up, `${label}.up`);
   if (cam.fov !== void 0) {
     out.fov = requireFinite$6(cam.fov, `${label}.fov`);
     if (out.fov <= 0 || out.fov >= 180) throw new Error(`${label}.fov must be between 0 and 180`);
@@ -51302,8 +52906,8 @@ function validateLight(light, label) {
   const out = { type: light.type };
   if (light.color !== void 0) out.color = requireColor(light.color, `${label}.color`);
   if (light.intensity !== void 0) out.intensity = requireFinite$6(light.intensity, `${label}.intensity`);
-  if (light.position !== void 0) out.position = requireVec3$1(light.position, `${label}.position`);
-  if (light.target !== void 0) out.target = requireVec3$1(light.target, `${label}.target`);
+  if (light.position !== void 0) out.position = requireVec3$2(light.position, `${label}.position`);
+  if (light.target !== void 0) out.target = requireVec3$2(light.target, `${label}.target`);
   if (light.groundColor !== void 0) out.groundColor = requireColor(light.groundColor, `${label}.groundColor`);
   if (light.skyColor !== void 0) out.skyColor = requireColor(light.skyColor, `${label}.skyColor`);
   if (light.angle !== void 0) out.angle = requireFinite$6(light.angle, `${label}.angle`);
@@ -51849,7 +53453,7 @@ class ProductStationBuilder {
     this.profileValue = profileFromSketch(sketch, "custom", width, depth);
     return this;
   }
-  /** Stores a semantic crown amount for diagnostics and future rail solving. */
+  /** Set the station crown amount for soft product-section intent. */
   crown(amount) {
     if (!Number.isFinite(amount)) throw new Error("station.crown(amount) requires a finite number");
     this.crownValue = amount;
@@ -52835,7 +54439,7 @@ function scale$1(v, s) {
 function dot$2(a2, b) {
   return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
 }
-function lerp$2(a2, b, t) {
+function lerp$4(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function frameMatrix$1(x2, y2, z2, p2) {
@@ -52846,7 +54450,7 @@ function axisVector(axis, sign2 = 1) {
   if (axis === "Y") return [0, sign2, 0];
   return [0, 0, sign2];
 }
-function axisPosition(axis, point2) {
+function axisPosition$1(axis, point2) {
   return point2[AXIS_INDEX[axis]];
 }
 function crossPointForStation(axis, point2) {
@@ -52854,7 +54458,7 @@ function crossPointForStation(axis, point2) {
   if (axis === "Y") return [point2[0], -point2[2]];
   return [point2[1], point2[2]];
 }
-function orientLoftToAxis(shape, axis) {
+function orientLoftToAxis$1(shape, axis) {
   if (axis === "Z") return shape;
   if (axis === "Y") return shape.rotateX(-90);
   return shape.transform([0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1]);
@@ -52911,9 +54515,9 @@ function interpolateQuery(a2, b, t) {
   }
   return {
     side: sideA,
-    u: lerp$2(a2.u ?? 0.5, b.u ?? 0.5, t),
-    v: lerp$2(a2.v ?? 0.5, b.v ?? 0.5, t),
-    offset: lerp$2(a2.offset ?? 0, b.offset ?? 0, t)
+    u: lerp$4(a2.u ?? 0.5, b.u ?? 0.5, t),
+    v: lerp$4(a2.v ?? 0.5, b.v ?? 0.5, t),
+    offset: lerp$4(a2.offset ?? 0, b.offset ?? 0, t)
   };
 }
 function resolvePathQueries(points) {
@@ -52980,8 +54584,8 @@ class ProductSkin {
     this.stations = stations;
     this.rails = rails;
     for (const [name2, query] of Object.entries(refs)) this.refQueries.set(name2, cloneQuery(query));
-    this.axisMin = Math.min(...stations.map((station) => axisPosition(axis, station.center)));
-    this.axisMax = Math.max(...stations.map((station) => axisPosition(axis, station.center)));
+    this.axisMin = Math.min(...stations.map((station) => axisPosition$1(axis, station.center)));
+    this.axisMax = Math.max(...stations.map((station) => axisPosition$1(axis, station.center)));
     this.diagnosticsValue = {
       ...diagnostics,
       stationNames: stations.map((station) => station.name),
@@ -53038,24 +54642,24 @@ class ProductSkin {
   }
   /** Interpolate center, width, and depth at a normalized v or absolute axis value. */
   stationAt(vOrAxis) {
-    const axisValue = vOrAxis >= 0 && vOrAxis <= 1 ? lerp$2(this.axisMin, this.axisMax, vOrAxis) : clamp$5(vOrAxis, this.axisMin, this.axisMax);
+    const axisValue = vOrAxis >= 0 && vOrAxis <= 1 ? lerp$4(this.axisMin, this.axisMax, vOrAxis) : clamp$5(vOrAxis, this.axisMin, this.axisMax);
     const sorted = this.stations;
     for (let index2 = 0; index2 < sorted.length - 1; index2 += 1) {
       const a2 = sorted[index2];
       const b = sorted[index2 + 1];
-      const aAxis = axisPosition(this.axis, a2.center);
-      const bAxis = axisPosition(this.axis, b.center);
+      const aAxis = axisPosition$1(this.axis, a2.center);
+      const bAxis = axisPosition$1(this.axis, b.center);
       if (axisValue < aAxis - EPS$5 || axisValue > bAxis + EPS$5) continue;
       const span = Math.max(EPS$5, bAxis - aAxis);
       const t = clamp$5((axisValue - aAxis) / span, 0, 1);
       return {
         axisValue,
-        center: [lerp$2(a2.center[0], b.center[0], t), lerp$2(a2.center[1], b.center[1], t), lerp$2(a2.center[2], b.center[2], t)],
-        width: lerp$2(a2.profile.width, b.profile.width, t),
-        depth: lerp$2(a2.profile.depth, b.profile.depth, t),
+        center: [lerp$4(a2.center[0], b.center[0], t), lerp$4(a2.center[1], b.center[1], t), lerp$4(a2.center[2], b.center[2], t)],
+        width: lerp$4(a2.profile.width, b.profile.width, t),
+        depth: lerp$4(a2.profile.depth, b.profile.depth, t),
         dWidth: (b.profile.width - a2.profile.width) / span,
         dDepth: (b.profile.depth - a2.profile.depth) / span,
-        exponent: lerp$2(profileExponent(a2), profileExponent(b), t),
+        exponent: lerp$4(profileExponent(a2), profileExponent(b), t),
         kind: a2.profile.kind === b.profile.kind ? a2.profile.kind : "custom"
       };
     }
@@ -53177,10 +54781,10 @@ class ProductSkinBuilder {
   }
   /** Set named cross-section stations for the product skin. */
   stations(stations) {
-    this.stationsValue = stations.map(toStationSpec).sort((a2, b) => axisPosition(this.axisValue, a2.center) - axisPosition(this.axisValue, b.center));
+    this.stationsValue = stations.map(toStationSpec).sort((a2, b) => axisPosition$1(this.axisValue, a2.center) - axisPosition$1(this.axisValue, b.center));
     return this;
   }
-  /** Attach guide rails as ProductSkin IR metadata and diagnostics. */
+  /** Attach named guide rails for product-skin construction and downstream surface references. */
   rails(rails) {
     this.railsValue = { ...rails };
     return this;
@@ -53214,7 +54818,7 @@ class ProductSkinBuilder {
     this.edgeLengthValue = value;
     return this;
   }
-  /** Records a target wall thickness; v1 keeps exterior skin lowering sampled and reports wall as a diagnostic. */
+  /** Record intended wall thickness for product design metadata. Use explicit shelling when the model needs real inner-wall geometry. */
   wall(thickness) {
     if (!Number.isFinite(thickness) || thickness <= 0) throw new Error("Product.skin().wall(thickness) requires a positive finite number");
     this.wallValue = thickness;
@@ -53227,9 +54831,9 @@ class ProductSkinBuilder {
       const [x2, y2] = crossPointForStation(this.axisValue, station.center);
       return station.profile.sketch.translate(x2, y2);
     });
-    const heights = this.stationsValue.map((station) => axisPosition(this.axisValue, station.center));
+    const heights = this.stationsValue.map((station) => axisPosition$1(this.axisValue, station.center));
     let shape = loft(localProfiles, heights, { edgeLength: this.edgeLengthValue });
-    shape = orientLoftToAxis(shape, this.axisValue);
+    shape = orientLoftToAxis$1(shape, this.axisValue);
     if (this.colorValue) shape = shape.color(this.colorValue);
     shape = applyMaterial(shape, this.materialValue).as(this.name);
     const warnings = [];
@@ -53888,7 +55492,7 @@ function requirePositive$3(value, label) {
 function clamp$4(value, min2, max2) {
   return Math.max(min2, Math.min(max2, value));
 }
-function lerp$1(a2, b, t) {
+function lerp$3(a2, b, t) {
   return a2 + (b - a2) * t;
 }
 function add(a2, b) {
@@ -53938,19 +55542,19 @@ function transformLocal(point2, tangentAcross, normal, tangentAlong, x2, y2, z2
 function interpolateCylinder(a2, b, t, mode) {
   let delta = b.angle - a2.angle;
   if (mode === "shortest" && Math.abs(delta) > 180) delta -= Math.sign(delta) * 360;
-  return { kind: "cylinder", angle: a2.angle + delta * t, z: lerp$1(a2.z, b.z, t), offset: lerp$1(a2.offset ?? 0, b.offset ?? 0, t) };
+  return { kind: "cylinder", angle: a2.angle + delta * t, z: lerp$3(a2.z, b.z, t), offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t) };
 }
 function interpolatePlane(a2, b, t) {
-  return { kind: "plane", x: lerp$1(a2.x, b.x, t), y: lerp$1(a2.y, b.y, t), offset: lerp$1(a2.offset ?? 0, b.offset ?? 0, t) };
+  return { kind: "plane", x: lerp$3(a2.x, b.x, t), y: lerp$3(a2.y, b.y, t), offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t) };
 }
 function interpolateProductSkin(a2, b, t) {
   if ((a2.side ?? b.side) !== (b.side ?? a2.side)) throw new Error("SurfacePath on ProductSkin currently supports one side per path; split side transitions into separate members.");
   return {
     kind: "productSkin",
     side: a2.side ?? b.side,
-    u: lerp$1(a2.u ?? 0.5, b.u ?? 0.5, t),
-    v: lerp$1(a2.v ?? 0.5, b.v ?? 0.5, t),
-    offset: lerp$1(a2.offset ?? 0, b.offset ?? 0, t)
+    u: lerp$3(a2.u ?? 0.5, b.u ?? 0.5, t),
+    v: lerp$3(a2.v ?? 0.5, b.v ?? 0.5, t),
+    offset: lerp$3(a2.offset ?? 0, b.offset ?? 0, t)
   };
 }
 class SurfacePath {
@@ -54273,11 +55877,11 @@ function coordinateOnSide(coordinate, side, label) {
   return { ...coordinate, kind: "productSkin", side };
 }
 class ProductSkinCarrier {
-  constructor(skin, name = skin.name, sideValue, offsetValue = 0) {
+  constructor(skin, name = skin.name, sideValue2, offsetValue = 0) {
     __publicField(this, "kind", "productSkin");
     this.skin = skin;
     this.name = name;
-    this.sideValue = sideValue;
+    this.sideValue = sideValue2;
     this.offsetValue = offsetValue;
   }
   surface(side) {
@@ -55048,7 +56652,7 @@ function counterboresForPlate(spec2, width, height, thickness, diagnostics) {
 function minWidthAcrossAlongRange(widthAtT, length4, minAlong, maxAlong) {
   let minWidth = Number.POSITIVE_INFINITY;
   for (let index2 = 0; index2 <= 8; index2 += 1) {
-    const along = lerp$1(minAlong, maxAlong, index2 / 8);
+    const along = lerp$3(minAlong, maxAlong, index2 / 8);
     const t = Math.max(0, Math.min(1, (along + length4 / 2) / Math.max(length4, 1e-8)));
     minWidth = Math.min(minWidth, widthAtT(t));
   }
@@ -55348,7 +56952,7 @@ function pathParameterAtDistance(samples, distance2) {
     const segmentLength = Math.hypot(b.point[0] - a2.point[0], b.point[1] - a2.point[1], b.point[2] - a2.point[2]);
     if (traveled + segmentLength >= distance2) {
       const localT = segmentLength <= 1e-8 ? 0 : (distance2 - traveled) / segmentLength;
-      return lerp$1(a2.t, b.t, localT);
+      return lerp$3(a2.t, b.t, localT);
     }
     traveled += segmentLength;
   }
@@ -55401,7 +57005,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex <= acrossSegments; acrossIndex += 1) {
-      const across = lerp$1(-width / 2, width / 2, acrossIndex / acrossSegments);
+      const across = lerp$3(-width / 2, width / 2, acrossIndex / acrossSegments);
       mesh.vertices.push(pointAtProfile([across, along], false));
     }
   }
@@ -55411,7 +57015,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex <= acrossSegments; acrossIndex += 1) {
-      const across = lerp$1(-width / 2, width / 2, acrossIndex / acrossSegments);
+      const across = lerp$3(-width / 2, width / 2, acrossIndex / acrossSegments);
       mesh.vertices.push(pointAtProfile([across, along], true));
     }
   }
@@ -55423,7 +57027,7 @@ function compileBandFootprintMesh(path2, input) {
     const width = input.widthAt(t);
     const along = distance2 - length4 / 2;
     for (let acrossIndex = 0; acrossIndex < acrossSegments; acrossIndex += 1) {
-      const across = lerp$1(-width / 2, width / 2, (acrossIndex + 0.5) / acrossSegments);
+      const across = lerp$3(-width / 2, width / 2, (acrossIndex + 0.5) / acrossSegments);
       filled[alongIndex][acrossIndex] = !holes.some((hole2) => pointInProfileLoop([across, along], hole2));
     }
   }
@@ -56356,7 +57960,7 @@ class SurfaceMemberBuilder {
     this.record.features.push({ ...normalizeFeature(name, feature), type: "counterbore" });
     return this;
   }
-  /** Add a named anchor at a carrier surface coordinate for diagnostics, debug views, and future named-anchor joins. */
+  /** Add a named anchor at a carrier surface coordinate for explicit member joins. */
   anchorAt(name, coordinate) {
     if (!name.trim()) throw new Error("SurfaceMemberBuilder.anchorAt(name, coordinate) requires a non-empty name");
     const explicitAnchors = this.record.spec.explicitAnchors ?? [];
@@ -57505,7 +59109,7 @@ const Constraint = {
     return builder.constrain({ type: "length", line: resolveLineId(builder, line2), value });
   }
 };
-function requireVec3(v, label) {
+function requireVec3$1(v, label) {
   if (!Array.isArray(v) || v.length !== 3 || !Number.isFinite(v[0]) || !Number.isFinite(v[1]) || !Number.isFinite(v[2])) {
     throw new Error(`${label} must be a [number, number, number] with finite values, got ${JSON.stringify(v)}`);
   }
@@ -57518,24 +59122,24 @@ function requireFiniteNumber(n, label) {
   return n;
 }
 function distance$1(a2, b) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   return Math.hypot(b[0] - a2[0], b[1] - a2[1], b[2] - a2[2]);
 }
 function midpoint$1(a2, b) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   return [(a2[0] + b[0]) / 2, (a2[1] + b[1]) / 2, (a2[2] + b[2]) / 2];
 }
-function lerp(a2, b, t) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+function lerp$2(a2, b, t) {
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   requireFiniteNumber(t, "t");
   return [a2[0] + (b[0] - a2[0]) * t, a2[1] + (b[1] - a2[1]) * t, a2[2] + (b[2] - a2[2]) * t];
 }
 function direction(a2, b) {
-  requireVec3(a2, "a");
-  requireVec3(b, "b");
+  requireVec3$1(a2, "a");
+  requireVec3$1(b, "b");
   const dx = b[0] - a2[0];
   const dy = b[1] - a2[1];
   const dz = b[2] - a2[2];
@@ -57546,8 +59150,8 @@ function direction(a2, b) {
   return [dx / len2, dy / len2, dz / len2];
 }
 function offset(point2, dir, amount) {
-  requireVec3(point2, "point");
-  requireVec3(dir, "dir");
+  requireVec3$1(point2, "point");
+  requireVec3$1(dir, "dir");
   requireFiniteNumber(amount, "amount");
   return [point2[0] + dir[0] * amount, point2[1] + dir[1] * amount, point2[2] + dir[2] * amount];
 }
@@ -57557,7 +59161,7 @@ const Points = {
   /** Center point between two 3D points. */
   midpoint: midpoint$1,
   /** Linearly interpolate between two 3D points. t=0 returns a, t=1 returns b. */
-  lerp,
+  lerp: lerp$2,
   /** Unit direction vector from a to b. Throws if a and b are the same point. */
   direction,
   /** Move a point along a direction vector by a given amount. */
@@ -62689,9 +64293,84 @@ class ConstraintSketch extends Sketch {
    * Select the single arrangement region that contains the given seed point.
    * Throws if no region contains the seed.
    */
-  detectArrangementRegion(seed) {
+  detectArrangementRegion(_seed) {
     throw new Error("Not implemented");
   }
+  /**
+   * Return the solved constrained path as a sampled 2D polyline.
+   *
+   * Use this when a construction rail was authored with `constrainedSketch()`
+   * and should feed another operation such as `Loft.pathOnXz(...)`.
+   * The sketch must contain exactly one profile path.
+   *
+   * @param samples - Samples per curved segment. Default 32.
+   * @returns The solved path as an open polyline.
+   */
+  toPolyline(samples = 32) {
+    if (!Number.isFinite(samples) || samples < 2) throw new Error("ConstraintSketch.toPolyline() samples must be at least 2");
+    const profileLoops = this.definition.loops.filter((loop) => loop.type === "profile");
+    if (profileLoops.length !== 1) {
+      throw new Error("ConstraintSketch.toPolyline() requires exactly one profile path");
+    }
+    const sampleCount = Math.max(2, Math.round(samples));
+    const pointMap = new Map(this.definition.points.map((point2) => [point2.id, point2]));
+    const lineMap = new Map(this.definition.lines.map((line2) => [line2.id, line2]));
+    const arcMap = new Map(this.definition.arcs.map((arc) => [arc.id, arc]));
+    const bezierMap = new Map(this.definition.beziers.map((bezier) => [bezier.id, bezier]));
+    const points = [];
+    const appendStart = (point2, label) => {
+      const previous = points[points.length - 1];
+      if (!previous) {
+        points.push(point2);
+        return;
+      }
+      if (Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-6) {
+        throw new Error(`ConstraintSketch.toPolyline() profile path is not continuous at ${label}`);
+      }
+    };
+    const appendPoint = (point2) => {
+      const previous = points[points.length - 1];
+      if (!previous || Math.hypot(point2[0] - previous[0], point2[1] - previous[1]) > 1e-9) points.push(point2);
+    };
+    const requirePoint = (id, label) => {
+      const point2 = pointMap.get(id);
+      if (!point2) throw new Error(`ConstraintSketch.toPolyline() missing ${label}`);
+      return [point2.x, point2.y];
+    };
+    for (const segment of profileLoops[0].segments) {
+      if (segment.kind === "line") {
+        const line2 = lineMap.get(segment.line);
+        if (!line2) throw new Error(`ConstraintSketch.toPolyline() missing line "${segment.line}"`);
+        appendStart(requirePoint(line2.a, `line "${segment.line}" start point`), `line "${segment.line}"`);
+        appendPoint(requirePoint(line2.b, `line "${segment.line}" end point`));
+      } else if (segment.kind === "arc") {
+        const arc = arcMap.get(segment.arc);
+        if (!arc) throw new Error(`ConstraintSketch.toPolyline() missing arc "${segment.arc}"`);
+        const center = requirePoint(arc.center, `arc "${segment.arc}" center point`);
+        const start = requirePoint(arc.start, `arc "${segment.arc}" start point`);
+        const end = requirePoint(arc.end, `arc "${segment.arc}" end point`);
+        appendStart(start, `arc "${segment.arc}"`);
+        const startAngle = Math.atan2(start[1] - center[1], start[0] - center[0]);
+        const endAngle = Math.atan2(end[1] - center[1], end[0] - center[0]);
+        for (const point2 of tessellateArc(center[0], center[1], arc.radius, startAngle, endAngle, arc.clockwise, sampleCount)) {
+          appendPoint(point2);
+        }
+      } else {
+        const bezier = bezierMap.get(segment.bezier);
+        if (!bezier) throw new Error(`ConstraintSketch.toPolyline() missing bezier "${segment.bezier}"`);
+        const p0 = requirePoint(bezier.p0, `bezier "${segment.bezier}" start point`);
+        const p1 = requirePoint(bezier.p1, `bezier "${segment.bezier}" first control point`);
+        const p2 = requirePoint(bezier.p2, `bezier "${segment.bezier}" second control point`);
+        const p3 = requirePoint(bezier.p3, `bezier "${segment.bezier}" end point`);
+        appendStart(p0, `bezier "${segment.bezier}"`);
+        for (const point2 of tessellateBezier(p0[0], p0[1], p1[0], p1[1], p2[0], p2[1], p3[0], p3[1], sampleCount)) {
+          appendPoint(point2);
+        }
+      }
+    }
+    if (points.length < 2) throw new Error("ConstraintSketch.toPolyline() needs at least 2 points");
+    return points;
+  }
   /**
    * Re-solve the sketch after changing the value of one existing constraint.
    *
@@ -65818,8 +67497,8 @@ tinf_build_bits_base(dist_bits, dist_base, 2, 1);
 length_bits[28] = 0;
 length_base[28] = 258;
 var tinyInflate = tinf_uncompress;
-function derive(v0, v1, v2, v3, t) {
-  return Math.pow(1 - t, 3) * v0 + 3 * Math.pow(1 - t, 2) * t * v1 + 3 * (1 - t) * Math.pow(t, 2) * v2 + Math.pow(t, 3) * v3;
+function derive(v0, v1, v2, v32, t) {
+  return Math.pow(1 - t, 3) * v0 + 3 * Math.pow(1 - t, 2) * t * v1 + 3 * (1 - t) * Math.pow(t, 2) * v2 + Math.pow(t, 3) * v32;
 }
 function BoundingBox() {
   this.x1 = Number.NaN;
@@ -77976,6 +79655,295 @@ function polygonVertices(sides, radius, options) {
     centerY: options == null ? void 0 : options.centerY
   });
 }
+const LOFT_GUIDE_EPS = 1e-8;
+function orientLoftToAxis(shape, axis) {
+  if (axis === "Z") return shape;
+  if (axis === "Y") return shape.rotateX(-90);
+  return shape.transform([0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1]);
+}
+function buildRailEvaluators(rails, axis, start, end, railSamples) {
+  const seen = /* @__PURE__ */ new Set();
+  return rails.map((rail2) => {
+    if (seen.has(rail2.side)) throw new Error(`Loft.withGuideRails() received more than one ${rail2.side} rail`);
+    seen.add(rail2.side);
+    const sampled = sampleRailPath(rail2.path, railSamples);
+    if (sampled.length < 2) throw new Error("Loft guide rails require at least two points");
+    const points = sampled.map((point2) => ({ position: axisPosition(axis, point2), cross: crossPointForAxis(axis, point2) }));
+    const ordered = points[points.length - 1].position >= points[0].position ? points : [...points].reverse();
+    validateRailCoverage(ordered, start, end);
+    return { side: rail2.side, points: ordered };
+  });
+}
+function railCrossAt(rail2, position) {
+  const points = rail2.points;
+  if (position <= points[0].position + LOFT_GUIDE_EPS) return points[0].cross;
+  const last = points[points.length - 1];
+  if (position >= last.position - LOFT_GUIDE_EPS) return last.cross;
+  for (let index2 = 0; index2 < points.length - 1; index2 += 1) {
+    const a2 = points[index2];
+    const b = points[index2 + 1];
+    if (position >= a2.position - LOFT_GUIDE_EPS && position <= b.position + LOFT_GUIDE_EPS) {
+      const t = (position - a2.position) / (b.position - a2.position);
+      return [lerp$1(a2.cross[0], b.cross[0], t), lerp$1(a2.cross[1], b.cross[1], t)];
+    }
+  }
+  throw new Error("Loft guide rail does not cover requested station position");
+}
+function validateRailCoverage(points, start, end) {
+  for (let index2 = 1; index2 < points.length; index2 += 1) {
+    if (points[index2].position - points[index2 - 1].position < LOFT_GUIDE_EPS) {
+      throw new Error("Loft guide rails must be monotone along the loft axis");
+    }
+  }
+  if (points[0].position - start > LOFT_GUIDE_EPS || end - points[points.length - 1].position > LOFT_GUIDE_EPS) {
+    throw new Error("Loft guide rails must cover the full station range");
+  }
+}
+function sampleRailPath(path2, samples) {
+  if (Array.isArray(path2)) return path2.map((point2, index2) => requireVec3(point2, `Loft guide rail point ${index2}`));
+  if (path2 instanceof Curve3D || path2 instanceof HermiteCurve3D || path2 instanceof QuinticHermiteCurve3D || path2 instanceof NurbsCurve3D) {
+    return path2.sample(Math.max(2, Math.round(samples))).map((point2, index2) => requireVec3(point2, `Loft guide rail sample ${index2}`));
+  }
+  throw new Error("Loft guide rail path must be a Vec3[] or ForgeCAD 3D curve");
+}
+function requireVec3(point2, label) {
+  if (!Array.isArray(point2) || point2.length !== 3 || !point2.every(Number.isFinite)) {
+    throw new Error(`${label} must be a finite [x, y, z] point`);
+  }
+  return [point2[0], point2[1], point2[2]];
+}
+function axisPosition(axis, point2) {
+  if (axis === "X") return point2[0];
+  if (axis === "Y") return point2[1];
+  return point2[2];
+}
+function crossPointForAxis(axis, point2) {
+  if (axis === "X") return [point2[1], point2[2]];
+  if (axis === "Y") return [point2[0], -point2[2]];
+  return [point2[0], point2[1]];
+}
+function lerp$1(a2, b, t) {
+  return a2 + (b - a2) * t;
+}
+function loftWithGuideRails(stations, rails, options = {}) {
+  if (stations.length < 2) throw new Error("Loft.withGuideRails() requires at least two stations");
+  if (rails.length === 0) throw new Error("Loft.withGuideRails() requires at least one guide rail");
+  const sortedStations = sortedValidStations(stations);
+  const axis = options.axis ?? "Z";
+  const start = sortedStations[0].position;
+  const end = sortedStations[sortedStations.length - 1].position;
+  const railEvaluators = buildRailEvaluators(rails, axis, start, end, options.railSamples ?? 64);
+  const positions = generatedPositions(sortedStations, options.samples);
+  const profiles2 = positions.map((position) => {
+    const source = profileForPosition(sortedStations, position);
+    const bounds = boundsForPosition(sortedStations, position);
+    return fitProfileToBounds(source, applyRailsToBounds(bounds, railEvaluators, position));
+  });
+  const shape = loft(profiles2, positions, {
+    edgeLength: options.edgeLength,
+    boundsPadding: options.boundsPadding
+  });
+  return orientLoftToAxis(shape, axis);
+}
+function sortedValidStations(stations) {
+  const sorted = [...stations].sort((a2, b) => a2.position - b.position);
+  for (let index2 = 0; index2 < sorted.length; index2 += 1) {
+    if (!Number.isFinite(sorted[index2].position)) throw new Error("Loft.withGuideRails station position must be finite");
+    if (!(sorted[index2].profile instanceof Sketch)) throw new Error("Loft.withGuideRails() stations must use Sketch profiles");
+    if (index2 > 0 && sorted[index2].position - sorted[index2 - 1].position < LOFT_GUIDE_EPS) {
+      throw new Error("Loft.withGuideRails() requires unique, strictly increasing station positions");
+    }
+  }
+  return sorted;
+}
+function generatedPositions(stations, samples) {
+  const count = Math.max(2, Math.round(samples ?? Math.max(9, (stations.length - 1) * 8 + 1)));
+  const start = stations[0].position;
+  const end = stations[stations.length - 1].position;
+  const values = /* @__PURE__ */ new Set();
+  const positions = [];
+  const addPosition = (position) => {
+    const key = position.toFixed(9);
+    if (!values.has(key)) {
+      values.add(key);
+      positions.push(position);
+    }
+  };
+  for (let index2 = 0; index2 < count; index2 += 1) addPosition(start + (end - start) * index2 / (count - 1));
+  for (const station of stations) addPosition(station.position);
+  return positions.sort((a2, b) => a2 - b);
+}
+function profileForPosition(stations, position) {
+  for (let index2 = 0; index2 < stations.length - 1; index2 += 1) {
+    if (position <= stations[index2 + 1].position + LOFT_GUIDE_EPS) return stations[index2].profile;
+  }
+  return stations[stations.length - 1].profile;
+}
+function boundsForPosition(stations, position) {
+  if (position <= stations[0].position + LOFT_GUIDE_EPS) return sketchBounds(stations[0].profile);
+  const last = stations[stations.length - 1];
+  if (position >= last.position - LOFT_GUIDE_EPS) return sketchBounds(last.profile);
+  for (let index2 = 0; index2 < stations.length - 1; index2 += 1) {
+    const a2 = stations[index2];
+    const b = stations[index2 + 1];
+    if (position >= a2.position - LOFT_GUIDE_EPS && position <= b.position + LOFT_GUIDE_EPS) {
+      return lerpBounds(sketchBounds(a2.profile), sketchBounds(b.profile), (position - a2.position) / (b.position - a2.position));
+    }
+  }
+  return sketchBounds(last.profile);
+}
+function applyRailsToBounds(bounds, rails, position) {
+  const centerRail = rails.find((rail2) => rail2.side === "center");
+  const center = centerRail ? railCrossAt(centerRail, position) : void 0;
+  const next = { ...bounds };
+  applyAxisRail(next, "X", sideValue(rails, "left", position, 0), sideValue(rails, "right", position, 0), center == null ? void 0 : center[0]);
+  applyAxisRail(next, "Y", sideValue(rails, "back", position, 1), sideValue(rails, "front", position, 1), center == null ? void 0 : center[1]);
+  if (next.maxX - next.minX < LOFT_GUIDE_EPS || next.maxY - next.minY < LOFT_GUIDE_EPS) {
+    throw new Error("Loft.withGuideRails() guide rails produced a non-positive section size");
+  }
+  return next;
+}
+function sideValue(rails, side, position, crossIndex) {
+  const rail2 = rails.find((entry) => entry.side === side);
+  return rail2 ? railCrossAt(rail2, position)[crossIndex] : void 0;
+}
+function applyAxisRail(bounds, axis, minRail, maxRail, center) {
+  const minKey = axis === "X" ? "minX" : "minY";
+  const maxKey = axis === "X" ? "maxX" : "maxY";
+  const width = bounds[maxKey] - bounds[minKey];
+  if (minRail != null && maxRail != null) {
+    if (maxRail - minRail < LOFT_GUIDE_EPS) throw new Error("Loft.withGuideRails() opposite guide rails crossed");
+    if (center != null && Math.abs((minRail + maxRail) / 2 - center) > 1e-5) {
+      throw new Error("Loft.withGuideRails() center rail conflicts with opposite side rails");
+    }
+    bounds[minKey] = minRail;
+    bounds[maxKey] = maxRail;
+  } else if (maxRail != null) {
+    bounds[maxKey] = maxRail;
+    bounds[minKey] = center != null ? 2 * center - maxRail : maxRail - width;
+  } else if (minRail != null) {
+    bounds[minKey] = minRail;
+    bounds[maxKey] = center != null ? 2 * center - minRail : minRail + width;
+  } else if (center != null) {
+    bounds[minKey] = center - width / 2;
+    bounds[maxKey] = center + width / 2;
+  }
+}
+function fitProfileToBounds(profile, target) {
+  const source = sketchBounds(profile);
+  const sourceWidth = source.maxX - source.minX;
+  const sourceDepth = source.maxY - source.minY;
+  if (sourceWidth < LOFT_GUIDE_EPS || sourceDepth < LOFT_GUIDE_EPS) {
+    throw new Error("Loft.withGuideRails() station profiles must have positive bounds");
+  }
+  const sourceCenter = [(source.minX + source.maxX) / 2, (source.minY + source.maxY) / 2];
+  const targetCenter = [(target.minX + target.maxX) / 2, (target.minY + target.maxY) / 2];
+  return profile.scaleAround(sourceCenter, [(target.maxX - target.minX) / sourceWidth, (target.maxY - target.minY) / sourceDepth]).translate(targetCenter[0] - sourceCenter[0], targetCenter[1] - sourceCenter[1]);
+}
+function sketchBounds(profile) {
+  const bounds = profile.bounds();
+  return { minX: bounds.min[0], maxX: bounds.max[0], minY: bounds.min[1], maxY: bounds.max[1] };
+}
+function lerpBounds(a2, b, t) {
+  return {
+    minX: lerp(a2.minX, b.minX, t),
+    maxX: lerp(a2.maxX, b.maxX, t),
+    minY: lerp(a2.minY, b.minY, t),
+    maxY: lerp(a2.maxY, b.maxY, t)
+  };
+}
+function lerp(a2, b, t) {
+  return a2 + (b - a2) * t;
+}
+function mapLoftPath2D(path2, label, mapper) {
+  const points = sampleLoftPath2D(path2, label);
+  return points.map((point2, index2) => {
+    if (!Array.isArray(point2) || point2.length !== 2 || !point2.every(Number.isFinite)) {
+      throw new Error(`${label} point ${index2} must be a finite [x, y] point`);
+    }
+    return mapper([point2[0], point2[1]]);
+  });
+}
+function sampleLoftPath2D(path2, label) {
+  if (Array.isArray(path2)) {
+    if (path2.length < 2) throw new Error(`${label} requires at least two [x, y] points`);
+    return path2;
+  }
+  if (!path2 || typeof path2 !== "object" || typeof path2.toPolyline !== "function") {
+    throw new Error(`${label} requires a 2D path, solved constrained path, or [x, y] point array`);
+  }
+  const points = path2.toPolyline();
+  if (!Array.isArray(points) || points.length < 2) throw new Error(`${label} path must produce at least two [x, y] points`);
+  return points;
+}
+const Loft = {
+  /** Create a loft station from a 2D profile and an axis position. */
+  station(profile, position) {
+    if (!Number.isFinite(position)) throw new Error("Loft.station position must be finite");
+    return { profile, position };
+  },
+  /** Create a guide rail that constrains the section-local negative-X side. */
+  leftRail(path2) {
+    return { side: "left", path: path2 };
+  },
+  /** Create a guide rail that constrains the section-local positive-X side. */
+  rightRail(path2) {
+    return { side: "right", path: path2 };
+  },
+  /** Create a guide rail that constrains the section-local positive-Y side. */
+  frontRail(path2) {
+    return { side: "front", path: path2 };
+  },
+  /** Create a guide rail that constrains the section-local negative-Y side. */
+  backRail(path2) {
+    return { side: "back", path: path2 };
+  },
+  /** Create a guide rail that moves section centers along the loft. */
+  centerRail(path2) {
+    return { side: "center", path: path2 };
+  },
+  /**
+   * Place a 2D guide path onto the XZ plane.
+   *
+   * The path's first coordinate becomes X and its second coordinate becomes Z.
+   * Use this for left/right silhouette rails authored with `path()` or `constrainedSketch()`.
+   */
+  pathOnXz(path2, y2 = 0) {
+    if (!Number.isFinite(y2)) throw new Error("Loft.pathOnXz y must be finite");
+    return mapLoftPath2D(path2, "Loft.pathOnXz", ([x2, z2]) => [x2, y2, z2]);
+  },
+  /**
+   * Place a 2D guide path onto the YZ plane.
+   *
+   * The path's first coordinate becomes Y and its second coordinate becomes Z.
+   * Use this for front/back crown rails authored with `path()` or `constrainedSketch()`.
+   */
+  pathOnYz(path2, x2 = 0) {
+    if (!Number.isFinite(x2)) throw new Error("Loft.pathOnYz x must be finite");
+    return mapLoftPath2D(path2, "Loft.pathOnYz", ([y2, z2]) => [x2, y2, z2]);
+  },
+  /**
+   * Place a 2D guide path onto the XY plane.
+   *
+   * The path's first coordinate becomes X and its second coordinate becomes Y.
+   * Use this when lofting along X or Y and a rail lives in a horizontal sketch plane.
+   */
+  pathOnXy(path2, z2 = 0) {
+    if (!Number.isFinite(z2)) throw new Error("Loft.pathOnXy z must be finite");
+    return mapLoftPath2D(path2, "Loft.pathOnXy", ([x2, y2]) => [x2, y2, z2]);
+  },
+  /**
+   * Loft through profile stations while forcing generated sections to follow guide rails.
+   *
+   * Stations define the cross-section family. Guide rails define the side or center
+   * paths the loft must pass through. With opposite side rails, the section is scaled
+   * to touch both rails. With one side rail, the section keeps its interpolated size
+   * unless a center rail is also present.
+   */
+  withGuideRails(stations, rails, options = {}) {
+    return loftWithGuideRails(stations, rails, options);
+  }
+};
 let collectedHighlights = [];
 function resetHighlights() {
   collectedHighlights = [];
@@ -294630,6 +296598,7 @@ function classifySdfPreviewNode(node) {
     case "sdf:twist":
     case "sdf:bend":
     case "sdf:repeat":
+    case "sdf:circularArray":
     case "sdf:shell":
     case "sdf:onion":
       return classifySdfPreviewNode(node.child);
@@ -294639,10 +296608,7 @@ function classifySdfPreviewNode(node) {
         reason: "This SDF uses a custom JavaScript displacement function that cannot be compiled for raymarch preview."
       };
     case "sdf:surfaceDisplace":
-      return {
-        mode: "unsupported",
-        reason: "This SDF uses surface displacement that is not yet available in the raymarch shader."
-      };
+      return classifySurfaceDisplacePreviewNode(node);
     case "sdf:spatialBlend":
       return {
         mode: "unsupported",
@@ -294668,6 +296634,79 @@ ${node.shaderUnsupportedReason}` : ""}`
       };
   }
 }
+function classifySurfaceDisplacePreviewNode(node) {
+  if (!node.pattern) {
+    return {
+      mode: "unsupported",
+      reason: "This SDF uses a custom JavaScript surface pattern that cannot be compiled for raymarch preview."
+    };
+  }
+  const childResult = classifySdfPreviewNode(node.child);
+  if (childResult.mode !== "raymarch") return childResult;
+  const uv = analyzeShaderSurfaceUv(node.child, "p", node.uvMode);
+  if (uv.mode === "triplanar") {
+    return {
+      mode: "unsupported",
+      reason: "Typed surface displacement raymarch preview currently supports sphere, cylinder, and torus UV mappings."
+    };
+  }
+  return { mode: "raymarch" };
+}
+function f2(value) {
+  if (!Number.isFinite(value)) return "0.0";
+  const text = Number(value.toPrecision(9)).toString();
+  return text.includes(".") || text.includes("e") ? text : `${text}.0`;
+}
+function v3(value) {
+  return `vec3(${f2(value[0])}, ${f2(value[1])}, ${f2(value[2])})`;
+}
+function analyzeShaderSurfaceUv(node, p2, override) {
+  const analysis = analyzeShaderSurfaceUvNode(node, p2);
+  if (!override || override === "auto") return analysis;
+  if (override === "triplanar") return { mode: "triplanar" };
+  if (analysis.mode === "triplanar") return analysis;
+  if (override === analysis.mode) return analysis;
+  if (override === "sphere" || override === "cylinder") {
+    return { mode: override, localPoint: analysis.localPoint, radius: analysis.radius };
+  }
+  return analysis.mode === "torus" ? analysis : { mode: "triplanar" };
+}
+function analyzeShaderSurfaceUvNode(node, p2) {
+  switch (node.kind) {
+    case "sdf:sphere":
+      return { mode: "sphere", localPoint: p2, radius: node.radius };
+    case "sdf:cylinder":
+      return { mode: "cylinder", localPoint: p2, radius: node.radius };
+    case "sdf:torus":
+      return { mode: "torus", localPoint: p2, radius: node.minorRadius, majorRadius: node.majorRadius };
+    case "sdf:translate":
+      return analyzeShaderSurfaceUvNode(node.child, `(${p2} - ${v3(node.offset)})`);
+    case "sdf:rotate":
+      return analyzeShaderSurfaceUvNode(node.child, `rotateInvEuler(${p2}, ${v3(node.degrees)})`);
+    case "sdf:scale": {
+      const result = analyzeShaderSurfaceUvNode(node.child, `(${p2} / ${f2(node.factor)})`);
+      if (result.mode === "triplanar") return result;
+      return {
+        ...result,
+        radius: result.radius * node.factor,
+        ...result.mode === "torus" ? { majorRadius: result.majorRadius * node.factor } : {}
+      };
+    }
+    case "sdf:shell":
+      return analyzeShaderSurfaceUvNode(node.child, p2);
+    case "sdf:union":
+    case "sdf:smoothUnion":
+    case "sdf:intersection":
+    case "sdf:smoothIntersection":
+    case "sdf:difference":
+    case "sdf:smoothDifference":
+      return node.children.length > 0 ? analyzeShaderSurfaceUvNode(node.children[0], p2) : { mode: "triplanar" };
+    case "sdf:morph":
+      return analyzeShaderSurfaceUvNode(node.a, p2);
+    default:
+      return { mode: "triplanar" };
+  }
+}
 function describeScriptResultType(value) {
   var _a3, _b3;
   if (value == null) return String(value);
@@ -294728,7 +296767,7 @@ function mapScriptResultToScene(args) {
   var _a3;
   const objects = [];
   const shapeDimensions = [];
-  const pushShape = (shape, name, groupName, color, treePath) => {
+  const pushShape = (shape, name, groupName, color, treePath, tags = []) => {
     const objectId = `obj-${objects.length + 1}`;
     objects.push({
       id: objectId,
@@ -294739,7 +296778,8 @@ function mapScriptResultToScene(args) {
       materialProps: shape.materialProps,
       geometryInfo: shape.geometryInfo(),
       groupName,
-      treePath: treePath && treePath.length > 0 ? [...treePath] : [name]
+      treePath: treePath && treePath.length > 0 ? [...treePath] : [name],
+      ...tags.length > 0 ? { tags: [...tags] } : {}
     });
     const dims = getShapeDimensions(shape);
     dims.forEach((dim2) => {
@@ -294763,7 +296803,7 @@ function mapScriptResultToScene(args) {
       });
     }
   };
-  const pushSketch = (sketch, name, groupName, treePath) => {
+  const pushSketch = (sketch, name, groupName, treePath, tags = []) => {
     const meta2 = sketch instanceof ConstraintSketch ? sketch.constraintMeta : void 0;
     objects.push({
       id: `obj-${objects.length + 1}`,
@@ -294774,10 +296814,11 @@ function mapScriptResultToScene(args) {
       sketchMeta: meta2,
       color: sketch.colorHex,
       groupName,
-      treePath: treePath && treePath.length > 0 ? [...treePath] : [name]
+      treePath: treePath && treePath.length > 0 ? [...treePath] : [name],
+      ...tags.length > 0 ? { tags: [...tags] } : {}
     });
   };
-  const pushSdf = (sdfShape, name, groupName, treePath, color) => {
+  const pushSdf = (sdfShape, name, groupName, treePath, color, tags = []) => {
     const preview = classifySdfPreviewNode(sdfShape._node);
     const displayColor = color || sdfShape.colorHex;
     const data = {
@@ -294797,7 +296838,8 @@ function mapScriptResultToScene(args) {
       materialProps: sdfShape.materialProps,
       geometryInfo: null,
       groupName,
-      treePath: treePath && treePath.length > 0 ? [...treePath] : [name]
+      treePath: treePath && treePath.length > 0 ? [...treePath] : [name],
+      ...tags.length > 0 ? { tags: [...tags] } : {}
     });
   };
   const isNamedObject = (item) => {
@@ -294814,18 +296856,24 @@ function mapScriptResultToScene(args) {
   const rootGroupChildLabel = (grp, index2) => {
     return shapeGroupChildSegment(grp, index2, true);
   };
-  const flattenGroupChild = (child, label, groupName, treePath) => {
+  const flattenGroupChild = (child, label, groupName, treePath, tags = []) => {
     const resolvedTreePath = treePath && treePath.length > 0 ? treePath : [label];
     if (child instanceof ShapeGroup) {
       child.children.forEach((nested, i) => {
-        flattenGroupChild(nested, groupChildLabel(child, label, i), groupName, [...resolvedTreePath, shapeGroupChildSegment(child, i)]);
+        flattenGroupChild(
+          nested,
+          groupChildLabel(child, label, i),
+          groupName,
+          [...resolvedTreePath, shapeGroupChildSegment(child, i)],
+          mergeSceneTags(tags, child.tagsForChild(i))
+        );
       });
       return;
     }
     if (child instanceof Shape) {
-      pushShape(child, label, groupName, void 0, resolvedTreePath);
+      pushShape(child, label, groupName, void 0, resolvedTreePath, tags);
     } else if (child instanceof Sketch) {
-      pushSketch(child, label, groupName, resolvedTreePath);
+      pushSketch(child, label, groupName, resolvedTreePath, tags);
     }
   };
   const isPlainObject2 = (value) => {
@@ -294834,34 +296882,40 @@ function mapScriptResultToScene(args) {
     return proto2 === Object.prototype || proto2 === null;
   };
   const joinName = (path2) => path2.join(".");
-  const processRenderableTree = (value, fallbackLabel, fallbackSegment, parentGroup, parentTreePath = [], seen = /* @__PURE__ */ new WeakSet()) => {
+  const processRenderableTree = (value, fallbackLabel, fallbackSegment, parentGroup, parentTreePath = [], inheritedTags = [], seen = /* @__PURE__ */ new WeakSet()) => {
     const segment = fallbackSegment.trim().length > 0 ? fallbackSegment : fallbackLabel;
     const treePath = [...parentTreePath, segment];
     const name = joinName(treePath) || fallbackLabel;
     if (value instanceof Assembly) {
-      value.solve().toSceneObjects().forEach((item, index2) => processNamedItem(item, `${name}.${index2 + 1}`, `${index2 + 1}`, name, treePath));
+      value.solve().toSceneObjects().forEach((item, index2) => processNamedItem(item, `${name}.${index2 + 1}`, `${index2 + 1}`, name, treePath, inheritedTags));
       return;
     }
     if (value instanceof SolvedAssembly) {
-      value.toSceneObjects().forEach((item, index2) => processNamedItem(item, `${name}.${index2 + 1}`, `${index2 + 1}`, name, treePath));
+      value.toSceneObjects().forEach((item, index2) => processNamedItem(item, `${name}.${index2 + 1}`, `${index2 + 1}`, name, treePath, inheritedTags));
       return;
     }
     if (value instanceof ShapeGroup) {
       value.children.forEach((child, i) => {
-        flattenGroupChild(child, groupChildLabel(value, name, i), parentGroup, [...treePath, shapeGroupChildSegment(value, i)]);
+        flattenGroupChild(
+          child,
+          groupChildLabel(value, name, i),
+          parentGroup,
+          [...treePath, shapeGroupChildSegment(value, i)],
+          mergeSceneTags(inheritedTags, value.tagsForChild(i))
+        );
       });
       return;
     }
     if (value instanceof Shape) {
-      pushShape(value, name, parentGroup, void 0, treePath);
+      pushShape(value, name, parentGroup, void 0, treePath, inheritedTags);
       return;
     }
     if (value instanceof Sketch) {
-      pushSketch(value, name, parentGroup, treePath);
+      pushSketch(value, name, parentGroup, treePath, inheritedTags);
       return;
     }
     if (value instanceof SdfShape) {
-      pushSdf(value, name, parentGroup, treePath);
+      pushSdf(value, name, parentGroup, treePath, void 0, inheritedTags);
       return;
     }
     if (value instanceof GCodeBuilder) {
@@ -294872,7 +296926,8 @@ function mapScriptResultToScene(args) {
         sketch: null,
         toolpath: value.build(),
         geometryInfo: null,
-        treePath
+        treePath,
+        ...inheritedTags.length > 0 ? { tags: [...inheritedTags] } : {}
       });
       return;
     }
@@ -294882,30 +296937,38 @@ function mapScriptResultToScene(args) {
       value.forEach((item, index2) => {
         const childSegment = `${index2 + 1}`;
         const childLabel = `${name}.${childSegment}`;
-        processRenderableTree(item, childLabel, childSegment, parentGroup, treePath, seen);
+        processRenderableTree(item, childLabel, childSegment, parentGroup, treePath, inheritedTags, seen);
       });
       return;
     }
     if (isNamedObject(value)) {
-      processNamedItem(value, fallbackLabel, fallbackSegment, parentGroup, parentTreePath);
+      processNamedItem(value, fallbackLabel, fallbackSegment, parentGroup, parentTreePath, inheritedTags);
       return;
     }
     if (isPlainObject2(value)) {
       if (seen.has(value)) return;
       seen.add(value);
       Object.entries(value).forEach(([key, entry]) => {
-        processRenderableTree(entry, key, key, parentGroup, treePath, seen);
+        processRenderableTree(entry, key, key, parentGroup, treePath, inheritedTags, seen);
       });
     }
   };
-  const processNamedItem = (item, fallbackLabel, fallbackSegment, parentGroup, parentTreePath = []) => {
+  const processNamedItem = (item, fallbackLabel, fallbackSegment, parentGroup, parentTreePath = [], inheritedTags = []) => {
+    var _a4;
     const name = typeof item.name === "string" && item.name.trim().length > 0 ? item.name : fallbackLabel;
     const localSegment = typeof item.name === "string" && item.name.trim().length > 0 ? item.name : fallbackSegment;
     const treePath = [...parentTreePath, localSegment];
     const grp = parentGroup;
+    const tags = mergeSceneTags(inheritedTags, (_a4 = item.metadata) == null ? void 0 : _a4.tags, item.tags);
     if (item.group instanceof ShapeGroup) {
       item.group.children.forEach((child, i) => {
-        flattenGroupChild(child, groupChildLabel(item.group, name, i), name, [...treePath, shapeGroupChildSegment(item.group, i)]);
+        flattenGroupChild(
+          child,
+          groupChildLabel(item.group, name, i),
+          name,
+          [...treePath, shapeGroupChildSegment(item.group, i)],
+          mergeSceneTags(tags, item.group.tagsForChild(i))
+        );
       });
       return;
     }
@@ -294915,39 +296978,48 @@ function mapScriptResultToScene(args) {
         const childTreePath = [...treePath, `${i + 1}`];
         if (child instanceof ShapeGroup) {
           child.children.forEach((nested, nestedIndex) => {
-            flattenGroupChild(nested, groupChildLabel(child, name, nestedIndex), name, [
-              ...treePath,
-              shapeGroupChildSegment(child, nestedIndex)
-            ]);
+            flattenGroupChild(
+              nested,
+              groupChildLabel(child, name, nestedIndex),
+              name,
+              [...treePath, shapeGroupChildSegment(child, nestedIndex)],
+              mergeSceneTags(tags, child.tagsForChild(nestedIndex))
+            );
           });
         } else if (child instanceof Shape) {
-          pushShape(child, childLabel, name, void 0, childTreePath);
+          pushShape(child, childLabel, name, void 0, childTreePath, tags);
         } else if (child instanceof Sketch) {
-          pushSketch(child, childLabel, name, childTreePath);
+          pushSketch(child, childLabel, name, childTreePath, tags);
         } else if (child instanceof SdfShape) {
-          pushSdf(child, childLabel, name, childTreePath);
+          pushSdf(child, childLabel, name, childTreePath, void 0, tags);
         } else if (isNamedObject(child)) {
-          processNamedItem(child, childLabel, `${i + 1}`, name, treePath);
+          processNamedItem(child, childLabel, `${i + 1}`, name, treePath, tags);
         }
       });
       return;
     }
     if (item.shape instanceof ShapeGroup) {
       item.shape.children.forEach(
-        (child, i) => flattenGroupChild(child, groupChildLabel(item.shape, name, i), name, [...treePath, shapeGroupChildSegment(item.shape, i)])
+        (child, i) => flattenGroupChild(
+          child,
+          groupChildLabel(item.shape, name, i),
+          name,
+          [...treePath, shapeGroupChildSegment(item.shape, i)],
+          mergeSceneTags(tags, item.shape.tagsForChild(i))
+        )
       );
       return;
     }
     if (item.shape instanceof Shape) {
-      pushShape(item.shape, name, grp, item.color, treePath);
+      pushShape(item.shape, name, grp, item.color, treePath, tags);
       return;
     }
     if (item.shape instanceof SdfShape) {
-      pushSdf(item.shape, name, grp, treePath, item.color);
+      pushSdf(item.shape, name, grp, treePath, item.color, tags);
       return;
     }
     if (item.sdf instanceof SdfShape) {
-      pushSdf(item.sdf, name, grp, treePath, item.color);
+      pushSdf(item.sdf, name, grp, treePath, item.color, tags);
       return;
     }
     if (item.sketch instanceof Sketch) {
@@ -294961,7 +297033,8 @@ function mapScriptResultToScene(args) {
         sketchMeta: meta2,
         color: item.color || item.sketch.colorHex,
         groupName: grp,
-        treePath
+        treePath,
+        ...tags.length > 0 ? { tags: [...tags] } : {}
       });
     }
   };
@@ -294975,14 +297048,20 @@ function mapScriptResultToScene(args) {
   } else if (result instanceof ShapeGroup) {
     result.children.forEach((child, i) => {
       const label = rootGroupChildLabel(result, i);
-      flattenGroupChild(child, label, void 0, [label]);
+      flattenGroupChild(child, label, void 0, [label], result.tagsForChild(i));
     });
   } else if (Array.isArray(result)) {
     result.forEach((item, index2) => {
       const label = `Object ${index2 + 1}`;
       if (item instanceof ShapeGroup) {
         item.children.forEach((child, i) => {
-          flattenGroupChild(child, groupChildLabel(item, label, i), void 0, [label, shapeGroupChildSegment(item, i)]);
+          flattenGroupChild(
+            child,
+            groupChildLabel(item, label, i),
+            void 0,
+            [label, shapeGroupChildSegment(item, i)],
+            item.tagsForChild(i)
+          );
         });
         return;
       }
@@ -295015,7 +297094,7 @@ function mapScriptResultToScene(args) {
       } else if (defaultValue instanceof ShapeGroup) {
         defaultValue.children.forEach((child, i) => {
           const label = rootGroupChildLabel(defaultValue, i);
-          flattenGroupChild(child, label, void 0, [label]);
+          flattenGroupChild(child, label, void 0, [label], defaultValue.tagsForChild(i));
         });
       } else if (defaultValue instanceof Shape) {
         pushShape(defaultValue, args.fileName, void 0, void 0, [args.fileName]);
@@ -295061,7 +297140,8 @@ function mapScriptResultToScene(args) {
       name: `${mock2.name} (mock)`,
       shape: mock2.shape,
       sketch: null,
-      mock: true
+      mock: true,
+      tags: ["mock"]
     });
   }
   const hasSdfLeaves = objects.some((obj) => obj.sdf);
@@ -295332,6 +297412,7 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       nurbsSurface,
       spline2d,
       spline3d,
+      Loft,
       loft,
       loftAlongSpine,
       sweep,
@@ -296189,7 +298270,8 @@ function serializeRunResult(result, solverDebug = null) {
       geometryInfo: obj.geometryInfo,
       sketchMeta: obj.sketchMeta,
       groupName: obj.groupName,
-      treePath: obj.treePath
+      treePath: obj.treePath,
+      tags: obj.tags
     };
     if (serialized2.shapeData) {
       transferables.push(
@@ -296235,6 +298317,7 @@ function serializeRunMetadata(result) {
       sketchMeta: obj.sketchMeta,
       groupName: obj.groupName,
       treePath: obj.treePath,
+      tags: obj.tags,
       mock: obj.mock,
       serverShapeRef: obj.serverShapeRef,
       exactState: obj.exactState