forgecad 0.9.4 → 0.9.5

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

@@ -620,6 +620,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
@@ -670,6 +711,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":
@@ -683,6 +726,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 } : {},
@@ -4724,7 +4768,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)
@@ -4824,7 +4868,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)];
@@ -4845,8 +4889,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
@@ -5698,9 +5742,9 @@ function parse3mf(data) {
     let tMatch;
     while ((tMatch = trianglePattern.exec(meshXml)) !== null) {
       const v1 = parseInt(tMatch[1], 10) + vertexOffset;
-      const v2 = parseInt(tMatch[2], 10) + vertexOffset;
+      const v22 = parseInt(tMatch[2], 10) + vertexOffset;
       const v32 = parseInt(tMatch[3], 10) + vertexOffset;
-      allTriIndices.push(v1, v2, v32);
+      allTriIndices.push(v1, v22, v32);
     }
     for (let i = 0; i < meshVerts.length; i++) {
       allPositions.push(meshVerts[i]);
@@ -6083,6 +6127,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$1(...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$1(...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$1).join(",")}]-[${bounds.max.map(formatNumber$1).join(",")}]`;
+}
+function formatMm(value) {
+  return `${formatNumber$1(value)}mm`;
+}
+function formatNumber$1(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,
@@ -6543,8 +6868,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) {
@@ -6571,10 +6896,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);
@@ -6631,7 +6956,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];
       };
@@ -6651,23 +6976,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),
@@ -6676,24 +7001,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),
@@ -6702,12 +7027,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,
@@ -6730,8 +7055,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;
@@ -6827,76 +7152,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(px2, py2, pz2, r) {
-  return length3(px2, py2, pz2) - r;
+function sdSphere$1(px2, py2, pz2, r) {
+  return length3$1(px2, py2, pz2) - r;
 }
-function sdBox(px2, py2, pz2, hx, hy, hz) {
+function sdBox$1(px2, py2, pz2, hx, hy, hz) {
   const dx = abs(px2) - hx;
   const dy = abs(py2) - hy;
   const dz = abs(pz2) - 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(px2, py2, pz2, h, r) {
-  const dx = length2(px2, py2) - r;
+function sdCylinder$1(px2, py2, pz2, h, r) {
+  const dx = length2$1(px2, py2) - r;
   const dz = abs(pz2) - 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(px2, py2, pz2, R, r) {
-  const qx = length2(px2, py2) - R;
-  return length2(qx, pz2) - r;
+function sdTorus$1(px2, py2, pz2, R, r) {
+  const qx = length2$1(px2, py2) - R;
+  return length2$1(qx, pz2) - r;
 }
-function sdCapsule(px2, py2, pz2, h, r) {
+function sdCapsule$1(px2, py2, pz2, h, r) {
   const halfH = h * 0.5;
   const cz = clamp$a(pz2, -halfH, halfH);
-  return length3(px2, py2, pz2 - cz) - r;
+  return length3$1(px2, py2, pz2 - cz) - r;
 }
-function sdCone(px2, py2, pz2, h, r) {
-  const q = length2(px2, py2);
-  const cLen = length2(h, r);
+function sdCone$1(px2, py2, pz2, h, r) {
+  const q = length2$1(px2, py2);
+  const cLen = length2$1(h, r);
   const nx = h / cLen;
   const nz = -r / cLen;
-  const d2 = max(nx * q + nz * (pz2 - h), -pz2, pz2 - h);
+  const d2 = max$1(nx * q + nz * (pz2 - h), -pz2, pz2 - h);
   return d2;
 }
-function sdTaperedSegment(px2, py2, pz2, ax, ay, az, bx, by, bz, ra, rb) {
+function sdTaperedSegment$1(px2, py2, pz2, 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(px2 - ax, py2 - ay, pz2 - az, max(ra, rb));
+  if (len2 <= 1e-12) return sdSphere$1(px2 - ax, py2 - ay, pz2 - az, max$1(ra, rb));
   const h = clamp$a(((px2 - ax) * vx + (py2 - ay) * vy + (pz2 - az) * vz) / len2, 0, 1);
-  return length3(px2 - (ax + vx * h), py2 - (ay + vy * h), pz2 - (az + vz * h)) - (ra + (rb - ra) * h);
+  return length3$1(px2 - (ax + vx * h), py2 - (ay + vy * h), pz2 - (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;
@@ -6905,31 +7230,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);
@@ -6946,7 +7378,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;
       };
     }
@@ -6954,7 +7386,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;
       };
     }
@@ -6963,7 +7395,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;
       };
     }
@@ -6972,7 +7404,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;
       };
     }
@@ -6981,7 +7413,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;
       };
     }
@@ -6999,10 +7431,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;
@@ -7021,10 +7453,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);
       };
     }
@@ -7033,7 +7465,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);
       };
     }
@@ -7041,7 +7473,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);
@@ -7058,10 +7502,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);
@@ -7073,7 +7514,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;
@@ -7084,9 +7525,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;
       };
     }
@@ -7156,7 +7597,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;
@@ -7218,7 +7659,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);
@@ -7249,7 +7690,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": {
@@ -7263,7 +7704,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": {
@@ -7284,16 +7725,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);
@@ -7330,7 +7784,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);
@@ -7343,7 +7797,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]);
     }
   }
@@ -7359,242 +7813,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$1(b, node.children, x2, y2, z2, (a2, child) => b.min(a2, child));
+    case "sdf:difference":
+      return foldChildren$1(b, node.children, x2, y2, z2, (a2, child) => b.max(a2, b.neg(child)));
+    case "sdf:intersection":
+      return foldChildren$1(b, node.children, x2, y2, z2, (a2, child) => b.max(a2, child));
+    case "sdf:smoothUnion":
+      return foldChildren$1(b, node.children, x2, y2, z2, (a2, child) => smin(b, a2, child, node.radius));
+    case "sdf:smoothDifference":
+      return foldChildren$1(b, node.children, x2, y2, z2, (a2, child) => smax(b, a2, b.neg(child), node.radius));
+    case "sdf:smoothIntersection":
+      return foldChildren$1(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$1(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));
-}
-function formatBounds(bounds) {
-  return `[${bounds.min.map(formatNumber$1).join(",")}]-[${bounds.max.map(formatNumber$1).join(",")}]`;
-}
-function formatMm(value) {
-  return `${formatNumber$1(value)}mm`;
+  const builder = new SdfProgramBuilder();
+  return builder.finalize(emitSdfProgramNode(builder, node, builder.x, builder.y, builder.z));
 }
-function formatNumber$1(value) {
-  return Number.isInteger(value) ? String(value) : value.toFixed(3).replace(/0+$/, "").replace(/\.$/, "");
+function compileSdfProgram3(node) {
+  return compileSdfProgramEvaluator3(compileSdfProgram(node));
 }
-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`;
+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];
@@ -8060,7 +8816,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) {
@@ -8070,11 +8826,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) {
@@ -8093,10 +8849,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]");
   }
@@ -8108,8 +8864,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];
   });
@@ -8132,8 +8888,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]`);
     }
@@ -8144,7 +8900,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);
@@ -8152,7 +8908,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]) {
@@ -8332,16 +9088,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`);
       }
     }
@@ -9730,24 +10486,24 @@ function stitchSingleLoopLoft(loops, heights, wasm) {
       const j1 = (j + 1) % N;
       const v0 = baseIdx + j;
       const v1 = nextIdx + j;
-      const v2 = nextIdx + j1;
+      const v22 = nextIdx + j1;
       const v32 = baseIdx + j1;
-      triangles.push(v0, v32, v2);
-      triangles.push(v0, v2, v1);
+      triangles.push(v0, v32, v22);
+      triangles.push(v0, v22, v1);
     }
   }
   const bottomResampled2D = resampled[0].map(([x2, y2]) => [x2, y2]);
   const bottomTrisResampled = wasm.triangulate([bottomResampled2D]);
   for (const tri of bottomTrisResampled) {
-    const [v0, v1, v2] = Array.isArray(tri) ? tri : [tri[0], tri[1], tri[2]];
-    triangles.push(v0, v2, v1);
+    const [v0, v1, v22] = Array.isArray(tri) ? tri : [tri[0], tri[1], tri[2]];
+    triangles.push(v0, v22, v1);
   }
   const topResampled2D = resampled[resampled.length - 1].map(([x2, y2]) => [x2, y2]);
   const topTrisResampled = wasm.triangulate([topResampled2D]);
   const topStartIdx = (resampled.length - 1) * N;
   for (const tri of topTrisResampled) {
-    const [v0, v1, v2] = Array.isArray(tri) ? tri : [tri[0], tri[1], tri[2]];
-    triangles.push(topStartIdx + v0, topStartIdx + v1, topStartIdx + v2);
+    const [v0, v1, v22] = Array.isArray(tri) ? tri : [tri[0], tri[1], tri[2]];
+    triangles.push(topStartIdx + v0, topStartIdx + v1, topStartIdx + v22);
   }
   const mesh = new wasm.Mesh({
     numProp: 3,
@@ -9774,7 +10530,7 @@ async function initManifoldWasm() {
   if (_wasm$1) return _wasm$1;
   performance.mark("manifold:start");
   const Module = (await __vitePreload(async () => {
-    const { default: __vite_default__ } = await import("./manifold-lru0jwVw.js");
+    const { default: __vite_default__ } = await import("./manifold-CRoBhJKH.js");
     return { default: __vite_default__ };
   }, true ? [] : void 0)).default;
   performance.mark("manifold:imported");
@@ -10057,10 +10813,10 @@ function stitchLoopAlongPath(loop, _path, frames, wasm) {
       const j1 = (j + 1) % N;
       const v0 = baseIdx + j;
       const v1 = nextIdx + j;
-      const v2 = nextIdx + j1;
+      const v22 = nextIdx + j1;
       const v32 = baseIdx + j1;
-      triangles.push(v0, v32, v2);
-      triangles.push(v0, v2, v1);
+      triangles.push(v0, v32, v22);
+      triangles.push(v0, v22, v1);
     }
   }
   const bottomPts = resampled.map(([u2, v]) => [u2, v]);
@@ -11405,8 +12161,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);
@@ -11424,8 +12188,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);
@@ -16846,9 +17614,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;
@@ -19750,7 +20518,7 @@ function requireClipper() {
 }
 var clipperExports = requireClipper();
 const ClipperLib = /* @__PURE__ */ getDefaultExportFromCjs(clipperExports);
-let f$2 = 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;
   }
@@ -19759,7 +20527,7 @@ function d(n, t) {
   return n > t ? 1 : n < t ? -1 : 0;
 }
 function u$1(n, t, e) {
-  const r = new f$2(null, null);
+  const r = new f$3(null, null);
   let l = r, i = r;
   for (; ; ) {
     const o = e(n, t.key);
@@ -19782,7 +20550,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$2(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);
@@ -19823,7 +20591,7 @@ class z {
    * Adds a key, if it is not present in the tree
    */
   add(t, e) {
-    const r = new f$2(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;
@@ -20036,23 +20804,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$2(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$2(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$2(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$2(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;
@@ -20067,7 +20835,7 @@ function p(n, t, e) {
   return null;
 }
 function y(n, t, e) {
-  const r = new f$2(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;
@@ -20459,21 +21227,21 @@ const verticalIntersection = (pt, v, x2) => {
     y: pt.y + v.y / v.x * (x2 - pt.x)
   };
 };
-const intersection$1 = (pt1, v1, pt2, v2) => {
-  if (v1.x === 0) return verticalIntersection(pt2, v2, pt1.x);
-  if (v2.x === 0) return verticalIntersection(pt1, v1, pt2.x);
-  if (v1.y === 0) return horizontalIntersection(pt2, v2, pt1.y);
-  if (v2.y === 0) return horizontalIntersection(pt1, v1, pt2.y);
-  const kross = crossProduct(v1, v2);
+const intersection$1 = (pt1, v1, pt2, v22) => {
+  if (v1.x === 0) return verticalIntersection(pt2, v22, pt1.x);
+  if (v22.x === 0) return verticalIntersection(pt1, v1, pt2.x);
+  if (v1.y === 0) return horizontalIntersection(pt2, v22, pt1.y);
+  if (v22.y === 0) return horizontalIntersection(pt1, v1, pt2.y);
+  const kross = crossProduct(v1, v22);
   if (kross == 0) return null;
   const ve = {
     x: pt2.x - pt1.x,
     y: pt2.y - pt1.y
   };
   const d1 = crossProduct(ve, v1) / kross;
-  const d2 = crossProduct(ve, v2) / kross;
-  const x1 = pt1.x + d2 * v1.x, x2 = pt2.x + d1 * v2.x;
-  const y1 = pt1.y + d2 * v1.y, y2 = pt2.y + d1 * v2.y;
+  const d2 = crossProduct(ve, v22) / kross;
+  const x1 = pt1.x + d2 * v1.x, x2 = pt2.x + d1 * v22.x;
+  const y1 = pt1.y + d2 * v1.y, y2 = pt2.y + d1 * v22.y;
   const x3 = (x1 + x2) / 2;
   const y3 = (y1 + y2) / 2;
   return {
@@ -25055,7 +25823,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);
@@ -25067,14 +25841,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)}`
@@ -25438,7 +26216,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(
@@ -29668,16 +30448,16 @@ function clusterMeshFaces(shape) {
     const i2 = triVerts[i * 3 + 2];
     const v0 = [vertProperties[i0 * numProp], vertProperties[i0 * numProp + 1], vertProperties[i0 * numProp + 2]];
     const v1 = [vertProperties[i1 * numProp], vertProperties[i1 * numProp + 1], vertProperties[i1 * numProp + 2]];
-    const v2 = [vertProperties[i2 * numProp], vertProperties[i2 * numProp + 1], vertProperties[i2 * numProp + 2]];
+    const v22 = [vertProperties[i2 * numProp], vertProperties[i2 * numProp + 1], vertProperties[i2 * numProp + 2]];
     const e1 = [v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]];
-    const e2 = [v2[0] - v0[0], v2[1] - v0[1], v2[2] - v0[2]];
+    const e2 = [v22[0] - v0[0], v22[1] - v0[1], v22[2] - v0[2]];
     const rawCross = cross$4(e1, e2);
     const normal = normVec3(rawCross);
     if (!normal) continue;
     const crossLen = Math.sqrt(rawCross[0] * rawCross[0] + rawCross[1] * rawCross[1] + rawCross[2] * rawCross[2]);
     const triArea = crossLen / 2;
     const planeOffset = dot$5(normal, v0);
-    const triCentroid = [(v0[0] + v1[0] + v2[0]) / 3, (v0[1] + v1[1] + v2[1]) / 3, (v0[2] + v1[2] + v2[2]) / 3];
+    const triCentroid = [(v0[0] + v1[0] + v22[0]) / 3, (v0[1] + v1[1] + v22[1]) / 3, (v0[2] + v1[2] + v22[2]) / 3];
     let merged = false;
     for (const c2 of clusters) {
       if (dot$5(c2.normal, normal) > NORMAL_COS_EPS$1 && Math.abs(c2.planeOffset - planeOffset) < PLANE_OFFSET_EPS$1) {
@@ -32740,6 +33520,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 seen2 = /* @__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 || seen2.has(trimmed)) return;
+    seen2.add(trimmed);
+    out.push(trimmed);
+  });
+  return out;
+}
+function mergeSceneTags(...values) {
+  const out = [];
+  const seen2 = /* @__PURE__ */ new Set();
+  values.forEach((value) => {
+    normalizeSceneTags(value).forEach((tag) => {
+      if (seen2.has(tag)) return;
+      seen2.add(tag);
+      out.push(tag);
+    });
+  });
+  return out;
+}
 const _groupPlacementRefs = /* @__PURE__ */ new WeakMap();
 const _groupExplodeHint = /* @__PURE__ */ new WeakMap();
 function getGroupRefs(g2) {
@@ -32763,7 +33574,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}`);
 }
@@ -32824,31 +33635,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.
@@ -32863,13 +33689,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);
   }
@@ -32984,37 +33810,37 @@ class ShapeGroup {
     const u2 = opts.u ?? 0, v = opts.v ?? 0, p2 = opts.protrude ?? 0;
     const opp = { front: "back", back: "front", left: "right", right: "left", top: "bottom", bottom: "top" };
     const uvMap = {
-      front: (u22, v2, p22) => [u22, -p22, v2],
-      back: (u22, v2, p22) => [u22, p22, v2],
-      left: (u22, v2, p22) => [-p22, u22, v2],
-      right: (u22, v2, p22) => [p22, u22, v2],
-      top: (u22, v2, p22) => [u22, v2, p22],
-      bottom: (u22, v2, p22) => [u22, v2, -p22]
+      front: (u22, v22, p22) => [u22, -p22, v22],
+      back: (u22, v22, p22) => [u22, p22, v22],
+      left: (u22, v22, p22) => [-p22, u22, v22],
+      right: (u22, v22, p22) => [p22, u22, v22],
+      top: (u22, v22, p22) => [u22, v22, p22],
+      bottom: (u22, v22, p22) => [u22, v22, -p22]
     };
     return this.attachTo(parent, face, opp[face], uvMap[face](u2, v, p2));
   }
   /** 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);
   }
@@ -33057,7 +33883,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);
@@ -33125,7 +33952,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);
   }
@@ -33193,7 +34020,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);
@@ -33243,7 +34070,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$1) {
@@ -35418,7 +36245,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) {
@@ -35586,7 +36413,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];
@@ -35594,7 +36421,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;
 }
@@ -35621,6 +36448,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",
@@ -35690,6 +36710,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`);
@@ -35936,6 +36968,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 });
@@ -35996,6 +37051,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 });
@@ -36007,8 +37077,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) {
@@ -36032,10 +37102,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
@@ -36045,15 +37123,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 } : {},
@@ -36272,24 +37353,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") {
@@ -36322,6 +37389,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;
@@ -36762,12 +37832,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. */
@@ -39216,17 +40290,17 @@ let Shape$1 = class Shape {
       bottom: "top"
     };
     const uvMap = {
-      front: (u22, v2, p22) => [u22, -p22, v2],
+      front: (u22, v22, p22) => [u22, -p22, v22],
       // front = −Y face, outward = −Y
-      back: (u22, v2, p22) => [u22, p22, v2],
+      back: (u22, v22, p22) => [u22, p22, v22],
       // back = +Y face, outward = +Y
-      left: (u22, v2, p22) => [-p22, u22, v2],
+      left: (u22, v22, p22) => [-p22, u22, v22],
       // left = −X face, outward = −X
-      right: (u22, v2, p22) => [p22, u22, v2],
+      right: (u22, v22, p22) => [p22, u22, v22],
       // right = +X face, outward = +X
-      top: (u22, v2, p22) => [u22, v2, p22],
+      top: (u22, v22, p22) => [u22, v22, p22],
       // top = +Z face, outward = +Z
-      bottom: (u22, v2, p22) => [u22, v2, -p22]
+      bottom: (u22, v22, p22) => [u22, v22, -p22]
       // bottom = −Z face, outward = −Z
     };
     const selfAnchor = opposite[face];
@@ -41757,13 +42831,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.
@@ -41797,17 +42874,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$1) {
           markUsedOnShape(child, partName);
-          out2.push({ name: label, shape: child });
+          out2.push({ name: label, shape: child, ...tags.length > 0 ? { tags } : {} });
         }
       });
     };
@@ -42173,7 +43251,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
    */
@@ -43127,15 +44205,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);
@@ -47504,7 +48585,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) => {
@@ -47540,7 +48622,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) => {
@@ -48309,6 +49392,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$1)) 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$1)) 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$1)) {
+    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 {
@@ -49288,6 +50763,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;
@@ -49453,7 +50934,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
@@ -50651,9 +52148,9 @@ class Vector2 {
    * @param {number} alpha - The interpolation factor, typically in the closed interval `[0, 1]`.
    * @return {Vector2} A reference to this vector.
    */
-  lerpVectors(v1, v2, alpha) {
-    this.x = v1.x + (v2.x - v1.x) * alpha;
-    this.y = v1.y + (v2.y - v1.y) * alpha;
+  lerpVectors(v1, v22, alpha) {
+    this.x = v1.x + (v22.x - v1.x) * alpha;
+    this.y = v1.y + (v22.y - v1.y) * alpha;
     return this;
   }
   /**
@@ -52465,11 +53962,11 @@ class Vector4 {
    * @param {number} alpha - The interpolation factor, typically in the closed interval `[0, 1]`.
    * @return {Vector4} A reference to this vector.
    */
-  lerpVectors(v1, v2, alpha) {
-    this.x = v1.x + (v2.x - v1.x) * alpha;
-    this.y = v1.y + (v2.y - v1.y) * alpha;
-    this.z = v1.z + (v2.z - v1.z) * alpha;
-    this.w = v1.w + (v2.w - v1.w) * alpha;
+  lerpVectors(v1, v22, alpha) {
+    this.x = v1.x + (v22.x - v1.x) * alpha;
+    this.y = v1.y + (v22.y - v1.y) * alpha;
+    this.z = v1.z + (v22.z - v1.z) * alpha;
+    this.w = v1.w + (v22.w - v1.w) * alpha;
     return this;
   }
   /**
@@ -54049,10 +55546,10 @@ class Vector3 {
    * @param {number} alpha - The interpolation factor, typically in the closed interval `[0, 1]`.
    * @return {Vector3} A reference to this vector.
    */
-  lerpVectors(v1, v2, alpha) {
-    this.x = v1.x + (v2.x - v1.x) * alpha;
-    this.y = v1.y + (v2.y - v1.y) * alpha;
-    this.z = v1.z + (v2.z - v1.z) * alpha;
+  lerpVectors(v1, v22, alpha) {
+    this.x = v1.x + (v22.x - v1.x) * alpha;
+    this.y = v1.y + (v22.y - v1.y) * alpha;
+    this.z = v1.z + (v22.z - v1.z) * alpha;
     return this;
   }
   /**
@@ -54865,13 +56362,13 @@ const _center = /* @__PURE__ */ new Vector3();
 const _extents = /* @__PURE__ */ new Vector3();
 const _triangleNormal = /* @__PURE__ */ new Vector3();
 const _testAxis = /* @__PURE__ */ new Vector3();
-function satForAxes(axes, v0, v1, v2, extents) {
+function satForAxes(axes, v0, v1, v22, extents) {
   for (let i = 0, j = axes.length - 3; i <= j; i += 3) {
     _testAxis.fromArray(axes, i);
     const r = extents.x * Math.abs(_testAxis.x) + extents.y * Math.abs(_testAxis.y) + extents.z * Math.abs(_testAxis.z);
     const p0 = v0.dot(_testAxis);
     const p1 = v1.dot(_testAxis);
-    const p2 = v2.dot(_testAxis);
+    const p2 = v22.dot(_testAxis);
     if (Math.max(-Math.max(p0, p1, p2), Math.min(p0, p1, p2)) > r) {
       return false;
     }
@@ -57985,7 +59482,7 @@ class Triangle {
    * @param {Vector3} target - The target vector that is used to store the method's result.
    * @return {?Vector3} The interpolated value.
    */
-  static getInterpolation(point2, p1, p2, p3, v1, v2, v32, target) {
+  static getInterpolation(point2, p1, p2, p3, v1, v22, v32, target) {
     if (this.getBarycoord(point2, p1, p2, p3, _v3$2) === null) {
       target.x = 0;
       target.y = 0;
@@ -57995,7 +59492,7 @@ class Triangle {
     }
     target.setScalar(0);
     target.addScaledVector(v1, _v3$2.x);
-    target.addScaledVector(v2, _v3$2.y);
+    target.addScaledVector(v22, _v3$2.y);
     target.addScaledVector(v32, _v3$2.z);
     return target;
   }
@@ -58160,8 +59657,8 @@ class Triangle {
    * @param {Vector3} target - The target vector that is used to store the method's result.
    * @return {?Vector3} The interpolated value.
    */
-  getInterpolation(point2, v1, v2, v32, target) {
-    return Triangle.getInterpolation(point2, this.a, this.b, this.c, v1, v2, v32, target);
+  getInterpolation(point2, v1, v22, v32, target) {
+    return Triangle.getInterpolation(point2, this.a, this.b, this.c, v1, v22, v32, target);
   }
   /**
    * Returns `true` if the given point, when projected onto the plane of the
@@ -66438,13 +67935,13 @@ class CubicBezierCurve extends Curve {
    * @param {Vector2} [v2] - The second control point.
    * @param {Vector2} [v3] - The end point.
    */
-  constructor(v0 = new Vector2(), v1 = new Vector2(), v2 = new Vector2(), v32 = new Vector2()) {
+  constructor(v0 = new Vector2(), v1 = new Vector2(), v22 = new Vector2(), v32 = new Vector2()) {
     super();
     this.isCubicBezierCurve = true;
     this.type = "CubicBezierCurve";
     this.v0 = v0;
     this.v1 = v1;
-    this.v2 = v2;
+    this.v2 = v22;
     this.v3 = v32;
   }
   /**
@@ -66456,10 +67953,10 @@ class CubicBezierCurve extends Curve {
    */
   getPoint(t, optionalTarget = new Vector2()) {
     const point2 = optionalTarget;
-    const v0 = this.v0, v1 = this.v1, v2 = this.v2, v32 = this.v3;
+    const v0 = this.v0, v1 = this.v1, v22 = this.v2, v32 = this.v3;
     point2.set(
-      CubicBezier(t, v0.x, v1.x, v2.x, v32.x),
-      CubicBezier(t, v0.y, v1.y, v2.y, v32.y)
+      CubicBezier(t, v0.x, v1.x, v22.x, v32.x),
+      CubicBezier(t, v0.y, v1.y, v22.y, v32.y)
     );
     return point2;
   }
@@ -66497,13 +67994,13 @@ class CubicBezierCurve3 extends Curve {
    * @param {Vector3} [v2] - The second control point.
    * @param {Vector3} [v3] - The end point.
    */
-  constructor(v0 = new Vector3(), v1 = new Vector3(), v2 = new Vector3(), v32 = new Vector3()) {
+  constructor(v0 = new Vector3(), v1 = new Vector3(), v22 = new Vector3(), v32 = new Vector3()) {
     super();
     this.isCubicBezierCurve3 = true;
     this.type = "CubicBezierCurve3";
     this.v0 = v0;
     this.v1 = v1;
-    this.v2 = v2;
+    this.v2 = v22;
     this.v3 = v32;
   }
   /**
@@ -66515,11 +68012,11 @@ class CubicBezierCurve3 extends Curve {
    */
   getPoint(t, optionalTarget = new Vector3()) {
     const point2 = optionalTarget;
-    const v0 = this.v0, v1 = this.v1, v2 = this.v2, v32 = this.v3;
+    const v0 = this.v0, v1 = this.v1, v22 = this.v2, v32 = this.v3;
     point2.set(
-      CubicBezier(t, v0.x, v1.x, v2.x, v32.x),
-      CubicBezier(t, v0.y, v1.y, v2.y, v32.y),
-      CubicBezier(t, v0.z, v1.z, v2.z, v32.z)
+      CubicBezier(t, v0.x, v1.x, v22.x, v32.x),
+      CubicBezier(t, v0.y, v1.y, v22.y, v32.y),
+      CubicBezier(t, v0.z, v1.z, v22.z, v32.z)
     );
     return point2;
   }
@@ -66555,12 +68052,12 @@ class LineCurve extends Curve {
    * @param {Vector2} [v1] - The start point.
    * @param {Vector2} [v2] - The end point.
    */
-  constructor(v1 = new Vector2(), v2 = new Vector2()) {
+  constructor(v1 = new Vector2(), v22 = new Vector2()) {
     super();
     this.isLineCurve = true;
     this.type = "LineCurve";
     this.v1 = v1;
-    this.v2 = v2;
+    this.v2 = v22;
   }
   /**
    * Returns a point on the line.
@@ -66615,12 +68112,12 @@ class LineCurve3 extends Curve {
    * @param {Vector3} [v1] - The start point.
    * @param {Vector3} [v2] - The end point.
    */
-  constructor(v1 = new Vector3(), v2 = new Vector3()) {
+  constructor(v1 = new Vector3(), v22 = new Vector3()) {
     super();
     this.isLineCurve3 = true;
     this.type = "LineCurve3";
     this.v1 = v1;
-    this.v2 = v2;
+    this.v2 = v22;
   }
   /**
    * Returns a point on the line.
@@ -66676,13 +68173,13 @@ class QuadraticBezierCurve extends Curve {
    * @param {Vector2} [v1] - The control point.
    * @param {Vector2} [v2] - The end point.
    */
-  constructor(v0 = new Vector2(), v1 = new Vector2(), v2 = new Vector2()) {
+  constructor(v0 = new Vector2(), v1 = new Vector2(), v22 = new Vector2()) {
     super();
     this.isQuadraticBezierCurve = true;
     this.type = "QuadraticBezierCurve";
     this.v0 = v0;
     this.v1 = v1;
-    this.v2 = v2;
+    this.v2 = v22;
   }
   /**
    * Returns a point on the curve.
@@ -66693,10 +68190,10 @@ class QuadraticBezierCurve extends Curve {
    */
   getPoint(t, optionalTarget = new Vector2()) {
     const point2 = optionalTarget;
-    const v0 = this.v0, v1 = this.v1, v2 = this.v2;
+    const v0 = this.v0, v1 = this.v1, v22 = this.v2;
     point2.set(
-      QuadraticBezier(t, v0.x, v1.x, v2.x),
-      QuadraticBezier(t, v0.y, v1.y, v2.y)
+      QuadraticBezier(t, v0.x, v1.x, v22.x),
+      QuadraticBezier(t, v0.y, v1.y, v22.y)
     );
     return point2;
   }
@@ -66730,13 +68227,13 @@ class QuadraticBezierCurve3 extends Curve {
    * @param {Vector3} [v1] - The control point.
    * @param {Vector3} [v2] - The end point.
    */
-  constructor(v0 = new Vector3(), v1 = new Vector3(), v2 = new Vector3()) {
+  constructor(v0 = new Vector3(), v1 = new Vector3(), v22 = new Vector3()) {
     super();
     this.isQuadraticBezierCurve3 = true;
     this.type = "QuadraticBezierCurve3";
     this.v0 = v0;
     this.v1 = v1;
-    this.v2 = v2;
+    this.v2 = v22;
   }
   /**
    * Returns a point on the curve.
@@ -66747,11 +68244,11 @@ class QuadraticBezierCurve3 extends Curve {
    */
   getPoint(t, optionalTarget = new Vector3()) {
     const point2 = optionalTarget;
-    const v0 = this.v0, v1 = this.v1, v2 = this.v2;
+    const v0 = this.v0, v1 = this.v1, v22 = this.v2;
     point2.set(
-      QuadraticBezier(t, v0.x, v1.x, v2.x),
-      QuadraticBezier(t, v0.y, v1.y, v2.y),
-      QuadraticBezier(t, v0.z, v1.z, v2.z)
+      QuadraticBezier(t, v0.x, v1.x, v22.x),
+      QuadraticBezier(t, v0.y, v1.y, v22.y),
+      QuadraticBezier(t, v0.z, v1.z, v22.z)
     );
     return point2;
   }
@@ -92099,7 +93596,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;
@@ -93430,7 +94927,7 @@ class ProductSkinBuilder {
     this.stationsValue = stations.map(toStationSpec).sort((a2, b) => axisPosition(this.axisValue, a2.center) - axisPosition(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;
@@ -93464,7 +94961,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;
@@ -96606,7 +98103,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 ?? [];
@@ -106177,8 +107674,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, 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 derive(v0, v1, v22, v32, t) {
+  return Math.pow(1 - t, 3) * v0 + 3 * Math.pow(1 - t, 2) * t * v1 + 3 * (1 - t) * Math.pow(t, 2) * v22 + Math.pow(t, 3) * v32;
 }
 function BoundingBox() {
   this.x1 = Number.NaN;
@@ -335397,6 +336894,8 @@ function createForgeRuntimeModule(bindings) {
   runtime.default = runtime;
   return runtime;
 }
+const DEFAULT_RAYMARCH_STEPS = 360;
+const MIN_RAYMARCH_STEP = 0.012;
 function classifySdfPreviewNode(node) {
   switch (node.kind) {
     case "sdf:sphere":
@@ -335434,6 +336933,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);
@@ -335443,10 +336943,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",
@@ -335472,6 +336969,24 @@ ${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();
@@ -335480,6 +336995,9 @@ function f2(value) {
 function v3(value) {
   return `vec3(${f2(value[0])}, ${f2(value[1])}, ${f2(value[2])})`;
 }
+function v2(value) {
+  return `vec2(${f2(value[0])}, ${f2(value[1])})`;
+}
 function metricFlag(mode) {
   return mode === "metric-approx" ? "1.0" : "0.0";
 }
@@ -335499,6 +337017,32 @@ function scaleLimit(limit, factor) {
   const scale2 = positiveFinite(Math.abs(factor));
   return limit !== null && scale2 !== null ? limit * scale2 : limit;
 }
+function surfacePatternStepLimit(pattern) {
+  switch (pattern.kind) {
+    case "surfacePattern:constant":
+      return null;
+    case "surfacePattern:sineWave":
+      return minPositive(pattern.wavelength * 0.1, Math.abs(pattern.amplitude) * 0.5);
+    case "surfacePattern:stripes":
+      return minPositive(pattern.spacing * 0.25, pattern.width * 0.25, pattern.depth * 0.5);
+    case "surfacePattern:overUnderWeave":
+      return minPositive(
+        ...pattern.spacing.map((value) => value * 0.25),
+        ...pattern.threadWidth.map((value) => value * 0.25),
+        pattern.depth * 0.5
+      );
+    case "surfacePattern:abs":
+    case "surfacePattern:negate":
+      return surfacePatternStepLimit(pattern.child);
+    case "surfacePattern:add":
+    case "surfacePattern:multiply":
+    case "surfacePattern:min":
+    case "surfacePattern:max":
+      return minPositive(...pattern.children.map(surfacePatternStepLimit));
+    case "surfacePattern:clamp":
+      return surfacePatternStepLimit(pattern.child);
+  }
+}
 function tpmsStepLimit(node) {
   const cellLimit = node.cellSize * 0.08;
   const thicknessLimit = node.thicknessMode === "metric-approx" ? node.thickness * 0.35 : cellLimit;
@@ -335533,6 +337077,10 @@ function estimateNodeStepLimit(node) {
       return minPositive(estimateNodeStepLimit(node.child), 0.35);
     case "sdf:repeat":
       return minPositive(estimateNodeStepLimit(node.child), ...node.spacing.map((value) => positiveFinite(value * 0.25)));
+    case "sdf:circularArray": {
+      const arcSpacing = node.offset > 0 ? 2 * Math.PI * node.offset / node.count : null;
+      return minPositive(estimateNodeStepLimit(node.child), arcSpacing !== null ? arcSpacing * 0.25 : null);
+    }
     case "sdf:shell":
       return minPositive(estimateNodeStepLimit(node.child), Math.max(0.04, node.thickness * 0.25));
     case "sdf:onion":
@@ -335543,11 +337091,12 @@ function estimateNodeStepLimit(node) {
     case "sdf:lidinoid":
       return tpmsStepLimit(node);
     case "sdf:displace":
-    case "sdf:surfaceDisplace":
     case "sdf:spatialBlend":
     case "sdf:noise":
     case "sdf:voronoi":
       return null;
+    case "sdf:surfaceDisplace":
+      return node.pattern ? minPositive(estimateNodeStepLimit(node.child), surfacePatternStepLimit(node.pattern)) : null;
     case "sdf:custom":
       return node.shaderBody ? positiveFinite(node.raymarchStepLimit ?? 0.25) ?? 0.25 : null;
   }
@@ -335572,6 +337121,98 @@ function emitPolylineSweepExpr(node, p2) {
   }
   return expr;
 }
+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 emitSurfaceUvExpr(uv) {
+  const p2 = uv.localPoint;
+  switch (uv.mode) {
+    case "sphere":
+      return `surfaceUvSphere(${p2}, ${f2(uv.radius)})`;
+    case "cylinder":
+      return `surfaceUvCylinder(${p2}, ${f2(uv.radius)})`;
+    case "torus":
+      return `surfaceUvTorus(${p2}, ${f2(uv.majorRadius)}, ${f2(uv.radius)})`;
+  }
+}
+function emitSurfacePatternExpr(pattern, uvExpr) {
+  switch (pattern.kind) {
+    case "surfacePattern:constant":
+      return f2(pattern.value);
+    case "surfacePattern:sineWave":
+      return `surfacePatternSineWave(${uvExpr}, ${v2(pattern.direction)}, ${f2(pattern.wavelength)}, ${f2(pattern.amplitude)}, ${f2(pattern.phase)}, ${f2(pattern.bias)})`;
+    case "surfacePattern:stripes":
+      return `surfacePatternStripes(${uvExpr}, ${v2(pattern.direction)}, ${f2(pattern.spacing)}, ${f2(pattern.width)}, ${f2(pattern.depth)})`;
+    case "surfacePattern:overUnderWeave":
+      return `surfacePatternOverUnderWeave(${uvExpr}, ${v2(pattern.spacing)}, ${v2(pattern.threadWidth)}, ${f2(pattern.depth)}, ${f2(pattern.underScale)})`;
+    case "surfacePattern:abs":
+      return `abs(${emitSurfacePatternExpr(pattern.child, uvExpr)})`;
+    case "surfacePattern:negate":
+      return `(-(${emitSurfacePatternExpr(pattern.child, uvExpr)}))`;
+    case "surfacePattern:add":
+      return pattern.children.length === 0 ? "0.0" : `(${pattern.children.map((child) => emitSurfacePatternExpr(child, uvExpr)).join(" + ")})`;
+    case "surfacePattern:multiply":
+      return pattern.children.length === 0 ? "1.0" : `(${pattern.children.map((child) => emitSurfacePatternExpr(child, uvExpr)).join(" * ")})`;
+    case "surfacePattern:min":
+      return foldSurfacePatternChildren(pattern, uvExpr, "min", "0.0");
+    case "surfacePattern:max":
+      return foldSurfacePatternChildren(pattern, uvExpr, "max", "0.0");
+    case "surfacePattern:clamp":
+      return `clamp(${emitSurfacePatternExpr(pattern.child, uvExpr)}, ${f2(pattern.min)}, ${f2(pattern.max)})`;
+  }
+}
+function foldSurfacePatternChildren(pattern, uvExpr, op, empty) {
+  if (pattern.children.length === 0) return empty;
+  let expr = emitSurfacePatternExpr(pattern.children[0], uvExpr);
+  for (let i = 1; i < pattern.children.length; i++) {
+    expr = `${op}(${expr}, ${emitSurfacePatternExpr(pattern.children[i], uvExpr)})`;
+  }
+  return expr;
+}
 function emitSdfExpr(node, p2) {
   switch (node.kind) {
     case "sdf:sphere":
@@ -335614,6 +337255,11 @@ function emitSdfExpr(node, p2) {
       return emitSdfExpr(node.child, `bendPoint(${p2}, ${f2(node.radius)})`);
     case "sdf:repeat":
       return emitSdfExpr(node.child, `repeatPoint(${p2}, ${v3(node.spacing)}, ${v3(node.count)})`);
+    case "sdf:circularArray": {
+      const a2 = emitSdfExpr(node.child, `circularArrayPoint(${p2}, ${f2(node.count)}, ${f2(node.offset)}, -1.0)`);
+      const b = emitSdfExpr(node.child, `circularArrayPoint(${p2}, ${f2(node.count)}, ${f2(node.offset)}, 0.0)`);
+      return `min(${a2}, ${b})`;
+    }
     case "sdf:shell":
       return `(abs(${emitSdfExpr(node.child, p2)}) - ${f2(node.thickness * 0.5)})`;
     case "sdf:onion": {
@@ -335621,6 +337267,12 @@ function emitSdfExpr(node, p2) {
       for (let i = 0; i < node.layers; i++) expr = `(abs(${expr}) - ${f2(node.thickness)})`;
       return expr;
     }
+    case "sdf:surfaceDisplace": {
+      if (!node.pattern) return "1e20";
+      const uv = analyzeShaderSurfaceUv(node.child, p2, node.uvMode);
+      if (uv.mode === "triplanar") return "1e20";
+      return `(${emitSdfExpr(node.child, p2)} + ${emitSurfacePatternExpr(node.pattern, emitSurfaceUvExpr(uv))})`;
+    }
     case "sdf:gyroid":
       return `sdGyroid(${p2}, ${f2(node.cellSize)}, ${f2(node.thickness)}, ${metricFlag(node.thicknessMode)})`;
     case "sdf:schwarzP":
@@ -335636,7 +337288,6 @@ function emitSdfExpr(node, p2) {
       }
       return "1e20";
     case "sdf:displace":
-    case "sdf:surfaceDisplace":
     case "sdf:spatialBlend":
     case "sdf:noise":
     case "sdf:voronoi":
@@ -335710,9 +337361,9 @@ uniform vec3 uHoverColor;
 uniform float uHoverIntensity;
 uniform float uIsOrthographic;
 
-const int MAX_STEPS = 360;
+const int MAX_STEPS = ${DEFAULT_RAYMARCH_STEPS};
 const int REFINE_STEPS = 7;
-const float MIN_STEP = 0.012;
+const float MIN_STEP = ${f2(MIN_RAYMARCH_STEP)};
 const float HIT_EPS = 0.035;
 const float NORMAL_EPS = 0.12;
 const float FIELD_STEP_LIMIT = ${stepLimit === null ? "1e20" : f2(stepLimit)};
@@ -335801,6 +337452,53 @@ vec3 repeatPoint(vec3 p, vec3 spacing, vec3 count) {
   );
 }
 
+vec3 circularArrayPoint(vec3 p, float count, float offset, float sectorOffset) {
+  float step = 6.283185307179586 / max(count, 1.0);
+  float radius = length(p.xy);
+  float angle = mod(atan(p.y, p.x), step);
+  if (angle < 0.0) angle += step;
+  angle += sectorOffset * step;
+  return vec3(cos(angle) * radius - offset, sin(angle) * radius, p.z);
+}
+
+vec2 surfaceUvSphere(vec3 p, float radius) {
+  return vec2(atan(p.y, p.x) * radius, acos(clamp(p.z / max(length(p), 1e-9), -1.0, 1.0)) * radius);
+}
+
+vec2 surfaceUvCylinder(vec3 p, float radius) {
+  return vec2(atan(p.y, p.x) * radius, p.z);
+}
+
+vec2 surfaceUvTorus(vec3 p, float majorRadius, float minorRadius) {
+  return vec2(atan(p.y, p.x) * majorRadius, atan(p.z, length(p.xy) - majorRadius) * minorRadius);
+}
+
+float surfacePatternSineWave(vec2 uv, vec2 direction, float wavelength, float amplitude, float phase, float bias) {
+  return bias + sin(dot(uv, direction) * (6.283185307179586 / wavelength) + phase) * amplitude;
+}
+
+float surfacePatternStripes(vec2 uv, vec2 direction, float spacing, float width, float depth) {
+  float coord = dot(uv, direction);
+  float d = abs(coord - floor(coord / spacing + 0.5) * spacing);
+  float p = max(0.0, 1.0 - d / (width * 0.5));
+  return -(p * p) * depth;
+}
+
+float surfacePatternOverUnderWeave(vec2 uv, vec2 spacing, vec2 threadWidth, float depth, float underScale) {
+  float su = uv.x / spacing.x;
+  float sv = uv.y / spacing.y;
+  float du = abs(su - floor(su + 0.5)) * spacing.x;
+  float dv = abs(sv - floor(sv + 0.5)) * spacing.y;
+  float pU = max(0.0, 1.0 - du / (threadWidth.x * 0.5));
+  float pV = max(0.0, 1.0 - dv / (threadWidth.y * 0.5));
+  pU *= pU;
+  pV *= pV;
+  float checker = mod(floor(su + 0.5) + floor(sv + 0.5), 2.0);
+  float top = checker > 0.5 ? pV : pU;
+  float bot = checker > 0.5 ? pU : pV;
+  return -max(top, bot * underScale) * depth;
+}
+
 vec3 rotateInvEuler(vec3 p, vec3 degrees) {
   vec3 r = radians(degrees);
   float cx = cos(r.x);
@@ -336001,9 +337699,9 @@ void main() {
   float bestAbsDist = 1e20;
   int bestIndex = -1;
   bool conservativeField = FIELD_STEP_LIMIT < 1e19;
-  float maxStep = conservativeField
-    ? max(MIN_STEP, min(max(sceneDiag / 260.0, MIN_STEP), FIELD_STEP_LIMIT))
-    : max(MIN_STEP, sceneDiag / 18.0);
+  float coarseMaxStep = max(MIN_STEP, sceneDiag / 18.0);
+  float conservativeMaxStep = max(MIN_STEP, min(max(sceneDiag / 260.0, MIN_STEP), FIELD_STEP_LIMIT));
+  float localDetailBand = max(HIT_EPS * 4.0, FIELD_STEP_LIMIT * 4.0);
   float stepScale = conservativeField ? CONSERVATIVE_STEP_SCALE : SAFE_STEP_SCALE;
 
   for (int i = 0; i < MAX_STEPS; i++) {
@@ -336024,6 +337722,7 @@ void main() {
       hit = true;
       break;
     }
+    float maxStep = conservativeField && absDist <= localDetailBand ? conservativeMaxStep : coarseMaxStep;
     float stepSize = clamp(absDist * stepScale, MIN_STEP, maxStep);
     prevT = t;
     prevDist = dist;
@@ -336147,7 +337846,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,
@@ -336158,7 +337857,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) => {
@@ -336182,7 +337882,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}`,
@@ -336193,10 +337893,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 = {
@@ -336216,7 +337917,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) => {
@@ -336233,18 +337935,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$1) {
-      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) => {
@@ -336253,34 +337961,40 @@ function mapScriptResultToScene(args) {
     return proto2 === Object.prototype || proto2 === null;
   };
   const joinName = (path2) => path2.join(".");
-  const processRenderableTree = (value, fallbackLabel, fallbackSegment, parentGroup, parentTreePath = [], seen2 = /* @__PURE__ */ new WeakSet()) => {
+  const processRenderableTree = (value, fallbackLabel, fallbackSegment, parentGroup, parentTreePath = [], inheritedTags = [], seen2 = /* @__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$1) {
-      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) {
@@ -336291,7 +338005,8 @@ function mapScriptResultToScene(args) {
         sketch: null,
         toolpath: value.build(),
         geometryInfo: null,
-        treePath
+        treePath,
+        ...inheritedTags.length > 0 ? { tags: [...inheritedTags] } : {}
       });
       return;
     }
@@ -336301,30 +338016,38 @@ function mapScriptResultToScene(args) {
       value.forEach((item, index2) => {
         const childSegment = `${index2 + 1}`;
         const childLabel = `${name}.${childSegment}`;
-        processRenderableTree(item, childLabel, childSegment, parentGroup, treePath, seen2);
+        processRenderableTree(item, childLabel, childSegment, parentGroup, treePath, inheritedTags, seen2);
       });
       return;
     }
     if (isNamedObject(value)) {
-      processNamedItem(value, fallbackLabel, fallbackSegment, parentGroup, parentTreePath);
+      processNamedItem(value, fallbackLabel, fallbackSegment, parentGroup, parentTreePath, inheritedTags);
       return;
     }
     if (isPlainObject2(value)) {
       if (seen2.has(value)) return;
       seen2.add(value);
       Object.entries(value).forEach(([key, entry]) => {
-        processRenderableTree(entry, key, key, parentGroup, treePath, seen2);
+        processRenderableTree(entry, key, key, parentGroup, treePath, inheritedTags, seen2);
       });
     }
   };
-  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;
     }
@@ -336334,39 +338057,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$1) {
-          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$1) {
-      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) {
@@ -336380,7 +338112,8 @@ function mapScriptResultToScene(args) {
         sketchMeta: meta2,
         color: item.color || item.sketch.colorHex,
         groupName: grp,
-        treePath
+        treePath,
+        ...tags.length > 0 ? { tags: [...tags] } : {}
       });
     }
   };
@@ -336394,14 +338127,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;
       }
@@ -336434,7 +338173,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$1) {
         pushShape(defaultValue, args.fileName, void 0, void 0, [args.fileName]);
@@ -336480,7 +338219,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);