forgecad 0.7.0 → 0.8.0

package/dist/assets/{reportWorker-DYcRHhv9.js → reportWorker-Dxr-5A7w.js}

@@ -1688,6 +1688,17 @@ function cloneSweepPathCompilePlan(path2) {
         c1: canonicalVec3(path2.c1),
         chordLength: canonicalNumber(path2.chordLength)
       };
+    case "nurbs":
+      return {
+        kind: "nurbs",
+        controlPoints: path2.controlPoints.map(
+          ([x, y, z]) => [canonicalNumber(x), canonicalNumber(y), canonicalNumber(z)]
+        ),
+        weights: path2.weights.map(canonicalNumber),
+        knots: path2.knots.map(canonicalNumber),
+        degree: path2.degree,
+        closed: path2.closed
+      };
     default:
       assertExhaustive(path2);
   }
@@ -1754,10 +1765,33 @@ function cloneProfileCompilePlan(plan) {
         replayReason: plan.replayReason,
         transforms: plan.transforms.map(cloneProfileTransform)
       };
+    case "pathProfile":
+      return {
+        kind: "pathProfile",
+        points: plan.points.map(([x, y]) => [x, y]),
+        edges: plan.edges.map(cloneProfileEdge),
+        transforms: plan.transforms.map(cloneProfileTransform)
+      };
     default:
       assertExhaustive(plan);
   }
 }
+function cloneProfileEdge(edge) {
+  switch (edge.kind) {
+    case "line":
+      return { kind: "line", x1: edge.x1, y1: edge.y1, x2: edge.x2, y2: edge.y2 };
+    case "arc":
+      return { kind: "arc", x1: edge.x1, y1: edge.y1, x2: edge.x2, y2: edge.y2, cx: edge.cx, cy: edge.cy, clockwise: edge.clockwise };
+    case "bspline":
+      return {
+        kind: "bspline",
+        controlPoints: edge.controlPoints.map(([x, y]) => [x, y]),
+        weights: [...edge.weights],
+        knots: [...edge.knots],
+        degree: edge.degree
+      };
+  }
+}
 function cloneShapeCompilePlan(plan) {
   if (!plan) return null;
   let result;
@@ -1998,6 +2032,24 @@ function cloneShapeCompilePlan(plan) {
         boundsPadding: canonicalNumber(plan.boundsPadding)
       };
       break;
+    case "importedStep":
+      result = { kind: "importedStep", filePath: plan.filePath, fileData: plan.fileData };
+      break;
+    case "nurbsSurface":
+      result = {
+        kind: "nurbsSurface",
+        controlGrid: plan.controlGrid.map(
+          (row) => row.map(([x, y, z]) => [canonicalNumber(x), canonicalNumber(y), canonicalNumber(z)])
+        ),
+        weightsGrid: plan.weightsGrid.map((row) => row.map(canonicalNumber)),
+        knotsU: plan.knotsU.map(canonicalNumber),
+        knotsV: plan.knotsV.map(canonicalNumber),
+        degreeU: plan.degreeU,
+        degreeV: plan.degreeV,
+        thickness: canonicalNumber(plan.thickness),
+        resolution: plan.resolution
+      };
+      break;
     default:
       assertExhaustive(plan);
   }
@@ -2188,6 +2240,8 @@ function findShapePrimaryQueryOwner(plan) {
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "nurbsSurface":
+    case "importedStep":
       return null;
     default:
       assertExhaustive(plan);
@@ -2234,6 +2288,8 @@ function collectShapeQueryOwners(plan) {
       case "importedMesh":
       case "sdf":
       case "fromSlices":
+      case "nurbsSurface":
+      case "importedStep":
         return;
       default:
         assertExhaustive(current);
@@ -2288,6 +2344,8 @@ function findShapeWorkplanePlacement(plan) {
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "nurbsSurface":
+    case "importedStep":
       return null;
     default:
       assertExhaustive(plan);
@@ -2410,6 +2468,184 @@ function buildFromSlicesShapeCompilePlan(groups, options) {
     boundsPadding: canonicalNumber(options.boundsPadding)
   };
 }
+function generateClampedKnots(n, degree) {
+  const m = n + degree + 1;
+  const knots = new Array(m);
+  for (let i = 0; i < m; i++) {
+    if (i <= degree) knots[i] = 0;
+    else if (i >= m - degree - 1) knots[i] = 1;
+    else knots[i] = (i - degree) / (n - degree);
+  }
+  return knots;
+}
+function findSpan(n, degree, u, knots) {
+  if (u >= knots[n]) return n - 1;
+  if (u <= knots[degree]) return degree;
+  let lo = degree;
+  let hi = n;
+  let mid = lo + hi >>> 1;
+  while (u < knots[mid] || u >= knots[mid + 1]) {
+    if (u < knots[mid]) hi = mid;
+    else lo = mid;
+    mid = lo + hi >>> 1;
+  }
+  return mid;
+}
+function basisFuns(span, u, degree, knots) {
+  const N = new Array(degree + 1);
+  const left = new Array(degree + 1);
+  const right = new Array(degree + 1);
+  N[0] = 1;
+  for (let j = 1; j <= degree; j++) {
+    left[j] = u - knots[span + 1 - j];
+    right[j] = knots[span + j] - u;
+    let saved = 0;
+    for (let r = 0; r < j; r++) {
+      const denom = right[r + 1] + left[j - r];
+      const temp = denom === 0 ? 0 : N[r] / denom;
+      N[r] = saved + right[r + 1] * temp;
+      saved = left[j - r] * temp;
+    }
+    N[j] = saved;
+  }
+  return N;
+}
+function basisFunsDeriv(span, u, degree, knots, nDeriv) {
+  const ndu = Array.from({ length: degree + 1 }, () => new Array(degree + 1).fill(0));
+  const a = Array.from({ length: 2 }, () => new Array(degree + 1).fill(0));
+  const left = new Array(degree + 1);
+  const right = new Array(degree + 1);
+  ndu[0][0] = 1;
+  for (let j = 1; j <= degree; j++) {
+    left[j] = u - knots[span + 1 - j];
+    right[j] = knots[span + j] - u;
+    let saved = 0;
+    for (let r2 = 0; r2 < j; r2++) {
+      ndu[j][r2] = right[r2 + 1] + left[j - r2];
+      const temp = ndu[j][r2] === 0 ? 0 : ndu[r2][j - 1] / ndu[j][r2];
+      ndu[r2][j] = saved + right[r2 + 1] * temp;
+      saved = left[j - r2] * temp;
+    }
+    ndu[j][j] = saved;
+  }
+  const ders = Array.from({ length: nDeriv + 1 }, () => new Array(degree + 1).fill(0));
+  for (let j = 0; j <= degree; j++) {
+    ders[0][j] = ndu[j][degree];
+  }
+  for (let r2 = 0; r2 <= degree; r2++) {
+    let s1 = 0;
+    let s2 = 1;
+    a[0][0] = 1;
+    for (let k = 1; k <= nDeriv; k++) {
+      let d = 0;
+      const rk = r2 - k;
+      const pk = degree - k;
+      if (r2 >= k) {
+        a[s2][0] = ndu[pk + 1][rk] === 0 ? 0 : a[s1][0] / ndu[pk + 1][rk];
+        d = a[s2][0] * ndu[rk][pk];
+      }
+      const j1 = rk >= -1 ? 1 : -rk;
+      const j2 = r2 - 1 <= pk ? k - 1 : degree - r2;
+      for (let j = j1; j <= j2; j++) {
+        a[s2][j] = ndu[pk + 1][rk + j] === 0 ? 0 : (a[s1][j] - a[s1][j - 1]) / ndu[pk + 1][rk + j];
+        d += a[s2][j] * ndu[rk + j][pk];
+      }
+      if (r2 <= pk) {
+        a[s2][k] = ndu[pk + 1][r2] === 0 ? 0 : -a[s1][k - 1] / ndu[pk + 1][r2];
+        d += a[s2][k] * ndu[r2][pk];
+      }
+      ders[k][r2] = d;
+      const tmp = s1;
+      s1 = s2;
+      s2 = tmp;
+    }
+  }
+  let r = degree;
+  for (let k = 1; k <= nDeriv; k++) {
+    for (let j = 0; j <= degree; j++) {
+      ders[k][j] *= r;
+    }
+    r *= degree - k;
+  }
+  return ders;
+}
+function deBoor3D(controlPoints, weights, knots, degree, u) {
+  const n = controlPoints.length;
+  const span = findSpan(n, degree, u, knots);
+  const N = basisFuns(span, u, degree, knots);
+  let wx = 0, wy = 0, wz = 0, wSum = 0;
+  for (let j = 0; j <= degree; j++) {
+    const idx = span - degree + j;
+    const w = weights[idx] * N[j];
+    wx += w * controlPoints[idx][0];
+    wy += w * controlPoints[idx][1];
+    wz += w * controlPoints[idx][2];
+    wSum += w;
+  }
+  if (wSum === 0) return [0, 0, 0];
+  return [wx / wSum, wy / wSum, wz / wSum];
+}
+function deBoor3DDeriv(controlPoints, weights, knots, degree, u) {
+  const n = controlPoints.length;
+  const span = findSpan(n, degree, u, knots);
+  const ders = basisFunsDeriv(span, u, degree, knots, 1);
+  const N = ders[0];
+  const dN = ders[1];
+  let ax = 0, ay = 0, az = 0, wVal = 0;
+  let dax = 0, day = 0, daz = 0, dwVal = 0;
+  for (let j = 0; j <= degree; j++) {
+    const idx = span - degree + j;
+    const wi = weights[idx];
+    const px = controlPoints[idx][0], py = controlPoints[idx][1], pz = controlPoints[idx][2];
+    ax += N[j] * wi * px;
+    ay += N[j] * wi * py;
+    az += N[j] * wi * pz;
+    wVal += N[j] * wi;
+    dax += dN[j] * wi * px;
+    day += dN[j] * wi * py;
+    daz += dN[j] * wi * pz;
+    dwVal += dN[j] * wi;
+  }
+  if (wVal === 0) return [0, 0, 0];
+  const invW = 1 / wVal;
+  return [
+    (dax - dwVal * ax * invW) * invW,
+    (day - dwVal * ay * invW) * invW,
+    (daz - dwVal * az * invW) * invW
+  ];
+}
+function deBoor2D(controlPoints, weights, knots, degree, u) {
+  const n = controlPoints.length;
+  const span = findSpan(n, degree, u, knots);
+  const N = basisFuns(span, u, degree, knots);
+  let wx = 0, wy = 0, wSum = 0;
+  for (let j = 0; j <= degree; j++) {
+    const idx = span - degree + j;
+    const w = weights[idx] * N[j];
+    wx += w * controlPoints[idx][0];
+    wy += w * controlPoints[idx][1];
+    wSum += w;
+  }
+  if (wSum === 0) return [0, 0];
+  return [wx / wSum, wy / wSum];
+}
+function sampleNurbs3D(controlPoints, weights, knots, degree, count) {
+  const n = controlPoints.length;
+  const uMin = knots[degree];
+  const uMax = knots[n];
+  const result = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const t = i / (count - 1);
+    const u = uMin + t * (uMax - uMin);
+    result[i] = deBoor3D(controlPoints, weights, knots, degree, u);
+  }
+  return result;
+}
+function remapToKnotDomain(t, n, degree, knots) {
+  const uMin = knots[degree];
+  const uMax = knots[n];
+  return uMin + Math.max(0, Math.min(1, t)) * (uMax - uMin);
+}
 function catmullRom3D$2(p0, p1, p2, p3, t, tension) {
   const tt = t * t;
   const ttt = tt * t;
@@ -2544,6 +2780,10 @@ function evalPathAt(path2, t) {
         h00 * path2.p0[2] + h10 * path2.t0[2] + h20 * path2.c0[2] + h01 * path2.p1[2] + h11 * path2.t1[2] + h21 * path2.c1[2]
       ];
     }
+    case "nurbs": {
+      const u = remapToKnotDomain(Math.max(0, Math.min(1, t)), path2.controlPoints.length, path2.degree, path2.knots);
+      return deBoor3D(path2.controlPoints, path2.weights, path2.knots, path2.degree, u);
+    }
   }
 }
 function estimateCurvatureAt(path2, t) {
@@ -2578,6 +2818,18 @@ function sweepPathToPolyline(path2, samples = 48) {
         path2.c1,
         samples
       );
+    case "nurbs": {
+      const n = path2.controlPoints.length;
+      const uMin = path2.knots[path2.degree];
+      const uMax = path2.knots[n];
+      const result = new Array(samples);
+      for (let i = 0; i < samples; i++) {
+        const t = i / (samples - 1);
+        const u = uMin + t * (uMax - uMin);
+        result[i] = deBoor3D(path2.controlPoints, path2.weights, path2.knots, path2.degree, u);
+      }
+      return result;
+    }
   }
 }
 function sweepPathToPolylineAdaptive(path2, baseSamples = 48) {
@@ -2811,6 +3063,8 @@ function searchOwnerMatch(plan, owner) {
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "nurbsSurface":
+    case "importedStep":
       return {
         issue: {
           code: "edge-owner-not-found",
@@ -2892,7 +3146,7 @@ function propagateCandidateAcrossRewrite(plan, candidate) {
   return edgeSuccess(candidate.selection, preservedEntry.query);
 }
 function resolvePropagatedEdgeQueryAtOwnerBase(ownerBase, ref) {
-  if (ownerBase.kind === "box" || ownerBase.kind === "cylinder" || ownerBase.kind === "sphere" || ownerBase.kind === "extrude" || ownerBase.kind === "sheetMetal" || ownerBase.kind === "revolve" || ownerBase.kind === "loft" || ownerBase.kind === "sweep" || ownerBase.kind === "variableSweep" || ownerBase.kind === "transform" || ownerBase.kind === "queryOwner" || ownerBase.kind === "filletEdges" || ownerBase.kind === "chamferEdges" || ownerBase.kind === "importedMesh" || ownerBase.kind === "sdf" || ownerBase.kind === "fromSlices" || ownerBase.kind === "torus" || ownerBase.kind === "draft" || ownerBase.kind === "offsetSolid") {
+  if (ownerBase.kind === "box" || ownerBase.kind === "cylinder" || ownerBase.kind === "sphere" || ownerBase.kind === "extrude" || ownerBase.kind === "sheetMetal" || ownerBase.kind === "revolve" || ownerBase.kind === "loft" || ownerBase.kind === "sweep" || ownerBase.kind === "variableSweep" || ownerBase.kind === "transform" || ownerBase.kind === "queryOwner" || ownerBase.kind === "filletEdges" || ownerBase.kind === "chamferEdges" || ownerBase.kind === "importedMesh" || ownerBase.kind === "sdf" || ownerBase.kind === "fromSlices" || ownerBase.kind === "nurbsSurface" || ownerBase.kind === "importedStep" || ownerBase.kind === "torus" || ownerBase.kind === "draft" || ownerBase.kind === "offsetSolid") {
     return edgeIssue(
       "edge-query-propagation-mismatch",
       "The selected propagated edge query does not point at a topology-rewrite result on this target shape."
@@ -3118,6 +3372,8 @@ function resolveSelectionFromOwnerBase(plan, edgeName) {
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "nurbsSurface":
+    case "importedStep":
       return edgeIssue(
         "unsupported-edge-base",
         "Edge finishing v1 currently supports tracked vertical edges from compile-covered box() bodies and rectangle extrusions before topology-changing edits."
@@ -3152,7 +3408,7 @@ function resolveSupportedEdgeFeatureSelection(plan, ref) {
   return edgeIssue("edge-query-unsupported-after-rewrite", descendant.reason);
 }
 function resolveEdgeChainAtOwnerBase(ownerBase, ref) {
-  if (ownerBase.kind === "box" || ownerBase.kind === "cylinder" || ownerBase.kind === "sphere" || ownerBase.kind === "extrude" || ownerBase.kind === "sheetMetal" || ownerBase.kind === "revolve" || ownerBase.kind === "loft" || ownerBase.kind === "sweep" || ownerBase.kind === "variableSweep" || ownerBase.kind === "transform" || ownerBase.kind === "queryOwner" || ownerBase.kind === "filletEdges" || ownerBase.kind === "chamferEdges" || ownerBase.kind === "importedMesh" || ownerBase.kind === "sdf" || ownerBase.kind === "fromSlices" || ownerBase.kind === "torus" || ownerBase.kind === "draft" || ownerBase.kind === "offsetSolid") {
+  if (ownerBase.kind === "box" || ownerBase.kind === "cylinder" || ownerBase.kind === "sphere" || ownerBase.kind === "extrude" || ownerBase.kind === "sheetMetal" || ownerBase.kind === "revolve" || ownerBase.kind === "loft" || ownerBase.kind === "sweep" || ownerBase.kind === "variableSweep" || ownerBase.kind === "transform" || ownerBase.kind === "queryOwner" || ownerBase.kind === "filletEdges" || ownerBase.kind === "chamferEdges" || ownerBase.kind === "importedMesh" || ownerBase.kind === "sdf" || ownerBase.kind === "fromSlices" || ownerBase.kind === "nurbsSurface" || ownerBase.kind === "importedStep" || ownerBase.kind === "torus" || ownerBase.kind === "draft" || ownerBase.kind === "offsetSolid") {
     return {
       kind: "unsupported",
       query: cloneEdgeQueryRef(ref),
@@ -3185,7 +3441,7 @@ function resolveEdgeChainAtOwnerBase(ownerBase, ref) {
   };
 }
 function resolveCreatedEdgeChainAtOwnerBase(ownerBase, ref) {
-  if (ownerBase.kind === "box" || ownerBase.kind === "cylinder" || ownerBase.kind === "sphere" || ownerBase.kind === "extrude" || ownerBase.kind === "sheetMetal" || ownerBase.kind === "revolve" || ownerBase.kind === "loft" || ownerBase.kind === "sweep" || ownerBase.kind === "variableSweep" || ownerBase.kind === "transform" || ownerBase.kind === "queryOwner" || ownerBase.kind === "filletEdges" || ownerBase.kind === "chamferEdges" || ownerBase.kind === "importedMesh" || ownerBase.kind === "sdf" || ownerBase.kind === "fromSlices" || ownerBase.kind === "torus" || ownerBase.kind === "draft" || ownerBase.kind === "offsetSolid") {
+  if (ownerBase.kind === "box" || ownerBase.kind === "cylinder" || ownerBase.kind === "sphere" || ownerBase.kind === "extrude" || ownerBase.kind === "sheetMetal" || ownerBase.kind === "revolve" || ownerBase.kind === "loft" || ownerBase.kind === "sweep" || ownerBase.kind === "variableSweep" || ownerBase.kind === "transform" || ownerBase.kind === "queryOwner" || ownerBase.kind === "filletEdges" || ownerBase.kind === "chamferEdges" || ownerBase.kind === "importedMesh" || ownerBase.kind === "sdf" || ownerBase.kind === "fromSlices" || ownerBase.kind === "nurbsSurface" || ownerBase.kind === "importedStep" || ownerBase.kind === "torus" || ownerBase.kind === "draft" || ownerBase.kind === "offsetSolid") {
     return {
       kind: "unsupported",
       query: cloneEdgeQueryRef(ref),
@@ -4678,6 +4934,8 @@ function lowerBaseShellPlanToConcretePlan(plan, thickness, openFaces) {
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "nurbsSurface":
+    case "importedStep":
       return {
         ok: false,
         reason: `Shape.shell() supports box(), cylinder(), straight extrude(), loft(), sweep(), and variableSweep() bases. "${plan.kind}" bases are not supported.`
@@ -5016,7 +5274,7 @@ const defaultPerm = doublePerm(p);
 const defaultPermMod12 = permMod12(defaultPerm);
 const F3 = 1 / 3;
 const G3 = 1 / 6;
-function dot3$5(gi, x, y, z) {
+function dot3$6(gi, x, y, z) {
   const o = gi * 3;
   return grad3[o] * x + grad3[o + 1] * y + grad3[o + 2] * z;
 }
@@ -5126,28 +5384,28 @@ function simplex3Core(x, y, z, perm, pm12) {
     n0 = 0;
   } else {
     t0 *= t0;
-    n0 = t0 * t0 * dot3$5(gi0, x0, y0, z0);
+    n0 = t0 * t0 * dot3$6(gi0, x0, y0, z0);
   }
   let t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
   if (t1 < 0) {
     n1 = 0;
   } else {
     t1 *= t1;
-    n1 = t1 * t1 * dot3$5(gi1, x1, y1, z1);
+    n1 = t1 * t1 * dot3$6(gi1, x1, y1, z1);
   }
   let t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
   if (t2 < 0) {
     n2 = 0;
   } else {
     t2 *= t2;
-    n2 = t2 * t2 * dot3$5(gi2, x2, y2, z2);
+    n2 = t2 * t2 * dot3$6(gi2, x2, y2, z2);
   }
   let t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
   if (t3 < 0) {
     n3 = 0;
   } else {
     t3 *= t3;
-    n3 = t3 * t3 * dot3$5(gi3, x3, y3, z3);
+    n3 = t3 * t3 * dot3$6(gi3, x3, y3, z3);
   }
   return 32 * (n0 + n1 + n2 + n3);
 }
@@ -5911,6 +6169,158 @@ function padBounds(b, pad) {
     max: [b.max[0] + pad, b.max[1] + pad, b.max[2] + pad]
   };
 }
+function requireFinite$6(v, label) {
+  if (!Number.isFinite(v)) throw new Error(`nurbsSurface: ${label} must be finite, got ${v}`);
+}
+class NurbsSurface {
+  // columns in control grid
+  constructor(controlGrid, options = {}) {
+    __publicField(this, "controlGrid");
+    __publicField(this, "weightsGrid");
+    __publicField(this, "knotsU");
+    __publicField(this, "knotsV");
+    __publicField(this, "degreeU");
+    __publicField(this, "degreeV");
+    __publicField(this, "nU");
+    // rows in control grid
+    __publicField(this, "nV");
+    const nU = controlGrid.length;
+    if (nU < 2) throw new Error("nurbsSurface: controlGrid must have at least 2 rows");
+    const nV = controlGrid[0].length;
+    if (nV < 2) throw new Error("nurbsSurface: controlGrid must have at least 2 columns");
+    const degreeU = options.degreeU ?? Math.min(nU - 1, 3);
+    const degreeV = options.degreeV ?? Math.min(nV - 1, 3);
+    if (nU < degreeU + 1) throw new Error(`nurbsSurface: need at least ${degreeU + 1} rows for degreeU=${degreeU}, got ${nU}`);
+    if (nV < degreeV + 1) throw new Error(`nurbsSurface: need at least ${degreeV + 1} columns for degreeV=${degreeV}, got ${nV}`);
+    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$6(controlGrid[i][j][0], `controlGrid[${i}][${j}][0]`);
+        requireFinite$6(controlGrid[i][j][1], `controlGrid[${i}][${j}][1]`);
+        requireFinite$6(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$6(weightsGrid[i][j], `weights[${i}][${j}]`);
+        if (weightsGrid[i][j] <= 0) throw new Error(`nurbsSurface: weights[${i}][${j}] must be > 0`);
+      }
+    }
+    const knotsU = options.knotsU ?? generateClampedKnots(nU, degreeU);
+    const knotsV = options.knotsV ?? generateClampedKnots(nV, degreeV);
+    if (knotsU.length !== nU + degreeU + 1) throw new Error(`nurbsSurface: knotsU.length should be ${nU + degreeU + 1}, got ${knotsU.length}`);
+    if (knotsV.length !== nV + degreeV + 1) throw new Error(`nurbsSurface: knotsV.length should be ${nV + degreeV + 1}, got ${knotsV.length}`);
+    this.controlGrid = controlGrid.map((row) => row.map(([x, y, z]) => [x, y, z]));
+    this.weightsGrid = weightsGrid.map((row) => [...row]);
+    this.knotsU = [...knotsU];
+    this.knotsV = [...knotsV];
+    this.degreeU = degreeU;
+    this.degreeV = degreeV;
+    this.nU = nU;
+    this.nV = nV;
+  }
+  /**
+   * Evaluate the surface at parameters (u, v) ∈ [0, 1]².
+   * Uses tensor product evaluation: evaluate basis functions in U and V independently.
+   */
+  pointAt(u, v) {
+    const uu = this.remapU(Math.max(0, Math.min(1, u)));
+    const vv = this.remapV(Math.max(0, Math.min(1, v)));
+    const spanU = findSpan(this.nU, this.degreeU, uu, this.knotsU);
+    const spanV = findSpan(this.nV, this.degreeV, vv, this.knotsV);
+    const Nu = basisFuns(spanU, uu, this.degreeU, this.knotsU);
+    const Nv = basisFuns(spanV, vv, this.degreeV, this.knotsV);
+    let wx = 0, wy = 0, wz = 0, wSum = 0;
+    for (let i = 0; i <= this.degreeU; i++) {
+      const rowIdx = spanU - this.degreeU + i;
+      for (let j = 0; j <= this.degreeV; j++) {
+        const colIdx = spanV - this.degreeV + j;
+        const w = Nu[i] * Nv[j] * this.weightsGrid[rowIdx][colIdx];
+        const pt = this.controlGrid[rowIdx][colIdx];
+        wx += w * pt[0];
+        wy += w * pt[1];
+        wz += w * pt[2];
+        wSum += w;
+      }
+    }
+    if (wSum === 0) return [0, 0, 0];
+    return [wx / wSum, wy / wSum, wz / wSum];
+  }
+  /**
+   * Evaluate the surface normal at (u, v) via cross product of partial derivatives.
+   */
+  normalAt(u, v) {
+    const eps = 1e-5;
+    const u0 = Math.max(0, u - eps), u1 = Math.min(1, u + eps);
+    const v0 = Math.max(0, v - eps), v1 = Math.min(1, v + eps);
+    const pu = this.pointAt(u1, v), pmu = this.pointAt(u0, v);
+    const pv = this.pointAt(u, v1), pmv = this.pointAt(u, v0);
+    const du = [pu[0] - pmu[0], pu[1] - pmu[1], pu[2] - pmu[2]];
+    const dv = [pv[0] - pmv[0], pv[1] - pmv[1], pv[2] - pmv[2]];
+    const nx = du[1] * dv[2] - du[2] * dv[1];
+    const ny = du[2] * dv[0] - du[0] * dv[2];
+    const nz = du[0] * dv[1] - du[1] * dv[0];
+    const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    if (len < 1e-12) return [0, 0, 1];
+    return [nx / len, ny / len, nz / len];
+  }
+  /**
+   * Tessellate the surface into a triangle mesh.
+   * Returns positions, normals, and triangle indices.
+   */
+  tessellate(resU = 32, resV = 32) {
+    const positions = [];
+    const normals = [];
+    for (let i = 0; i <= resU; i++) {
+      const u = i / resU;
+      for (let j = 0; j <= resV; j++) {
+        const v = j / resV;
+        positions.push(this.pointAt(u, v));
+        normals.push(this.normalAt(u, v));
+      }
+    }
+    const indices = [];
+    for (let i = 0; i < resU; i++) {
+      for (let j = 0; j < resV; j++) {
+        const a = i * (resV + 1) + j;
+        const b = a + 1;
+        const c = (i + 1) * (resV + 1) + j;
+        const d = c + 1;
+        indices.push(a, c, b);
+        indices.push(b, c, d);
+      }
+    }
+    return { positions, normals, indices };
+  }
+  remapU(t) {
+    return this.knotsU[this.degreeU] + t * (this.knotsU[this.nU] - this.knotsU[this.degreeU]);
+  }
+  remapV(t) {
+    return this.knotsV[this.degreeV] + t * (this.knotsV[this.nV] - this.knotsV[this.degreeV]);
+  }
+}
+function nurbsSurface(controlGrid, options) {
+  const surface = new NurbsSurface(controlGrid, options);
+  const thickness = (options == null ? void 0 : options.thickness) ?? 1;
+  const resolution = (options == null ? void 0 : options.resolution) ?? 32;
+  return buildShapeFromCompilePlan(
+    createOwnedShapeCompilePlan({
+      kind: "nurbsSurface",
+      controlGrid: surface.controlGrid.map(
+        (row) => row.map(([x, y, z]) => [x, y, z])
+      ),
+      weightsGrid: surface.weightsGrid.map((row) => [...row]),
+      knotsU: [...surface.knotsU],
+      knotsV: [...surface.knotsV],
+      degreeU: surface.degreeU,
+      degreeV: surface.degreeV,
+      thickness,
+      resolution
+    }, "nurbsSurface")
+  );
+}
 let _simplifier = null;
 async function initMeshoptimizer() {
   if (_simplifier) return;
@@ -6314,6 +6724,8 @@ function sampleSweepPath(path2, edgeLengthHint) {
       return sweepPathToPolyline(path2, resolveCurveSampleCount(edgeLengthHint, path2.chordLength));
     case "quintic-hermite":
       return sweepPathToPolyline(path2, resolveCurveSampleCount(edgeLengthHint, path2.chordLength));
+    case "nurbs":
+      return sweepPathToPolyline(path2, edgeLengthHint != null ? Math.max(16, Math.round(path2.controlPoints.length * 12 / Math.max(0.1, edgeLengthHint))) : 48);
   }
 }
 function clamp$7(v, lo, hi) {
@@ -7173,7 +7585,7 @@ let _wasm = null;
 async function initManifoldWasm() {
   if (_wasm) return _wasm;
   performance.mark("manifold:start");
-  const Module = (await import("./manifold-D7o0N50J.js")).default;
+  const Module = (await import("./manifold-DBckbFgx.js")).default;
   performance.mark("manifold:imported");
   const wasm = await Module();
   wasm.setup();
@@ -7195,74 +7607,105 @@ function isManifoldCapableBackend(b) {
 }
 _a2 = SHAPE_BACKEND_MARKER;
 const _ManifoldShapeBackend = class _ManifoldShapeBackend {
-  constructor(manifold) {
+  constructor(manifoldOrResource) {
     __publicField(this, _a2, true);
-    this.manifold = manifold;
+    __publicField(this, "resource");
+    __publicField(this, "released", false);
+    this.resource = "refCount" in manifoldOrResource ? manifoldOrResource : {
+      manifold: manifoldOrResource,
+      refCount: 1,
+      disposed: false
+    };
+  }
+  getLiveManifold(apiName = "ManifoldShapeBackend") {
+    if (this.released || this.resource.disposed) {
+      throw new Error(`${apiName}: manifold backend was already disposed`);
+    }
+    return this.resource.manifold;
   }
   clone() {
-    return new _ManifoldShapeBackend(this.manifold);
+    this.resource.refCount += 1;
+    return new _ManifoldShapeBackend(this.resource);
   }
   translate(x, y, z) {
-    return new _ManifoldShapeBackend(this.manifold.translate(x, y, z));
+    return new _ManifoldShapeBackend(this.getLiveManifold("translate()").translate(x, y, z));
   }
   rotate(x, y, z) {
-    return new _ManifoldShapeBackend(this.manifold.rotate(x, y, z));
+    return new _ManifoldShapeBackend(this.getLiveManifold("rotate()").rotate(x, y, z));
   }
   transform(m) {
-    return new _ManifoldShapeBackend(this.manifold.transform(m));
+    return new _ManifoldShapeBackend(this.getLiveManifold("transform()").transform(m));
   }
   scale(v) {
-    return new _ManifoldShapeBackend(this.manifold.scale(v));
+    return new _ManifoldShapeBackend(this.getLiveManifold("scale()").scale(v));
   }
   mirror(normal) {
-    return new _ManifoldShapeBackend(this.manifold.mirror(normal));
+    return new _ManifoldShapeBackend(this.getLiveManifold("mirror()").mirror(normal));
   }
   split(other) {
-    const [inside, outside] = this.manifold.split(requireManifoldShapeBackend(other, "ShapeBackend.split()"));
+    const [inside, outside] = this.getLiveManifold("split()").split(requireManifoldShapeBackend(other, "ShapeBackend.split()"));
     return [new _ManifoldShapeBackend(inside), new _ManifoldShapeBackend(outside)];
   }
   splitByPlane(normal, originOffset) {
-    const [inside, outside] = this.manifold.splitByPlane(normal, originOffset);
+    const [inside, outside] = this.getLiveManifold("splitByPlane()").splitByPlane(normal, originOffset);
     return [new _ManifoldShapeBackend(inside), new _ManifoldShapeBackend(outside)];
   }
   trimByPlane(normal, originOffset) {
-    return new _ManifoldShapeBackend(this.manifold.trimByPlane(normal, originOffset));
+    return new _ManifoldShapeBackend(this.getLiveManifold("trimByPlane()").trimByPlane(normal, originOffset));
   }
   simplify(tolerance) {
-    return new _ManifoldShapeBackend(this.manifold.simplify(tolerance));
+    return new _ManifoldShapeBackend(this.getLiveManifold("simplify()").simplify(tolerance));
   }
   boundingBox() {
-    return this.manifold.boundingBox();
+    return this.getLiveManifold("boundingBox()").boundingBox();
   }
   volume() {
-    return this.manifold.volume();
+    return this.getLiveManifold("volume()").volume();
   }
   surfaceArea() {
-    return this.manifold.surfaceArea();
+    return this.getLiveManifold("surfaceArea()").surfaceArea();
   }
   minGap(other, searchLength) {
-    return this.manifold.minGap(requireManifoldShapeBackend(other, "ShapeBackend.minGap()"), searchLength);
+    return this.getLiveManifold("minGap()").minGap(requireManifoldShapeBackend(other, "ShapeBackend.minGap()"), searchLength);
   }
   isEmpty() {
-    return this.manifold.isEmpty();
+    return this.getLiveManifold("isEmpty()").isEmpty();
   }
   numBodies() {
-    return this.manifold.decompose().length;
+    const parts = this.getLiveManifold("numBodies()").decompose();
+    try {
+      return parts.length;
+    } finally {
+      parts.forEach((part) => {
+        var _a3;
+        return (_a3 = part.delete) == null ? void 0 : _a3.call(part);
+      });
+    }
   }
   numTri() {
-    return this.manifold.numTri();
+    return this.getLiveManifold("numTri()").numTri();
   }
   getMesh() {
-    return this.manifold.getMesh();
+    return this.getLiveManifold("getMesh()").getMesh();
   }
   slice(offset2) {
-    return this.manifold.slice(offset2);
+    return this.getLiveManifold("slice()").slice(offset2);
   }
   project() {
-    return this.manifold.project();
+    return this.getLiveManifold("project()").project();
   }
   requireManifold() {
-    return this.manifold;
+    return this.getLiveManifold("requireManifold()");
+  }
+  dispose() {
+    var _a3, _b3;
+    if (this.released) return;
+    this.released = true;
+    this.resource.refCount = Math.max(0, this.resource.refCount - 1);
+    if (this.resource.refCount === 0 && !this.resource.disposed) {
+      this.resource.disposed = true;
+      (_b3 = (_a3 = this.resource.manifold).delete) == null ? void 0 : _b3.call(_a3);
+    }
   }
 };
 let ManifoldShapeBackend = _ManifoldShapeBackend;
@@ -7498,6 +7941,12 @@ function rotateVector(v, axis, c, s) {
     v[2] * c + kCrossV[2] * s + axis[2] * kDotV * (1 - c)
   ];
 }
+function disposeWasmObject(value) {
+  if (value != null && typeof value.delete === "function") value.delete();
+}
+function disposeWasmObjects(values) {
+  for (const value of values) disposeWasmObject(value);
+}
 function applyProfileCompileTransform(crossSection, step) {
   switch (step.kind) {
     case "translate":
@@ -7513,7 +7962,9 @@ function applyProfileCompileTransform(crossSection, step) {
 function applyProfileCompileTransforms(crossSection, transforms) {
   let out = crossSection;
   for (const step of transforms) {
+    const prev = out;
     out = applyProfileCompileTransform(out, step);
+    if (out !== prev) disposeWasmObject(prev);
   }
   return out;
 }
@@ -7525,17 +7976,21 @@ function lowerProfileBooleanCompilePlan(plan, wasm) {
   if (profiles.length === 1) {
     return applyProfileCompileTransforms(profiles[0], plan.transforms);
   }
-  const combined = (() => {
-    switch (plan.op) {
-      case "union":
-        return wasm.CrossSection.union(profiles);
-      case "difference":
-        return wasm.CrossSection.difference(profiles);
-      case "intersection":
-        return wasm.CrossSection.intersection(profiles);
-    }
-  })();
-  return applyProfileCompileTransforms(combined, plan.transforms);
+  try {
+    const combined = (() => {
+      switch (plan.op) {
+        case "union":
+          return wasm.CrossSection.union(profiles);
+        case "difference":
+          return wasm.CrossSection.difference(profiles);
+        case "intersection":
+          return wasm.CrossSection.intersection(profiles);
+      }
+    })();
+    return applyProfileCompileTransforms(combined, plan.transforms);
+  } finally {
+    disposeWasmObjects(profiles);
+  }
 }
 function lowerProfileCompilePlanToCrossSection(plan, wasm) {
   switch (plan.kind) {
@@ -7543,7 +7998,9 @@ function lowerProfileCompilePlanToCrossSection(plan, wasm) {
       return applyProfileCompileTransforms(wasm.CrossSection.square([plan.width, plan.height], true), plan.transforms);
     case "roundedRect": {
       const radius = Math.min(plan.radius, plan.width / 2, plan.height / 2);
-      const crossSection = wasm.CrossSection.square([plan.width - 2 * radius, plan.height - 2 * radius], true).offset(radius, "Round");
+      const base = wasm.CrossSection.square([plan.width - 2 * radius, plan.height - 2 * radius], true);
+      const crossSection = base.offset(radius, "Round");
+      if (crossSection !== base) disposeWasmObject(base);
       return applyProfileCompileTransforms(crossSection, plan.transforms);
     }
     case "circle":
@@ -7552,15 +8009,29 @@ function lowerProfileCompilePlanToCrossSection(plan, wasm) {
       return applyProfileCompileTransforms(new wasm.CrossSection([plan.points]), plan.transforms);
     case "boolean":
       return lowerProfileBooleanCompilePlan(plan, wasm);
-    case "offset":
-      return applyProfileCompileTransforms(
-        lowerProfileCompilePlanToCrossSection(plan.base, wasm).offset(plan.delta, plan.join),
-        plan.transforms
-      );
+    case "offset": {
+      const base = lowerProfileCompilePlanToCrossSection(plan.base, wasm);
+      try {
+        return applyProfileCompileTransforms(base.offset(plan.delta, plan.join), plan.transforms);
+      } finally {
+        disposeWasmObject(base);
+      }
+    }
     case "project": {
-      const projected = lowerShapeCompilePlanToManifold(plan.sourceShape, wasm).transform(planeFrameToWorldToPlaneMatrix(plan.plane)).project();
-      return applyProfileCompileTransforms(projected, plan.transforms);
+      const source = lowerShapeCompilePlanToManifold(plan.sourceShape, wasm);
+      try {
+        const transformed = source.transform(planeFrameToWorldToPlaneMatrix(plan.plane));
+        try {
+          return applyProfileCompileTransforms(transformed.project(), plan.transforms);
+        } finally {
+          if (transformed !== source) disposeWasmObject(transformed);
+        }
+      } finally {
+        disposeWasmObject(source);
+      }
     }
+    case "pathProfile":
+      return applyProfileCompileTransforms(new wasm.CrossSection([plan.points]), plan.transforms);
     default:
       assertExhaustive(plan);
   }
@@ -7584,7 +8055,9 @@ function applyShapeCompileTransform(manifold, step) {
 function applyShapeCompileTransforms(manifold, steps) {
   let out = manifold;
   for (const step of steps) {
+    const prev = out;
     out = applyShapeCompileTransform(out, step);
+    if (out !== prev) disposeWasmObject(prev);
   }
   return out;
 }
@@ -7599,22 +8072,36 @@ function lowerShapeBooleanCompilePlan(plan, wasm) {
   if (shapes.length === 1) {
     return shapes[0];
   }
-  switch (plan.op) {
-    case "union":
-      return wasm.Manifold.union(shapes);
-    case "difference":
-      return wasm.Manifold.difference(shapes);
-    case "intersection":
-      return wasm.Manifold.intersection(shapes);
+  try {
+    switch (plan.op) {
+      case "union":
+        return wasm.Manifold.union(shapes);
+      case "difference":
+        return wasm.Manifold.difference(shapes);
+      case "intersection":
+        return wasm.Manifold.intersection(shapes);
+    }
+  } finally {
+    disposeWasmObjects(shapes);
   }
 }
 function lowerShapeTrimByPlaneCompilePlan(plan, wasm) {
-  return lowerShapeCompilePlanToManifold(plan.base, wasm).trimByPlane([plan.normalX, plan.normalY, plan.normalZ], plan.originOffset);
+  const base = lowerShapeCompilePlanToManifold(plan.base, wasm);
+  try {
+    return base.trimByPlane([plan.normalX, plan.normalY, plan.normalZ], plan.originOffset);
+  } finally {
+    disposeWasmObject(base);
+  }
 }
 function lowerShapeLoftCompilePlan(plan, wasm) {
-  const inputPolygons = plan.profiles.map(
-    (profile) => lowerProfileCompilePlanToCrossSection(profile, wasm).toPolygons()
-  );
+  const inputPolygons = plan.profiles.map((profile) => {
+    const crossSection = lowerProfileCompilePlanToCrossSection(profile, wasm);
+    try {
+      return crossSection.toPolygons();
+    } finally {
+      disposeWasmObject(crossSection);
+    }
+  });
   if (inputPolygons.length >= 2) {
     const stitched = loftStitched(inputPolygons, plan.heights, wasm);
     if (stitched) return stitched;
@@ -7623,7 +8110,14 @@ function lowerShapeLoftCompilePlan(plan, wasm) {
   return lowerSdfToManifold(levelSetFieldToStandardSdf(input.sdf), input.bounds, input.edgeLength, wasm);
 }
 function lowerShapeSweepCompilePlan(plan, wasm) {
-  const profilePolygons = lowerProfileCompilePlanToCrossSection(plan.profile, wasm).toPolygons();
+  const crossSection = lowerProfileCompilePlanToCrossSection(plan.profile, wasm);
+  const profilePolygons = (() => {
+    try {
+      return crossSection.toPolygons();
+    } finally {
+      disposeWasmObject(crossSection);
+    }
+  })();
   const pathPoints = sweepPathToPolylineAdaptive(plan.path, plan.pathSamples ?? 48);
   const up = [plan.up[0], plan.up[1], plan.up[2]];
   const stitched = sweepStitched(profilePolygons, pathPoints, up, wasm);
@@ -7635,77 +8129,318 @@ function lowerShapeSweepCompilePlan(plan, wasm) {
   });
   return lowerSdfToManifold(levelSetFieldToStandardSdf(input.sdf), input.bounds, input.edgeLength, wasm);
 }
-function lowerFromSlicesToManifold(plan, wasm) {
-  if (plan.groups.length === 0) throw new Error("Shape.fromSlices requires at least one slice");
-  const groupSolids = [];
-  for (const group2 of plan.groups) {
+function buildPlaneFrame(normal) {
+  const [nx, ny, nz] = normal;
+  if (Math.abs(nz) > 1 - 1e-8) {
+    const s = nz > 0 ? 1 : -1;
+    return { u: [1, 0, 0], v: [0, s, 0] };
+  }
+  if (Math.abs(ny) > 1 - 1e-8) {
+    const s = ny > 0 ? 1 : -1;
+    return { u: [1, 0, 0], v: [0, 0, s] };
+  }
+  if (Math.abs(nx) > 1 - 1e-8) {
+    const s = nx > 0 ? 1 : -1;
+    return { u: [0, 1, 0], v: [0, 0, s] };
+  }
+  const ref = Math.abs(nx) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+  const uRaw = [
+    ref[1] * nz - ref[2] * ny,
+    ref[2] * nx - ref[0] * nz,
+    ref[0] * ny - ref[1] * nx
+  ];
+  const uLen = Math.sqrt(uRaw[0] * uRaw[0] + uRaw[1] * uRaw[1] + uRaw[2] * uRaw[2]);
+  const u = [uRaw[0] / uLen, uRaw[1] / uLen, uRaw[2] / uLen];
+  const v = [
+    ny * u[2] - nz * u[1],
+    nz * u[0] - nx * u[2],
+    nx * u[1] - ny * u[0]
+  ];
+  return { u, v };
+}
+function dot3$5(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function profileHalfWidths(loops, height) {
+  let maxPos = 0;
+  let maxNeg = 0;
+  for (const loop of loops) {
+    for (let i = 0; i < loop.length; i++) {
+      const [x0, y0] = loop[i];
+      const [x1, y1] = loop[(i + 1) % loop.length];
+      if (y0 <= height && y1 > height || y1 <= height && y0 > height) {
+        const t = (height - y0) / (y1 - y0);
+        const x = x0 + t * (x1 - x0);
+        if (x > maxPos) maxPos = x;
+        if (x < 0 && -x > maxNeg) maxNeg = -x;
+      }
+    }
+  }
+  return [maxPos, maxNeg];
+}
+function interpolatedHalfWidths(slices, spineCoord) {
+  if (slices.length === 1) return profileHalfWidths(slices[0].polygons, spineCoord);
+  if (spineCoord <= slices[0].offset) return profileHalfWidths(slices[0].polygons, spineCoord);
+  if (spineCoord >= slices[slices.length - 1].offset) {
+    return profileHalfWidths(slices[slices.length - 1].polygons, spineCoord);
+  }
+  let seg = 0;
+  while (seg + 1 < slices.length && spineCoord > slices[seg + 1].offset) seg++;
+  const t = (spineCoord - slices[seg].offset) / (slices[seg + 1].offset - slices[seg].offset);
+  const [p0, n0] = profileHalfWidths(slices[seg].polygons, spineCoord);
+  const [p1, n1] = profileHalfWidths(slices[seg + 1].polygons, spineCoord);
+  return [p0 * (1 - t) + p1 * t, n0 * (1 - t) + n1 * t];
+}
+function lowerMultiGroupFromSlicesToManifold(plan, wasm) {
+  const n0 = plan.groups[0].normal;
+  const n1 = plan.groups[1].normal;
+  const spineRaw = [
+    n0[1] * n1[2] - n0[2] * n1[1],
+    n0[2] * n1[0] - n0[0] * n1[2],
+    n0[0] * n1[1] - n0[1] * n1[0]
+  ];
+  const spineLen = Math.sqrt(spineRaw[0] ** 2 + spineRaw[1] ** 2 + spineRaw[2] ** 2);
+  if (spineLen < 1e-8) {
+    throw new Error("Shape.fromSlices: multi-group slices must have non-parallel normals.");
+  }
+  const spine = [spineRaw[0] / spineLen, spineRaw[1] / spineLen, spineRaw[2] / spineLen];
+  const preparedGroups = plan.groups.map((group2) => {
+    const frame = buildPlaneFrame(group2.normal);
     const sorted = [...group2.slices].sort((a, b) => a.offset - b.offset);
-    const [nx, ny, nz] = group2.normal;
-    let solid;
-    if (sorted.length === 1) {
-      const cross2 = lowerProfileCompilePlanToCrossSection(sorted[0].profile, wasm);
-      const extrudeHalf = 500;
-      solid = cross2.extrude(2 * extrudeHalf).translate(0, 0, sorted[0].offset - extrudeHalf);
-    } else {
-      const polygons = sorted.map((s) => lowerProfileCompilePlanToCrossSection(s.profile, wasm).toPolygons());
-      const heights = sorted.map((s) => s.offset);
-      const stitched = polygons.length >= 2 ? loftStitched(polygons, heights, wasm) : null;
-      if (stitched) {
-        solid = stitched;
+    const sliceData = sorted.map((s) => {
+      const cross2 = lowerProfileCompilePlanToCrossSection(s.profile, wasm);
+      try {
+        const polygons = cross2.toPolygons();
+        return { offset: s.offset, polygons, sdf: compilePolygonsSdf(polygons) };
+      } finally {
+        disposeWasmObject(cross2);
+      }
+    });
+    const spineOnU = Math.abs(dot3$5(spine, frame.u));
+    const spineOnV = Math.abs(dot3$5(spine, frame.v));
+    const vIsSpine = spineOnV >= spineOnU;
+    const measAxis = vIsSpine ? frame.u : frame.v;
+    const spineAxis = vIsSpine ? frame.v : frame.u;
+    const spineSign = dot3$5(spine, spineAxis) >= 0 ? 1 : -1;
+    let minMeas = Infinity;
+    let maxMeas = -Infinity;
+    let minSpine = Infinity;
+    let maxSpine = -Infinity;
+    for (const s of sliceData) {
+      for (const loop of s.polygons) {
+        for (const [x, y] of loop) {
+          const meas = vIsSpine ? x : y;
+          const sp = vIsSpine ? y : x;
+          if (meas < minMeas) minMeas = meas;
+          if (meas > maxMeas) maxMeas = meas;
+          if (sp < minSpine) minSpine = sp;
+          if (sp > maxSpine) maxSpine = sp;
+        }
+      }
+    }
+    const sliceDataForRayCast = vIsSpine ? sliceData : sliceData.map((s) => ({
+      offset: s.offset,
+      polygons: s.polygons.map((loop) => loop.map(([x, y]) => [y, x]))
+    }));
+    const profileSdf2d = (u, v) => {
+      if (sliceData.length === 1) return sliceData[0].sdf(u, v);
+      const w = vIsSpine ? v : u;
+      const offsets = sliceData.map((s) => s.offset);
+      if (w <= offsets[0]) return sliceData[0].sdf(u, v);
+      if (w >= offsets[offsets.length - 1]) return sliceData[sliceData.length - 1].sdf(u, v);
+      let seg = 0;
+      while (seg + 1 < offsets.length && w > offsets[seg + 1]) seg++;
+      const t = (w - offsets[seg]) / (offsets[seg + 1] - offsets[seg]);
+      return sliceData[seg].sdf(u, v) * (1 - t) + sliceData[seg + 1].sdf(u, v) * t;
+    };
+    return {
+      normal: group2.normal,
+      frame,
+      measAxis,
+      spineSign,
+      vIsSpine,
+      sliceData: sliceDataForRayCast,
+      profileSdf2d,
+      minMeas,
+      maxMeas,
+      minSpine,
+      maxSpine
+    };
+  });
+  const sdf3d = (p2) => {
+    const spineCoord = dot3$5(p2, spine);
+    let sumRhoSq = 0;
+    let profileCapSdf = Infinity;
+    for (const g of preparedGroups) {
+      const measCoord = dot3$5(p2, g.measAxis);
+      const localSpine = spineCoord * g.spineSign;
+      const [wPos, wNeg] = interpolatedHalfWidths(g.sliceData, localSpine);
+      let rho;
+      if (wPos <= 1e-10 && wNeg <= 1e-10) {
+        rho = 2;
+      } else if (measCoord >= 0) {
+        rho = wPos > 1e-10 ? measCoord / wPos : 2;
       } else {
-        const input = buildLoftLevelSetInput(polygons, heights, {
-          edgeLength: plan.edgeLength,
-          boundsPadding: plan.boundsPadding
-        });
-        solid = lowerSdfToManifold(levelSetFieldToStandardSdf(input.sdf), input.bounds, input.edgeLength, wasm);
+        rho = wNeg > 1e-10 ? -measCoord / wNeg : 2;
       }
+      sumRhoSq += rho * rho;
+      const u = dot3$5(p2, g.frame.u);
+      const v = dot3$5(p2, g.frame.v);
+      const dProfile = g.profileSdf2d(u, v);
+      profileCapSdf = Math.min(profileCapSdf, dProfile);
     }
-    if (Math.abs(nx) > 1e-10 || Math.abs(ny) > 1e-10 || nz < 0) {
-      if (Math.abs(nx) < 1e-10 && Math.abs(ny) < 1e-10 && nz < 0) {
-        solid = solid.rotate([180, 0, 0]);
+    const rhoSdf = sumRhoSq - 1;
+    const capSdf = -profileCapSdf;
+    return Math.max(rhoSdf, capSdf);
+  };
+  let bMinX = -Infinity;
+  let bMaxX = Infinity;
+  let bMinY = -Infinity;
+  let bMaxY = Infinity;
+  let bMinZ = -Infinity;
+  let bMaxZ = Infinity;
+  for (const g of preparedGroups) {
+    for (let axis = 0; axis < 3; axis++) {
+      const mc = g.measAxis[axis];
+      if (Math.abs(mc) > 0.5) {
+        const lo = mc > 0 ? g.minMeas : -g.maxMeas;
+        const hi = mc > 0 ? g.maxMeas : -g.minMeas;
+        if (axis === 0) {
+          bMinX = Math.max(bMinX, lo);
+          bMaxX = Math.min(bMaxX, hi);
+        } else if (axis === 1) {
+          bMinY = Math.max(bMinY, lo);
+          bMaxY = Math.min(bMaxY, hi);
+        } else {
+          bMinZ = Math.max(bMinZ, lo);
+          bMaxZ = Math.min(bMaxZ, hi);
+        }
+      }
+    }
+  }
+  let spineMin = -Infinity;
+  let spineMax = Infinity;
+  for (const g of preparedGroups) {
+    const lo = g.spineSign > 0 ? g.minSpine : -g.maxSpine;
+    const hi = g.spineSign > 0 ? g.maxSpine : -g.minSpine;
+    spineMin = Math.max(spineMin, lo);
+    spineMax = Math.min(spineMax, hi);
+  }
+  for (let axis = 0; axis < 3; axis++) {
+    if (Math.abs(spine[axis]) > 0.5) {
+      const lo = spine[axis] > 0 ? spineMin : -spineMax;
+      const hi = spine[axis] > 0 ? spineMax : -spineMin;
+      if (axis === 0) {
+        bMinX = Math.max(bMinX, lo);
+        bMaxX = Math.min(bMaxX, hi);
+      } else if (axis === 1) {
+        bMinY = Math.max(bMinY, lo);
+        bMaxY = Math.min(bMaxY, hi);
       } else {
-        const ax = -ny;
-        const ay = nx;
-        const len = Math.sqrt(ax * ax + ay * ay);
-        const c = nz;
-        const s = len;
-        const ux = ax / len;
-        const uy = ay / len;
-        const m00 = c + ux * ux * (1 - c);
-        const m01 = ux * uy * (1 - c);
-        const m02 = uy * s;
-        const m10 = uy * ux * (1 - c);
-        const m11 = c + uy * uy * (1 - c);
-        const m12 = -ux * s;
-        const m20 = -uy * s;
-        const m21 = ux * s;
-        const m22 = c;
-        solid = solid.transform([m00, m01, m02, 0, m10, m11, m12, 0, m20, m21, m22, 0, 0, 0, 0, 1]);
-      }
-    }
-    groupSolids.push(solid);
-  }
-  if (groupSolids.length === 1) return groupSolids[0];
-  let result = groupSolids[0];
-  for (let i = 1; i < groupSolids.length; i++) {
-    result = result.intersect(groupSolids[i]);
+        bMinZ = Math.max(bMinZ, lo);
+        bMaxZ = Math.min(bMaxZ, hi);
+      }
+    }
   }
-  return result;
+  const fallback = 100;
+  if (!isFinite(bMinX)) bMinX = -fallback;
+  if (!isFinite(bMaxX)) bMaxX = fallback;
+  if (!isFinite(bMinY)) bMinY = -fallback;
+  if (!isFinite(bMaxY)) bMaxY = fallback;
+  if (!isFinite(bMinZ)) bMinZ = -fallback;
+  if (!isFinite(bMaxZ)) bMaxZ = fallback;
+  const pad = plan.boundsPadding;
+  const bounds = {
+    min: [bMinX - pad, bMinY - pad, bMinZ - pad],
+    max: [bMaxX + pad, bMaxY + pad, bMaxZ + pad]
+  };
+  return lowerSdfToManifold(sdf3d, bounds, plan.edgeLength, wasm);
+}
+function lowerFromSlicesToManifold(plan, wasm) {
+  if (plan.groups.length === 0) throw new Error("Shape.fromSlices requires at least one slice");
+  if (plan.groups.length > 1) {
+    return lowerMultiGroupFromSlicesToManifold(plan, wasm);
+  }
+  const group2 = plan.groups[0];
+  const sorted = [...group2.slices].sort((a, b) => a.offset - b.offset);
+  const [nx, ny, nz] = group2.normal;
+  let solid;
+  if (sorted.length === 1) {
+    const cross2 = lowerProfileCompilePlanToCrossSection(sorted[0].profile, wasm);
+    const extrudeHalf = 500;
+    try {
+      const extruded = cross2.extrude(2 * extrudeHalf);
+      solid = applyShapeCompileTransforms(extruded, [{ kind: "translate", x: 0, y: 0, z: sorted[0].offset - extrudeHalf }]);
+    } finally {
+      disposeWasmObject(cross2);
+    }
+  } else {
+    const polygons = sorted.map((s) => {
+      const crossSection = lowerProfileCompilePlanToCrossSection(s.profile, wasm);
+      try {
+        return crossSection.toPolygons();
+      } finally {
+        disposeWasmObject(crossSection);
+      }
+    });
+    const heights = sorted.map((s) => s.offset);
+    const stitched = polygons.length >= 2 ? loftStitched(polygons, heights, wasm) : null;
+    if (stitched) {
+      solid = stitched;
+    } else {
+      const input = buildLoftLevelSetInput(polygons, heights, {
+        edgeLength: plan.edgeLength,
+        boundsPadding: plan.boundsPadding
+      });
+      solid = lowerSdfToManifold(levelSetFieldToStandardSdf(input.sdf), input.bounds, input.edgeLength, wasm);
+    }
+  }
+  if (Math.abs(nx) > 1e-10 || Math.abs(ny) > 1e-10 || nz < 0) {
+    if (Math.abs(nx) < 1e-10 && Math.abs(ny) < 1e-10 && nz < 0) {
+      const prev = solid;
+      solid = solid.rotate([180, 0, 0]);
+      if (solid !== prev) disposeWasmObject(prev);
+    } else {
+      const ax = -ny;
+      const ay = nx;
+      const len = Math.sqrt(ax * ax + ay * ay);
+      const c = nz;
+      const s = len;
+      const ux = ax / len;
+      const uy = ay / len;
+      const m00 = c + ux * ux * (1 - c);
+      const m01 = ux * uy * (1 - c);
+      const m02 = uy * s;
+      const m10 = uy * ux * (1 - c);
+      const m11 = c + uy * uy * (1 - c);
+      const m12 = -ux * s;
+      const m20 = -uy * s;
+      const m21 = ux * s;
+      const m22 = c;
+      const prev = solid;
+      solid = solid.transform([m00, m01, m02, 0, m10, m11, m12, 0, m20, m21, m22, 0, 0, 0, 0, 1]);
+      if (solid !== prev) disposeWasmObject(prev);
+    }
+  }
+  return solid;
 }
 function lowerShapeVariableSweepCompilePlan(plan, wasm) {
-  const sectionPolygons = plan.sections.map((s) => ({
-    t: s.t,
-    polygons: lowerProfileCompilePlanToCrossSection(s.profile, wasm).toPolygons()
-  }));
-  const input = buildVariableSweepLevelSetInput(
-    sectionPolygons,
-    plan.path,
-    {
-      edgeLength: plan.edgeLength,
-      boundsPadding: plan.boundsPadding,
-      up: [plan.up[0], plan.up[1], plan.up[2]]
+  const sectionPolygons = plan.sections.map((s) => {
+    const crossSection = lowerProfileCompilePlanToCrossSection(s.profile, wasm);
+    try {
+      return {
+        t: s.t,
+        polygons: crossSection.toPolygons()
+      };
+    } finally {
+      disposeWasmObject(crossSection);
     }
-  );
+  });
+  const input = buildVariableSweepLevelSetInput(sectionPolygons, plan.path, {
+    edgeLength: plan.edgeLength,
+    boundsPadding: plan.boundsPadding,
+    up: [plan.up[0], plan.up[1], plan.up[2]]
+  });
   return lowerSdfToManifold(levelSetFieldToStandardSdf(input.sdf), input.bounds, input.edgeLength, wasm);
 }
 function lowerShapeFilletCompilePlan(plan, wasm) {
@@ -7716,13 +8451,15 @@ function lowerShapeFilletCompilePlan(plan, wasm) {
       `fillet2d() currently supports ${selection.selection.edgeName} only with quadrant [${selection.selection.quadrant[0]}, ${selection.selection.quadrant[1]}].`
     );
   }
-  return applyFilletSelectionToManifold(
-    lowerShapeCompilePlanToManifold(plan.base, wasm),
-    selection.selection,
-    plan.radius,
-    plan.segments,
-    wasm
-  );
+  const base = lowerShapeCompilePlanToManifold(plan.base, wasm);
+  try {
+    const result = applyFilletSelectionToManifold(base, selection.selection, plan.radius, plan.segments, wasm);
+    if (result !== base) disposeWasmObject(base);
+    return result;
+  } catch (error) {
+    disposeWasmObject(base);
+    throw error;
+  }
 }
 function lowerShapeChamferCompilePlan(plan, wasm) {
   const selection = resolveSupportedEdgeFeatureSelection(plan.base, plan.edge);
@@ -7732,7 +8469,15 @@ function lowerShapeChamferCompilePlan(plan, wasm) {
       `chamfer2d() currently supports ${selection.selection.edgeName} only with quadrant [${selection.selection.quadrant[0]}, ${selection.selection.quadrant[1]}].`
     );
   }
-  return applyChamferSelectionToManifold(lowerShapeCompilePlanToManifold(plan.base, wasm), selection.selection, plan.size, wasm);
+  const base = lowerShapeCompilePlanToManifold(plan.base, wasm);
+  try {
+    const result = applyChamferSelectionToManifold(base, selection.selection, plan.size, wasm);
+    if (result !== base) disposeWasmObject(base);
+    return result;
+  } catch (error) {
+    disposeWasmObject(base);
+    throw error;
+  }
 }
 function edgeSegmentToSelection(segment) {
   const { start, end, direction: axis, normalA, normalB, convex } = segment;
@@ -7827,7 +8572,9 @@ function lowerFilletEdgesCompilePlan(plan, wasm) {
     try {
       const selection = edgeSegmentToSelection(seg);
       const apply = seg.convex ? applyFilletSelectionToManifold : applyConcaveFilletSelectionToManifold;
-      manifold = apply(manifold, selection, plan.radius, plan.segments, wasm);
+      const prev = manifold;
+      manifold = apply(prev, selection, plan.radius, plan.segments, wasm);
+      if (manifold !== prev) disposeWasmObject(prev);
     } catch {
     }
   }
@@ -7852,7 +8599,9 @@ function lowerChamferEdgesCompilePlan(plan, wasm) {
     try {
       const selection = edgeSegmentToSelection(seg);
       const apply = seg.convex ? applyChamferSelectionToManifold : applyConcaveChamferSelectionToManifold;
-      manifold = apply(manifold, selection, plan.size, wasm);
+      const prev = manifold;
+      manifold = apply(prev, selection, plan.size, wasm);
+      if (manifold !== prev) disposeWasmObject(prev);
     } catch {
     }
   }
@@ -7861,24 +8610,34 @@ function lowerChamferEdgesCompilePlan(plan, wasm) {
 function lowerShapeCompilePlanToManifold(plan, wasm) {
   switch (plan.kind) {
     case "box":
-      return wasm.Manifold.cube([plan.x, plan.y, plan.z], false).translate(-plan.x / 2, -plan.y / 2, 0);
+      return applyShapeCompileTransforms(wasm.Manifold.cube([plan.x, plan.y, plan.z], false), [
+        { kind: "translate", x: -plan.x / 2, y: -plan.y / 2, z: 0 }
+      ]);
     case "cylinder":
       return wasm.Manifold.cylinder(plan.height, plan.radius, plan.radiusTop ?? -1, plan.segments ?? 0, false);
     case "sphere":
       return wasm.Manifold.sphere(plan.radius, plan.segments ?? 0);
     case "torus": {
       const circle2 = wasm.CrossSection.circle(plan.minorRadius, plan.segments ?? 0);
-      const translated = circle2.translate([plan.majorRadius, 0]);
-      return translated.revolve(plan.segments ?? 0, 360);
+      try {
+        const translated = circle2.translate([plan.majorRadius, 0]);
+        try {
+          return translated.revolve(plan.segments ?? 0, 360);
+        } finally {
+          disposeWasmObject(translated);
+        }
+      } finally {
+        disposeWasmObject(circle2);
+      }
+    }
+    case "extrude": {
+      const profile = lowerProfileCompilePlanToCrossSection(plan.profile, wasm);
+      try {
+        return profile.extrude(plan.height, plan.twistSegments ?? 0, plan.twist ?? 0, plan.scaleTop, false);
+      } finally {
+        disposeWasmObject(profile);
+      }
     }
-    case "extrude":
-      return lowerProfileCompilePlanToCrossSection(plan.profile, wasm).extrude(
-        plan.height,
-        plan.twistSegments ?? 0,
-        plan.twist ?? 0,
-        plan.scaleTop,
-        false
-      );
     case "sheetMetal":
       return lowerShapeCompilePlanToManifold(lowerSheetMetalBasePlan(plan.model, plan.output), wasm);
     case "shell": {
@@ -7896,8 +8655,14 @@ function lowerShapeCompilePlanToManifold(plan, wasm) {
       if (!lowered.ok) throw new Error(lowered.reason);
       return lowerShapeCompilePlanToManifold(lowered.plan, wasm);
     }
-    case "revolve":
-      return lowerProfileCompilePlanToCrossSection(plan.profile, wasm).revolve(plan.segments ?? 0, plan.degrees);
+    case "revolve": {
+      const profile = lowerProfileCompilePlanToCrossSection(plan.profile, wasm);
+      try {
+        return profile.revolve(plan.segments ?? 0, plan.degrees);
+      } finally {
+        disposeWasmObject(profile);
+      }
+    }
     case "loft":
       return lowerShapeLoftCompilePlan(plan, wasm);
     case "sweep":
@@ -7932,6 +8697,10 @@ function lowerShapeCompilePlanToManifold(plan, wasm) {
     }
     case "fromSlices":
       return lowerFromSlicesToManifold(plan, wasm);
+    case "nurbsSurface":
+      return lowerNurbsSurfaceToManifold(plan, wasm);
+    case "importedStep":
+      throw new Error(`importStep("${plan.filePath}") requires the OCCT backend. Add setActiveBackend('occt') at the top of your script.`);
     default:
       assertExhaustive(plan);
   }
@@ -7958,17 +8727,27 @@ function lowerSdfToManifold(evalFn, bounds, edgeLength2, wasm) {
     vertProperties: vertProps6,
     triVerts
   });
-  return new wasm.Manifold(wasmMesh);
+  try {
+    return new wasm.Manifold(wasmMesh);
+  } finally {
+    disposeWasmObject(wasmMesh);
+  }
 }
 function simplifySdfMesh(triVerts, vertProperties, edgeLength2, wasm) {
   const maxError = edgeLength2 * 0.15;
   for (const ratio of [0.5, 0.75]) {
     let simplified = simplifyMesh(triVerts, vertProperties, ratio, maxError);
     simplified = filterDegenerateTriangles(simplified);
+    let mesh = null;
+    let manifold = null;
     try {
-      new wasm.Manifold(new wasm.Mesh({ numProp: 3, vertProperties, triVerts: simplified }));
+      mesh = new wasm.Mesh({ numProp: 3, vertProperties, triVerts: simplified });
+      manifold = new wasm.Manifold(mesh);
       return simplified;
     } catch {
+    } finally {
+      disposeWasmObject(manifold);
+      disposeWasmObject(mesh);
     }
   }
   return triVerts;
@@ -8028,6 +8807,58 @@ function projectVerticesToSurfaceWithNormals(vertProperties, sdfFn, out6) {
     }
   }
 }
+function lowerNurbsSurfaceToManifold(plan, wasm) {
+  const surface = new NurbsSurface(plan.controlGrid, {
+    degreeU: plan.degreeU,
+    degreeV: plan.degreeV,
+    weights: plan.weightsGrid,
+    knotsU: plan.knotsU,
+    knotsV: plan.knotsV
+  });
+  const res = plan.resolution;
+  const { positions, normals, indices } = surface.tessellate(res, res);
+  const thickness = plan.thickness;
+  const numVerts = positions.length;
+  const allPositions = [];
+  for (const [x, y, z] of positions) allPositions.push(x, y, z);
+  for (let i = 0; i < numVerts; i++) {
+    const [x, y, z] = positions[i];
+    const [nx, ny, nz] = normals[i];
+    allPositions.push(x - nx * thickness, y - ny * thickness, z - nz * thickness);
+  }
+  const allIndices = [];
+  for (const idx of indices) allIndices.push(idx);
+  for (let i = 0; i < indices.length; i += 3) {
+    allIndices.push(indices[i] + numVerts, indices[i + 2] + numVerts, indices[i + 1] + numVerts);
+  }
+  const resU = res, resV = res;
+  for (let i = 0; i < resU; i++) {
+    const a = i * (resV + 1);
+    const b = (i + 1) * (resV + 1);
+    allIndices.push(a, a + numVerts, b, b, a + numVerts, b + numVerts);
+    const c = a + resV;
+    const d = b + resV;
+    allIndices.push(c, d, c + numVerts, d, d + numVerts, c + numVerts);
+  }
+  for (let j = 0; j < resV; j++) {
+    const a = j;
+    const b = j + 1;
+    allIndices.push(a, b, a + numVerts, b, b + numVerts, a + numVerts);
+    const c = resU * (resV + 1) + j;
+    const d = c + 1;
+    allIndices.push(c, c + numVerts, d, d, c + numVerts, d + numVerts);
+  }
+  const mesh = new wasm.Mesh({
+    numProp: 3,
+    vertProperties: new Float32Array(allPositions),
+    triVerts: new Uint32Array(allIndices)
+  });
+  try {
+    return new wasm.Manifold(mesh);
+  } finally {
+    disposeWasmObject(mesh);
+  }
+}
 function lowerImportedMeshToManifold(fileData, format, filePath, wasm) {
   const parsed = parseMeshFile(fileData, format);
   if (parsed.triVerts.length === 0) {
@@ -8046,6 +8877,8 @@ function lowerImportedMeshToManifold(fileData, format, filePath, wasm) {
     throw new Error(
       `importMesh("${filePath}"): Manifold rejected the mesh — it may be non-manifold (non-watertight, self-intersecting, or degenerate). Original error: ${e instanceof Error ? e.message : String(e)}`
     );
+  } finally {
+    disposeWasmObject(wasmMesh);
   }
 }
 function lowerShapeCompilePlanToShapeBackend(plan, wasm) {
@@ -8480,6 +9313,8 @@ function summarizeProfile(profile) {
       return "offset profile";
     case "project":
       return "projected profile";
+    case "pathProfile":
+      return `path profile (${profile.edges.length} edges)`;
     default:
       assertExhaustive(profile);
   }
@@ -10102,6 +10937,8 @@ function resolveShapeFaceTableInternal(plan, owner) {
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "nurbsSurface":
+    case "importedStep":
       return emptyFaceTable();
     default:
       assertExhaustive(plan);
@@ -10605,7 +11442,7 @@ function transformPortMap(ports, matrix) {
   }
   return out;
 }
-function computeConnectFrame(childBase, childPort, parentPort, flip, childAlign = "middle", parentAlign = "middle") {
+function computeConnectFrame(childBase, childPort, parentPort, _flip, childAlign = "middle", parentAlign = "middle") {
   const childAlignPt = resolvePortAlignPoint(childPort, childAlign);
   const parentAlignPt = resolvePortAlignPoint(parentPort, parentAlign);
   const cI = childBase.point(childAlignPt);
@@ -10613,7 +11450,9 @@ function computeConnectFrame(childBase, childPort, parentPort, flip, childAlign
   const cUp = normalize3$2(childBase.vector(childPort.up));
   const cRight = normalize3$2(cross3$3(cAxis, cUp));
   const pOrigin = parentAlignPt;
-  const pAxis = flip ? negate3$1(parentPort.axis) : [...parentPort.axis];
+  const jointKind = childPort.kind ?? parentPort.kind;
+  const faceToFace = jointKind !== "prismatic";
+  const pAxis = faceToFace ? negate3$1(parentPort.axis) : [...parentPort.axis];
   const pUp = [...parentPort.up];
   const pRight = normalize3$2(cross3$3(pAxis, pUp));
   const r00 = pRight[0] * cRight[0] + pUp[0] * cUp[0] + pAxis[0] * cAxis[0];
@@ -12409,6 +13248,8 @@ function rootTopologyRewritePropagation(plan) {
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "nurbsSurface":
+    case "importedStep":
       return null;
     default:
       assertExhaustive(plan);
@@ -12832,6 +13673,8 @@ function rootPlanPropagation(plan) {
     case "importedMesh":
     case "sdf":
     case "fromSlices":
+    case "nurbsSurface":
+    case "importedStep":
       return void 0;
     default:
       assertExhaustive(plan);
@@ -14676,46 +15519,82 @@ function injectVoronoiSurfaceChild(children) {
     return child;
   });
 }
-var sdf = /* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  SdfShape,
-  SurfacePattern,
-  basketWeave,
-  bend,
-  blend,
+const sdf = {
+  /** Create an SDF sphere centered at the origin. */
+  sphere: sphere$1,
+  /** Create an SDF box centered at the origin with given full dimensions (not half-extents). */
   box: box$1,
-  brick,
+  /** Create an SDF cylinder centered at the origin, axis along Z. */
+  cylinder: cylinder$1,
+  /** Create an SDF torus centered at the origin, lying in the XY plane. */
+  torus: torus$1,
+  /** Create an SDF capsule centered at the origin, axis along Z. */
   capsule,
+  /** Create an SDF cone with base at z=0 and tip at z=height. */
   cone,
-  cylinder: cylinder$1,
-  diamond,
-  fromFunction,
+  /** Smooth union — blends shapes together with a smooth transition radius. */
+  smoothUnion,
+  /** Smooth difference — smoothly subtracts b from a. */
+  smoothDifference,
+  /** Smooth intersection — smoothly intersects a and b. */
+  smoothIntersection,
+  /** Morph between two SDF shapes. t=0 → a, t=1 → b. */
+  morph,
+  /**
+   * Spatially blend between two SDF patterns.
+   * The blend function receives (x, y, z) and returns 0..1:
+   * 0 = fully pattern `a`, 1 = fully pattern `b`.
+   */
+  blend,
+  /** Gyroid TPMS lattice — the most common lattice for additive manufacturing. */
   gyroid,
-  honeycomb,
-  knurl,
+  /** Schwarz-P TPMS lattice — isotropic pore structure. */
+  schwarzP,
+  /** Diamond TPMS lattice — stiffest TPMS structure. */
+  diamond,
+  /** Lidinoid TPMS lattice — visually distinct from gyroid, popular in research and art. */
   lidinoid,
-  morph,
+  /** 3D Simplex noise field — produces organic, natural-looking displacements. */
   noise,
+  /** 3D Voronoi pattern — organic cellular structures like bone, coral, or soap bubbles. */
+  voronoi,
+  /** Honeycomb (hexagonal) lattice pattern. Intersect with your shape to apply. */
+  honeycomb,
+  /** Sinusoidal wave ridges — parallel ridges along an axis. */
+  waves,
+  /** Knurl pattern — crossed helical grooves for grips and handles. */
+  knurl,
+  /** Perforated plate pattern — regular array of cylindrical holes. */
   perforated,
-  repeat,
+  /** Fish/dragon scale pattern — overlapping circular scales in hex-packed rows. */
   scales,
-  schwarzP,
-  smoothDifference,
-  smoothIntersection,
-  smoothUnion,
-  sphere: sphere$1,
-  torus: torus$1,
+  /** Brick/stone wall pattern — running bond with mortar grooves. */
+  brick,
+  /** Grid lattice pattern — two families of infinite slabs crossing at 90°. */
+  weave,
+  /** Basket weave surface pattern — threads with over-under crossings in UV space. Returns a SurfacePattern for use with `.surfaceDisplace()`. */
+  basketWeave,
+  /** Twist an SDF shape around the Z axis. */
   twist,
-  voronoi,
-  waves,
-  weave
-});
+  /** Bend an SDF shape around the Z axis. */
+  bend,
+  /** Repeat an SDF shape in space. */
+  repeat,
+  /** A 2D surface pattern — a heightmap function for use with `.surfaceDisplace()`. */
+  SurfacePattern,
+  /** Create an SDF shape from an arbitrary distance function. You must provide bounds since the function is opaque. */
+  fromFunction
+};
 async function initKernel() {
   initOCCT().catch((e) => console.warn("[kernel] OCCT background init failed:", e));
   const [manifoldModule] = await Promise.all([initManifoldWasm(), initMeshoptimizer()]);
   return manifoldModule;
 }
 let _activeBackend = "manifold";
+let _runtimeWarn = (msg) => console.warn(msg);
+function setRuntimeWarnSink(fn) {
+  _runtimeWarn = fn;
+}
 function unwrapShapeLike(value) {
   if (value instanceof Shape) return value;
   if (value && typeof value === "object" && typeof value.toShape === "function") {
@@ -15873,6 +16752,33 @@ class Shape {
   static _unwrap(value) {
     return unwrapShapeLike(value);
   }
+  /**
+   * Warn if a boolean operation had no geometric effect.
+   * Compares volumes before and after; if they match within tolerance, the operation was a no-op.
+   */
+  static _checkBooleanNoOp(op, base, result, others) {
+    try {
+      if (op === "intersection") {
+        if (result.isEmpty()) {
+          _runtimeWarn(
+            `intersection() produced an empty shape — the operands may not overlap.`
+          );
+        }
+        return;
+      }
+      if (op === "difference") {
+        const volBefore = base.volume();
+        const volAfter = result.volume();
+        const tol = Math.max(volBefore * 1e-4, 1e-3);
+        if (Math.abs(volBefore - volAfter) < tol) {
+          _runtimeWarn(
+            `subtract() had no effect — the tool may not overlap the base shape. Base vol=${volBefore.toFixed(1)}mm³, result vol=${volAfter.toFixed(1)}mm³`
+          );
+        }
+      }
+    } catch {
+    }
+  }
   /** Union this shape with others (additive boolean). Method form of union(). */
   add(...others) {
     const shapes = [
@@ -15910,7 +16816,7 @@ class Shape {
       "boolean:difference",
       (owner) => buildBooleanTopologyRewritePropagation("difference", owner, operandPlans)
     );
-    return setShapeCompilePlanInternal(
+    const resultShape = setShapeCompilePlanInternal(
       setShapeGeometryInfoInternal(
         withBaseDimensions(this, buildShapeFromCompilePlan(nextPlan, this.colorHex)),
         mergeGeometryInfos(
@@ -15921,6 +16827,8 @@ class Shape {
       ),
       nextPlan
     );
+    Shape._checkBooleanNoOp("difference", this, resultShape, shapes.slice(1));
+    return resultShape;
   }
   /** Keep only the overlap with other shapes. Method form of intersection(). */
   intersect(...others) {
@@ -15939,7 +16847,7 @@ class Shape {
       "boolean:intersection",
       (owner) => buildBooleanTopologyRewritePropagation("intersection", owner, operandPlans)
     );
-    return setShapeCompilePlanInternal(
+    const resultShape = setShapeCompilePlanInternal(
       setShapeGeometryInfoInternal(
         withMergedDimensions(shapes, buildShapeFromCompilePlan(nextPlan, this.colorHex)),
         mergeGeometryInfos(
@@ -15950,6 +16858,8 @@ class Shape {
       ),
       nextPlan
     );
+    Shape._checkBooleanNoOp("intersection", this, resultShape, shapes.slice(1));
+    return resultShape;
   }
   /** Alias for add() — matches the free-function union() naming. */
   union(...others) {
@@ -16551,6 +17461,7 @@ function intersection(...inputs) {
 var define_process_env_default = {};
 let _wasm_solve = null;
 let _wasm_get_profile = null;
+let _solverMemory = null;
 let _sessionApi = null;
 function getSessionApi() {
   return _sessionApi;
@@ -16850,9 +17761,11 @@ async function initSolverWasm() {
         }
         if (!wasmPath) throw new Error("solver_bg.wasm not found — run: npm run build:solver");
         const wasmBytes = readFileSync(wasmPath);
-        await solverModule.default(wasmBytes);
+        const exports$1 = await solverModule.default(wasmBytes);
+        _solverMemory = (exports$1 == null ? void 0 : exports$1.memory) ?? null;
       } else {
-        await solverModule.default();
+        const exports$1 = await solverModule.default();
+        _solverMemory = (exports$1 == null ? void 0 : exports$1.memory) ?? null;
       }
       performance.mark("solver:ready");
       performance.measure("solver:import", "solver:start", "solver:imported");
@@ -17839,7 +18752,7 @@ class MateBuilder {
     return this.constraints.reduce((sum, c) => sum + (CONSTRAINT_EQUATIONS[c.type] ?? 0), 0);
   }
 }
-let _collected$5 = null;
+let _collected$7 = null;
 const isAxis = (value) => value === "x" || value === "y" || value === "z";
 const normalizeDirection = (value, label) => {
   if (value === "radial" || isAxis(value)) return value;
@@ -17898,16 +18811,16 @@ const mergeDirective = (target, patch, label) => {
   return out;
 };
 function resetExplodeView() {
-  _collected$5 = null;
+  _collected$7 = null;
 }
 function getCollectedExplodeView() {
-  return _collected$5 ? cloneOptions(_collected$5) : null;
+  return _collected$7 ? cloneOptions(_collected$7) : null;
 }
 function explodeView(options = {}) {
   if (!options || typeof options !== "object") {
     throw new Error("explodeView(options) expects an options object");
   }
-  const next = _collected$5 ? cloneOptions(_collected$5) : {};
+  const next = _collected$7 ? cloneOptions(_collected$7) : {};
   if (options.enabled !== void 0) {
     if (typeof options.enabled !== "boolean") throw new Error("explodeView.enabled must be a boolean");
     next.enabled = options.enabled;
@@ -17955,9 +18868,9 @@ function explodeView(options = {}) {
     });
     next.byPath = byPath;
   }
-  _collected$5 = next;
+  _collected$7 = next;
 }
-let _collected$4 = null;
+let _collected$6 = null;
 const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
 const isVec3$1 = (value) => Array.isArray(value) && value.length === 3 && isFiniteNumber(value[0]) && isFiniteNumber(value[1]) && isFiniteNumber(value[2]);
 const normalizeAxis = (axis) => {
@@ -18247,22 +19160,22 @@ const cloneCollected = (value) => ({
   defaultAnimation: value.defaultAnimation
 });
 function resetJointsView() {
-  _collected$4 = null;
+  _collected$6 = null;
 }
 function getCollectedJointsView() {
-  return _collected$4 ? cloneCollected(_collected$4) : null;
+  return _collected$6 ? cloneCollected(_collected$6) : null;
 }
 function saveJointsView() {
-  return _collected$4 ? cloneCollected(_collected$4) : null;
+  return _collected$6 ? cloneCollected(_collected$6) : null;
 }
 function restoreJointsView(state) {
-  _collected$4 = state;
+  _collected$6 = state;
 }
 function jointsView(options = {}) {
   if (!options || typeof options !== "object") {
     throw new Error("jointsView(options) expects an options object");
   }
-  const next = _collected$4 ? cloneCollected(_collected$4) : { joints: [], couplings: [], animations: [] };
+  const next = _collected$6 ? cloneCollected(_collected$6) : { joints: [], couplings: [], animations: [] };
   if (options.enabled !== void 0) {
     if (typeof options.enabled !== "boolean") {
       throw new Error("jointsView.enabled must be a boolean");
@@ -18317,7 +19230,7 @@ function jointsView(options = {}) {
   if (next.defaultAnimation && !next.animations.some((animation) => animation.name === next.defaultAnimation)) {
     throw new Error(`jointsView defaultAnimation "${next.defaultAnimation}" does not exist in animations`);
   }
-  _collected$4 = next;
+  _collected$6 = next;
 }
 function bomToCsv(rows) {
   const header = ["part", "qty", "material", "process", "tolerance", "notes"];
@@ -19024,8 +19937,16 @@ class Assembly {
    * origins (child connector lands exactly on parent connector) and derives the joint frame
    * and axis from the connector geometry — no manual `frame` or `axis` math needed.
    *
+   * **Face-to-face convention:** Connectors always meet face-to-face, like a USB plug
+   * meeting a socket. Each connector's axis points "outward" from its part. When two
+   * connectors mate, the system brings them together so their axes oppose (anti-parallel).
+   * This is the same convention used by `matchTo()`.
+   *
+   * For a revolute joint (hinge), both connectors' axes should point outward from their
+   * respective parts along the hinge line. For a prismatic joint (slider), both axes
+   * should point along the slide direction from their part's perspective.
+   *
    * The joint type is inferred from the connector's `kind` field if not specified in `options`.
-   * Use `flip: true` for mirrored parts whose connector axis is reflected.
    *
    * When connectors are defined with `start`/`end`, you can control which point on each
    * connector meets via `align` / `parentAlign` / `childAlign` (`'start'`, `'middle'`, `'end'`).
@@ -19037,20 +19958,22 @@ class Assembly {
    * **Example**
    *
    * ```ts
-   * const mech = assembly("Arm")
-   *   .addPart("Base", base)
-   *   .addPart("Link", link)
-   *   .connect("Base.top", "Link.shoulder", {
-   *     as: "J1",
-   *     min: -90, max: 90, default: 0,
-   *   });
-   *
-   * return mech.solve({ J1: 45 }).toGroup();
+   * // Hinge: both axes point outward along the hinge line
+   * const frame = box(100, 10, 80).withConnectors({
+   *   hinge: connector("hinge", { origin: [0, 0, 40], axis: [0, 0, 1] }),
+   * });
+   * const door = box(60, 4, 80).withConnectors({
+   *   hinge: connector("hinge", { origin: [0, 0, 40], axis: [0, 0, -1] }),
+   * });
+   * assembly("Door")
+   *   .addPart("Frame", frame)
+   *   .addPart("Door", door)
+   *   .connect("Frame.hinge", "Door.hinge", { as: "swing", min: 0, max: 110 });
    * ```
    *
    * @param parentPortRef - `"PartName.connectorName"` on the parent side
    * @param childPortRef - `"PartName.connectorName"` on the child side
-   * @param options - `as` (joint name), `type`, `min`, `max`, `default`, `flip`, `align`, effort, velocity, etc.
+   * @param options - `as` (joint name), `type`, `min`, `max`, `default`, `align`, effort, velocity, etc.
    * @returns `this` for chaining
    * @see {@link match} for typed connector matching with gender/type validation
    * @category Connectors
@@ -19067,7 +19990,7 @@ class Assembly {
     const childBase = childRecord.base;
     const childAlign = options.childAlign ?? options.align ?? "middle";
     const parentAlign = options.parentAlign ?? options.align ?? "middle";
-    const { frame, axis } = computeConnectFrame(childBase, child.port, parent.port, options.flip ?? false, childAlign, parentAlign);
+    const { frame, axis } = computeConnectFrame(childBase, child.port, parent.port, false, childAlign, parentAlign);
     const min2 = options.min ?? child.port.min ?? parent.port.min;
     const max2 = options.max ?? child.port.max ?? parent.port.max;
     this._usedPortRefs.add(parentPortRef);
@@ -19985,12 +20908,12 @@ function bom(quantity, description, opts) {
     metadata
   });
 }
-let _collected$3 = [];
+let _collected$5 = [];
 function resetCutPlanes() {
-  _collected$3 = [];
+  _collected$5 = [];
 }
 function getCollectedCutPlanes() {
-  return _collected$3.slice();
+  return _collected$5.slice();
 }
 function normalizeExcludedObjectNames(input) {
   if (input === void 0) return void 0;
@@ -20006,7 +20929,29 @@ function cutPlane(name, normal, offsetOrOptions = 0, maybeOptions = {}) {
   const offset2 = Number.isFinite(rawOffset) ? rawOffset : 0;
   const options = usingOffsetArg ? maybeOptions : offsetOrOptions;
   const excludeObjectNames = normalizeExcludedObjectNames(options.exclude);
-  _collected$3.push({ name, normal, offset: offset2, excludeObjectNames });
+  _collected$5.push({ name, normal, offset: offset2, excludeObjectNames });
+}
+let _collected$4 = [];
+let _counter$1 = 0;
+function resetMocks() {
+  _collected$4 = [];
+  _counter$1 = 0;
+}
+function getCollectedMocks() {
+  return _collected$4.slice();
+}
+function mock(shape, name) {
+  if (!shape || typeof shape !== "object") {
+    throw new Error("mock(shape): shape must be a Shape");
+  }
+  _counter$1 += 1;
+  const displayName = name && typeof name === "string" && name.trim().length > 0 ? name.trim() : `Mock ${_counter$1}`;
+  _collected$4.push({
+    id: `mock-${_counter$1}`,
+    name: displayName,
+    shape
+  });
+  return shape;
 }
 const DEFAULT_PROFILE = {
   bedX: 220,
@@ -21374,11 +22319,13 @@ Shape.prototype.cutout = function cutout(sketch, opts = {}) {
   return shapeCutout(this, sketch, opts);
 };
 let _params = [];
+let _stringParams = [];
 let _listParams = [];
 let _overrides = {};
 let _scopeStack = [];
 function resetParams() {
   _params = [];
+  _stringParams = [];
   _listParams = [];
   _scopeStack = [];
 }
@@ -21388,6 +22335,9 @@ function setParamOverrides(overrides) {
 function getCollectedParams() {
   return _params;
 }
+function getCollectedStringParams() {
+  return _stringParams;
+}
 function getCollectedListParams() {
   return _listParams;
 }
@@ -21404,6 +22354,11 @@ function hasOwn(obj, key) {
 }
 function param(name, defaultValue, opts = {}) {
   var _a3;
+  if (typeof defaultValue !== "number") {
+    throw new Error(
+      `param("${name}"): defaultValue must be a number, got ${typeof defaultValue}. For text parameters, use Param.string("${name}", ${JSON.stringify(defaultValue)}).`
+    );
+  }
   const scope = _scopeStack[_scopeStack.length - 1];
   const scopedName = (scope == null ? void 0 : scope.namePrefix) ? `${scope.namePrefix} / ${name}` : name;
   const scopedLocal = scope == null ? void 0 : scope.localOverrides;
@@ -21473,6 +22428,32 @@ function choiceParam(name, defaultValue, choices) {
   }
   return choices[index];
 }
+function stringParam(name, defaultValue, opts = {}) {
+  var _a3;
+  if (typeof defaultValue !== "string") {
+    throw new Error(`Param.string("${name}"): defaultValue must be a string, got ${typeof defaultValue}.`);
+  }
+  const scope = _scopeStack[_scopeStack.length - 1];
+  const scopedName = (scope == null ? void 0 : scope.namePrefix) ? `${scope.namePrefix} / ${name}` : name;
+  const scopedLocal = scope == null ? void 0 : scope.localOverrides;
+  const hasLocalOverride = !!(scopedLocal && Object.prototype.hasOwnProperty.call(scopedLocal, name));
+  if (hasLocalOverride) (_a3 = scope.consumedKeys) == null ? void 0 : _a3.add(name);
+  const rawOverride = (hasLocalOverride ? scopedLocal[name] : void 0) ?? _overrides[scopedName] ?? _overrides[name];
+  const value = typeof rawOverride === "string" ? rawOverride : defaultValue;
+  const maxLength = opts.maxLength;
+  const clamped = maxLength !== void 0 ? value.slice(0, maxLength) : value;
+  if (!hasLocalOverride) {
+    _stringParams.push({ name: scopedName, value: clamped, defaultValue, maxLength });
+  }
+  return clamped;
+}
+const Param = {
+  number: param,
+  string: stringParam,
+  bool: boolParam,
+  choice: choiceParam,
+  list: listParam
+};
 function listParam(name, defaultItems, opts) {
   if (!Array.isArray(defaultItems)) throw new Error(`listParam("${name}"): defaultItems must be an array`);
   const scope = _scopeStack[_scopeStack.length - 1];
@@ -22051,6 +23032,24 @@ function catmullRom2D$1(p0, p1, p2, p3, t, tension) {
   const h11 = ttt - tt;
   return [h00 * p1[0] + h10 * m1x + h01 * p2[0] + h11 * m2x, h00 * p1[1] + h10 * m1y + h01 * p2[1] + h11 * m2y];
 }
+function sampleBSpline2D(controlPoints, weights, degree, tol = DEFAULT_TOLERANCE$1) {
+  const n = controlPoints.length;
+  const knots = generateClampedKnots(n, degree);
+  let polyLen = 0;
+  for (let i = 1; i < n; i++) {
+    polyLen += Math.hypot(controlPoints[i][0] - controlPoints[i - 1][0], controlPoints[i][1] - controlPoints[i - 1][1]);
+  }
+  const count = Math.max(8, Math.min(256, Math.ceil(polyLen / tol)));
+  const uMin = knots[degree];
+  const uMax = knots[n];
+  const pts = new Array(count);
+  for (let i = 0; i < count; i++) {
+    const t = i / (count - 1);
+    const u = uMin + t * (uMax - uMin);
+    pts[i] = deBoor2D(controlPoints, weights, knots, degree, u);
+  }
+  return pts;
+}
 function ensureCCW(pts) {
   let signedArea2 = 0;
   for (let i = 0; i < pts.length; i++) {
@@ -22425,6 +23424,82 @@ class PathBuilder {
     this.y = last[1];
     return this;
   }
+  // ── NURBS / exact curves ──────────────────────────────────────────────────
+  /**
+   * Rational B-spline edge to (x, y) with explicit control points and weights.
+   *
+   * The control points define the B-spline shape between the current position
+   * and (x, y). The current position is NOT included in `controlPoints` — it is
+   * automatically prepended. The endpoint (x, y) is the last control point.
+   *
+   * @param controlPoints — interior + endpoint control points (endpoint = last)
+   * @param opts.weights — rational weights (default: all 1.0)
+   * @param opts.degree — B-spline degree (default: control point count - 1, capped at 3)
+   */
+  nurbsTo(controlPoints, opts) {
+    if (controlPoints.length < 1) throw new Error("nurbsTo: need at least 1 control point (the endpoint)");
+    const allPts = [[this.x, this.y], ...controlPoints];
+    const n = allPts.length;
+    const degree = (opts == null ? void 0 : opts.degree) ?? Math.min(n - 1, 3);
+    const weights = (opts == null ? void 0 : opts.weights) ?? new Array(n).fill(1);
+    if (weights.length !== n) throw new Error(`nurbsTo: weights.length (${weights.length}) must match total control points (${n})`);
+    const last = controlPoints[controlPoints.length - 1];
+    this.segs.push({ kind: "bspline", x: last[0], y: last[1], controlPoints: allPts, weights, degree });
+    const prevPt = allPts[n - 2];
+    const tdx = last[0] - prevPt[0];
+    const tdy = last[1] - prevPt[1];
+    const tlen = Math.hypot(tdx, tdy);
+    if (tlen > 1e-9) {
+      this.dirX = tdx / tlen;
+      this.dirY = tdy / tlen;
+    }
+    this.x = last[0];
+    this.y = last[1];
+    return this;
+  }
+  /**
+   * Exact circular arc to (x, y) using a rational quadratic NURBS.
+   *
+   * Unlike `arcTo()` which tessellates to a polyline, this preserves the
+   * exact arc definition. When extruded through the OCCT backend, it produces
+   * a true cylindrical face — not a faceted approximation.
+   *
+   * @param x — endpoint X
+   * @param y — endpoint Y
+   * @param opts.radius — arc radius (default: auto-computed from chord)
+   * @param opts.clockwise — winding direction (default: false = CCW)
+   */
+  exactArcTo(x, y, opts) {
+    const clockwise = (opts == null ? void 0 : opts.clockwise) ?? false;
+    const dx = x - this.x;
+    const dy = y - this.y;
+    const chordLen = Math.hypot(dx, dy);
+    if (chordLen < 1e-9) return this;
+    const radius = (opts == null ? void 0 : opts.radius) ?? chordLen;
+    if (radius < chordLen / 2 - 1e-9) throw new Error("exactArcTo: radius too small for the chord");
+    const mx = (this.x + x) / 2;
+    const my = (this.y + y) / 2;
+    let nx = -dy / chordLen;
+    let ny = dx / chordLen;
+    if (clockwise) {
+      nx = -nx;
+      ny = -ny;
+    }
+    const h = Math.sqrt(Math.max(0, radius * radius - chordLen / 2 * (chordLen / 2)));
+    const cx = mx + nx * h;
+    const cy = my + ny * h;
+    const halfAngle = Math.asin(Math.min(1, chordLen / (2 * radius)));
+    const w = Math.cos(halfAngle);
+    const smx = (this.x + x) / 2 - cx;
+    const smy = (this.y + y) / 2 - cy;
+    const smLen = Math.hypot(smx, smy);
+    const shoulderX = cx + smx / smLen * radius;
+    const shoulderY = cy + smy / smLen * radius;
+    return this.nurbsTo(
+      [[shoulderX, shoulderY], [x, y]],
+      { weights: [1, w, 1], degree: 2 }
+    );
+  }
   // ── Corner modifiers ──────────────────────────────────────────────────────
   /**
    * Round the last corner (the junction between the previous two segments)
@@ -22749,6 +23824,11 @@ class PathBuilder {
         const last = seg.points[seg.points.length - 1];
         px = last[0];
         py = last[1];
+      } else if (seg.kind === "bspline") {
+        const sampled = sampleBSpline2D(seg.controlPoints, seg.weights, seg.degree);
+        for (let i = 1; i < sampled.length; i++) pts.push(sampled[i]);
+        px = seg.x;
+        py = seg.y;
       }
     }
     return pts;
@@ -22785,11 +23865,23 @@ class PathBuilder {
   close() {
     const subPaths = this.splitSubPaths();
     if (subPaths.length === 0) throw new Error("Path needs at least 3 points");
+    const hasBSpline = this.segs.some((s) => s.kind === "bspline");
     const tessellated = subPaths.map((segs) => this.tessellateSegs(segs));
     const outer = tessellated[0];
     if (outer.length < 3) throw new Error("Path needs at least 3 points");
     ensureCCW(outer);
-    let result = polygon(outer);
+    let result;
+    if (hasBSpline && subPaths.length === 1) {
+      const edges = this.buildProfileEdges(subPaths[0]);
+      result = buildSketchFromCompileProfilePlan({
+        kind: "pathProfile",
+        points: outer,
+        edges,
+        transforms: []
+      });
+    } else {
+      result = polygon(outer);
+    }
     for (let i = 1; i < tessellated.length; i++) {
       const hole2 = tessellated[i];
       if (hole2.length < 3) continue;
@@ -22916,6 +24008,48 @@ class PathBuilder {
     if (current.length > 0) paths.push(current);
     return paths;
   }
+  /** Build semantic ProfileEdge array from path segments (for pathProfile compile plan). */
+  buildProfileEdges(segs) {
+    const edges = [];
+    let px = 0, py = 0;
+    for (const seg of segs) {
+      if (seg.kind === "move") {
+        px = seg.x;
+        py = seg.y;
+      } else if (seg.kind === "line") {
+        edges.push({ kind: "line", x1: px, y1: py, x2: seg.x, y2: seg.y });
+        px = seg.x;
+        py = seg.y;
+      } else if (seg.kind === "arc") {
+        edges.push({ kind: "arc", x1: px, y1: py, x2: seg.x, y2: seg.y, cx: seg.cx, cy: seg.cy, clockwise: seg.clockwise });
+        px = seg.x;
+        py = seg.y;
+      } else if (seg.kind === "bspline") {
+        edges.push({
+          kind: "bspline",
+          controlPoints: seg.controlPoints,
+          weights: seg.weights,
+          knots: generateClampedKnots(seg.controlPoints.length, seg.degree),
+          degree: seg.degree
+        });
+        px = seg.x;
+        py = seg.y;
+      } else {
+        edges.push({ kind: "line", x1: px, y1: py, x2: seg.x, y2: seg.y });
+        px = seg.x;
+        py = seg.y;
+      }
+    }
+    if (segs.length > 0) {
+      const first = segs[0];
+      const firstX = first.kind === "move" ? first.x : 0;
+      const firstY = first.kind === "move" ? first.y : 0;
+      if (Math.hypot(px - firstX, py - firstY) > 1e-9) {
+        edges.push({ kind: "line", x1: px, y1: py, x2: firstX, y2: firstY });
+      }
+    }
+    return edges;
+  }
   /** Tessellate a sub-path (sequence of segments). */
   tessellateSegs(segs) {
     const pts = [];
@@ -22943,6 +24077,11 @@ class PathBuilder {
         const last = seg.points[seg.points.length - 1];
         px = last[0];
         py = last[1];
+      } else if (seg.kind === "bspline") {
+        const sampled = sampleBSpline2D(seg.controlPoints, seg.weights, seg.degree);
+        for (let i = 1; i < sampled.length; i++) pts.push(sampled[i]);
+        px = seg.x;
+        py = seg.y;
       }
     }
     return pts;
@@ -24229,7 +25368,20 @@ function spurGear(options) {
     profile = difference2d(profile, circle2d(normalized.boreDiameter * 0.5, Math.max(48, normalized.teeth * 2)));
   }
   const shape = sketchExtrude(profile, normalized.faceWidth);
-  return attachGearMeta(shape, meta2);
+  const shapeWithConnectors = shape.withConnectors({
+    bore: connectorFactory("gear-bore", {
+      origin: [0, 0, normalized.faceWidth / 2],
+      axis: [0, 0, 1],
+      kind: "revolute"
+    }, {
+      module: normalized.module,
+      teeth: normalized.teeth,
+      pitchRadius: meta2.pitchRadius,
+      outerRadius: meta2.outerRadius,
+      faceWidth: normalized.faceWidth
+    })
+  });
+  return attachGearMeta(shapeWithConnectors, meta2);
 }
 function normalizeSideGearOptions(options) {
   let normalizedSpur;
@@ -24315,7 +25467,23 @@ function sideGear(options) {
     );
     shape = shape.subtract(bore);
   }
-  return attachGearMeta(shape, meta2);
+  const boreZ = normalized.side === "top" ? zBands.bodyMinZ : zBands.bodyMaxZ;
+  const boreAxis = normalized.side === "top" ? [0, 0, -1] : [0, 0, 1];
+  const shapeWithConnectors = shape.withConnectors({
+    bore: connectorFactory("gear-bore", {
+      origin: [0, 0, boreZ],
+      axis: boreAxis,
+      kind: "revolute"
+    }, {
+      module: normalized.module,
+      teeth: normalized.teeth,
+      pitchRadius: meta2.pitchRadius,
+      outerRadius: meta2.outerRadius,
+      faceWidth: normalized.faceWidth,
+      toothSide: normalized.side
+    })
+  });
+  return attachGearMeta(shapeWithConnectors, meta2);
 }
 function faceGear(options) {
   try {
@@ -24432,7 +25600,20 @@ function ringGear(options) {
   }
   const profile = difference2d(ringBlank, union2d(...spaces));
   const shape = sketchExtrude(profile, normalized.faceWidth);
-  return attachGearMeta(shape, meta2);
+  const shapeWithConnectors = shape.withConnectors({
+    bore: connectorFactory("ring-bore", {
+      origin: [0, 0, normalized.faceWidth / 2],
+      axis: [0, 0, 1]
+    }, {
+      module: normalized.module,
+      teeth: normalized.teeth,
+      pitchRadius,
+      innerRadius: tipRadius,
+      outerRadius: normalized.outerRadius,
+      faceWidth: normalized.faceWidth
+    })
+  });
+  return attachGearMeta(shapeWithConnectors, meta2);
 }
 function rackGear(options) {
   if (!isFinitePositive(options.module)) throw new Error('rackGear: "module" must be > 0');
@@ -24483,7 +25664,8 @@ function rackGear(options) {
     teethSketches.push(sketchTranslate(toothSketch, cx, 0));
   }
   const span = (options.teeth - 1) * pitch + halfRoot * 2;
-  const base = sketchTranslate(rect(span + module * 2, baseHeight), 0, -dedendum - baseHeight * 0.5);
+  const length4 = span + module * 2;
+  const base = sketchTranslate(rect(length4, baseHeight), 0, -dedendum - baseHeight * 0.5);
   const profile = union2d(base, ...teethSketches);
   const shape = sketchExtrude(profile, options.faceWidth);
   const meta2 = {
@@ -24502,7 +25684,20 @@ function rackGear(options) {
     backlash,
     centered: false
   };
-  return attachGearMeta(shape, meta2);
+  const shapeWithConnectors = shape.withConnectors({
+    teeth: connectorFactory("rack-teeth", {
+      origin: [0, 0, options.faceWidth / 2],
+      axis: [1, 0, 0],
+      up: [0, 1, 0],
+      kind: "prismatic"
+    }, {
+      module,
+      teeth: options.teeth,
+      faceWidth: options.faceWidth,
+      length: length4
+    })
+  });
+  return attachGearMeta(shapeWithConnectors, meta2);
 }
 function normalizeShaftAngle(label, value) {
   if (!isFinitePositive(value) || value >= 175) {
@@ -24581,7 +25776,27 @@ function bevelGear(options) {
   const shape = sketchExtrude(profile, normalized.faceWidth, {
     scaleTop: normalized.topScale
   });
-  return attachGearMeta(shape, {
+  const apexZ = normalized.module * normalized.teeth * 0.5 / Math.tan(normalized.pitchAngleRad);
+  const measurements = {
+    module: normalized.module,
+    teeth: normalized.teeth,
+    pitchRadius: meta2.pitchRadius,
+    pitchAngleDeg: normalized.pitchAngleDeg,
+    coneDistance: normalized.coneDistance,
+    faceWidth: normalized.faceWidth
+  };
+  const shapeWithConnectors = shape.withConnectors({
+    bore: connectorFactory("gear-bore", {
+      origin: [0, 0, 0],
+      axis: [0, 0, -1],
+      kind: "revolute"
+    }, measurements),
+    apex: connectorFactory("bevel-apex", {
+      origin: [0, 0, apexZ],
+      axis: [0, 0, 1]
+    }, measurements)
+  });
+  return attachGearMeta(shapeWithConnectors, {
     ...meta2,
     kind: "bevel",
     centered: false,
@@ -25063,6 +26278,70 @@ function faceGearPair(options) {
     status: pairStatusFromDiagnostics(diagnostics)
   };
 }
+function gearRatio(teethA, teethB, options) {
+  if (!Number.isFinite(teethA) || teethA <= 0) throw new Error("gearRatio: teethA must be > 0");
+  if (!Number.isFinite(teethB) || teethB <= 0) throw new Error("gearRatio: teethB must be > 0");
+  const sign = (options == null ? void 0 : options.internal) ? 1 : -1;
+  return sign * teethA / teethB;
+}
+function rackRatio(module, pinionTeeth) {
+  if (!Number.isFinite(module) || module <= 0) throw new Error("rackRatio: module must be > 0");
+  if (!Number.isFinite(pinionTeeth) || pinionTeeth <= 0) throw new Error("rackRatio: pinionTeeth must be > 0");
+  const pitchRadius = module * pinionTeeth / 2;
+  return 180 / (Math.PI * pitchRadius);
+}
+function planetaryRatio(sunTeeth, ringTeeth) {
+  if (!Number.isFinite(sunTeeth) || sunTeeth <= 0) throw new Error("planetaryRatio: sunTeeth must be > 0");
+  if (!Number.isFinite(ringTeeth) || ringTeeth <= 0) throw new Error("planetaryRatio: ringTeeth must be > 0");
+  return 1 + ringTeeth / sunTeeth;
+}
+function boltPattern(options) {
+  const sizeData = METRIC_HOLE_TABLE[options.size];
+  if (!sizeData) throw new Error(`boltPattern: unsupported size "${options.size}"`);
+  const fit = options.fit ?? "normal";
+  const dia = sizeData[fit];
+  const segments = options.segments ?? 48;
+  if (!Array.isArray(options.positions) || options.positions.length === 0) {
+    throw new Error('boltPattern: "positions" must be a non-empty array of [x, y] pairs');
+  }
+  const positions = options.positions.map((p2, i) => {
+    if (!Array.isArray(p2) || p2.length !== 2 || !Number.isFinite(p2[0]) || !Number.isFinite(p2[1])) {
+      throw new Error(`boltPattern: position[${i}] must be a finite [x, y] pair`);
+    }
+    return [p2[0], p2[1]];
+  });
+  const xs = positions.map((p2) => p2[0]);
+  const ys = positions.map((p2) => p2[1]);
+  return {
+    size: options.size,
+    dia,
+    positions,
+    minX: Math.min(...xs),
+    maxX: Math.max(...xs),
+    minY: Math.min(...ys),
+    maxY: Math.max(...ys),
+    cut(shape, depth, cutOptions = {}) {
+      if (!Number.isFinite(depth) || depth <= 0) {
+        throw new Error("boltPattern.cut: depth must be > 0");
+      }
+      const from = cutOptions.from ?? 0;
+      const cutter = fastenerHole({
+        size: options.size,
+        fit,
+        depth,
+        center: false,
+        segments,
+        counterbore: cutOptions.counterbore,
+        countersink: cutOptions.countersink
+      });
+      let result = shape;
+      for (const [x, y] of positions) {
+        result = result.subtract(cutter.translate(x, y, from));
+      }
+      return result;
+    }
+  };
+}
 function thread(diameter, pitch, length4, options) {
   const r = diameter / 2;
   const depth = (options == null ? void 0 : options.depth) ?? pitch * 0.35;
@@ -25222,7 +26501,11 @@ const partLibrary = {
   gearPair,
   bevelGearPair,
   faceGearPair,
-  sideGearPair
+  sideGearPair,
+  gearRatio,
+  rackRatio,
+  planetaryRatio,
+  boltPattern
 };
 /**
  * @license
@@ -36725,14 +38008,14 @@ class WoodBoard {
     return this._withShape(this.shape.clone());
   }
 }
-function requireFinite$3(value, name) {
+function requireFinite$5(value, name) {
   if (!Number.isFinite(value)) {
     throw new Error(`${name} must be a finite number, got ${value}`);
   }
   return value;
 }
 function requirePositive$2(value, name) {
-  requireFinite$3(value, name);
+  requireFinite$5(value, name);
   if (value <= 0) {
     throw new Error(`${name} must be positive, got ${value}`);
   }
@@ -36767,10 +38050,10 @@ function dado(host, guest, opts) {
   }
   let fromBottom;
   if (opts.fromBottom != null) {
-    fromBottom = requireFinite$3(opts.fromBottom, "fromBottom");
+    fromBottom = requireFinite$5(opts.fromBottom, "fromBottom");
   } else {
     fromBottom = host.height - opts.fromTop - channelWidth;
-    requireFinite$3(fromBottom, "computed fromBottom");
+    requireFinite$5(fromBottom, "computed fromBottom");
   }
   let dadoLength = host.width;
   let xOffset = 0;
@@ -36827,7 +38110,7 @@ function mortiseAndTenon(mortiseBoard, tenonBoard, opts) {
   const style = o.style ?? "blind";
   const fit = o.fit ?? "snug";
   const clearance = clearanceForFit(fit);
-  const cornerRadius = o.cornerRadius != null ? requireFinite$3(o.cornerRadius, "cornerRadius") : 0;
+  const cornerRadius = o.cornerRadius != null ? requireFinite$5(o.cornerRadius, "cornerRadius") : 0;
   const tenonThickness = o.tenonThickness != null ? requirePositive$2(o.tenonThickness, "tenonThickness") : tenonBoard.thickness / 3;
   const tenonWidth = o.tenonWidth != null ? requirePositive$2(o.tenonWidth, "tenonWidth") : Math.min(tenonBoard.height * 0.6, mortiseBoard.height * 0.8);
   const tenonLength = o.tenonLength != null ? requirePositive$2(o.tenonLength, "tenonLength") : style === "through" ? mortiseBoard.thickness : mortiseBoard.thickness * 2 / 3;
@@ -36840,10 +38123,10 @@ function mortiseAndTenon(mortiseBoard, tenonBoard, opts) {
       throw new Error("mortiseAndTenon: specify position.fromTop or position.fromBottom, not both");
     }
     if (o.position.fromTop != null) {
-      requireFinite$3(o.position.fromTop, "position.fromTop");
+      requireFinite$5(o.position.fromTop, "position.fromTop");
       mortiseCenterY = mortiseBoard.height / 2 - o.position.fromTop - mortiseH / 2;
     } else if (o.position.fromBottom != null) {
-      requireFinite$3(o.position.fromBottom, "position.fromBottom");
+      requireFinite$5(o.position.fromBottom, "position.fromBottom");
       mortiseCenterY = -mortiseBoard.height / 2 + o.position.fromBottom + mortiseH / 2;
     }
   }
@@ -36913,6 +38196,94 @@ const Wood = {
    */
   mortiseAndTenon
 };
+let _collected$3 = null;
+function resetCameraTrajectory() {
+  _collected$3 = null;
+}
+function getCollectedCameraTrajectory() {
+  return _collected$3;
+}
+function isOrbitKeyframe(kf) {
+  return "orbit" in kf;
+}
+function isCartesianKeyframe(kf) {
+  return "position" in kf;
+}
+function requireFinite$4(value, label) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`cameraTrajectory(): ${label} must be a finite number, got ${value}`);
+  }
+}
+function validateOrbitKeyframe(kf, index) {
+  requireFinite$4(kf.at, `keyframes[${index}].at`);
+  requireFinite$4(kf.orbit.angle, `keyframes[${index}].orbit.angle`);
+  requireFinite$4(kf.orbit.pitch, `keyframes[${index}].orbit.pitch`);
+  requireFinite$4(kf.orbit.distance, `keyframes[${index}].orbit.distance`);
+}
+function validateCartesianKeyframe(kf, index) {
+  requireFinite$4(kf.at, `keyframes[${index}].at`);
+  if (!Array.isArray(kf.position) || kf.position.length !== 3) {
+    throw new Error(`cameraTrajectory(): keyframes[${index}].position must be a 3-element array`);
+  }
+  if (!Array.isArray(kf.target) || kf.target.length !== 3) {
+    throw new Error(`cameraTrajectory(): keyframes[${index}].target must be a 3-element array`);
+  }
+  for (let i = 0; i < 3; i++) {
+    requireFinite$4(kf.position[i], `keyframes[${index}].position[${i}]`);
+    requireFinite$4(kf.target[i], `keyframes[${index}].target[${i}]`);
+  }
+}
+function validateKeyframeOrder(keyframes) {
+  if (keyframes.length < 2) {
+    throw new Error("cameraTrajectory(): keyframes must contain at least 2 entries");
+  }
+  for (let i = 0; i < keyframes.length; i++) {
+    const at = keyframes[i].at;
+    if (at < 0 || at > 1) {
+      throw new Error(`cameraTrajectory(): keyframes[${i}].at must be in [0, 1], got ${at}`);
+    }
+    if (i > 0 && at < keyframes[i - 1].at) {
+      throw new Error(
+        `cameraTrajectory(): keyframes must be sorted by 'at' ascending — keyframes[${i - 1}].at=${keyframes[i - 1].at} > keyframes[${i}].at=${at}`
+      );
+    }
+  }
+}
+function cameraTrajectory(defOrFn, options) {
+  if (_collected$3 !== null) {
+    console.warn("cameraTrajectory() called more than once — overwriting previous trajectory.");
+  }
+  if (typeof defOrFn === "function") {
+    _collected$3 = {
+      kind: "parametric",
+      parametricFn: defOrFn,
+      duration: options == null ? void 0 : options.duration,
+      fps: options == null ? void 0 : options.fps
+    };
+    return;
+  }
+  const { keyframes, duration, fps, easing } = defOrFn;
+  if (!Array.isArray(keyframes) || keyframes.length === 0) {
+    throw new Error("cameraTrajectory(): keyframes must be a non-empty array");
+  }
+  validateKeyframeOrder(keyframes);
+  const first = keyframes[0];
+  if (isOrbitKeyframe(first)) {
+    const orbitKeyframes = keyframes;
+    for (let i = 0; i < orbitKeyframes.length; i++) {
+      validateOrbitKeyframe(orbitKeyframes[i], i);
+    }
+    _collected$3 = { kind: "orbit-keyframes", orbitKeyframes, duration, fps, easing };
+  } else if (isCartesianKeyframe(first)) {
+    const cartesianKeyframes = keyframes;
+    for (let i = 0; i < cartesianKeyframes.length; i++) {
+      validateCartesianKeyframe(cartesianKeyframes[i], i);
+    }
+    _collected$3 = { kind: "cartesian-keyframes", cartesianKeyframes, duration, fps, easing };
+  } else {
+    throw new Error('cameraTrajectory(): each keyframe must have either an "orbit" or "position" property');
+  }
+}
 function resolveEdges(shape, edges) {
   if (!edges) {
     return selectEdges(shape);
@@ -37020,7 +38391,7 @@ function offsetSolid(shape, thickness) {
     sources: ["offset-solid"]
   });
 }
-function requireFinite$2(value, label) {
+function requireFinite$3(value, label) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
     throw new Error(`${label} must be a finite number`);
   }
@@ -37030,7 +38401,7 @@ function requireVec3(value, label) {
   if (!Array.isArray(value) || value.length !== 3) {
     throw new Error(`${label} must be [x, y, z]`);
   }
-  return [requireFinite$2(value[0], `${label}[0]`), requireFinite$2(value[1], `${label}[1]`), requireFinite$2(value[2], `${label}[2]`)];
+  return [requireFinite$3(value[0], `${label}[0]`), requireFinite$3(value[1], `${label}[1]`), requireFinite$3(value[2], `${label}[2]`)];
 }
 function requireColor(value, label) {
   if (typeof value !== "string" || !value.trim()) {
@@ -37058,7 +38429,7 @@ function validateCamera(cam, label) {
   if (cam.target !== void 0) out.target = requireVec3(cam.target, `${label}.target`);
   if (cam.up !== void 0) out.up = requireVec3(cam.up, `${label}.up`);
   if (cam.fov !== void 0) {
-    out.fov = requireFinite$2(cam.fov, `${label}.fov`);
+    out.fov = requireFinite$3(cam.fov, `${label}.fov`);
     if (out.fov <= 0 || out.fov >= 180) throw new Error(`${label}.fov must be between 0 and 180`);
   }
   if (cam.type !== void 0) {
@@ -37076,15 +38447,15 @@ function validateLight(light, label) {
   }
   const out = { type: light.type };
   if (light.color !== void 0) out.color = requireColor(light.color, `${label}.color`);
-  if (light.intensity !== void 0) out.intensity = requireFinite$2(light.intensity, `${label}.intensity`);
+  if (light.intensity !== void 0) out.intensity = requireFinite$3(light.intensity, `${label}.intensity`);
   if (light.position !== void 0) out.position = requireVec3(light.position, `${label}.position`);
   if (light.target !== void 0) out.target = requireVec3(light.target, `${label}.target`);
   if (light.groundColor !== void 0) out.groundColor = requireColor(light.groundColor, `${label}.groundColor`);
   if (light.skyColor !== void 0) out.skyColor = requireColor(light.skyColor, `${label}.skyColor`);
-  if (light.angle !== void 0) out.angle = requireFinite$2(light.angle, `${label}.angle`);
-  if (light.penumbra !== void 0) out.penumbra = requireFinite$2(light.penumbra, `${label}.penumbra`);
-  if (light.decay !== void 0) out.decay = requireFinite$2(light.decay, `${label}.decay`);
-  if (light.distance !== void 0) out.distance = requireFinite$2(light.distance, `${label}.distance`);
+  if (light.angle !== void 0) out.angle = requireFinite$3(light.angle, `${label}.angle`);
+  if (light.penumbra !== void 0) out.penumbra = requireFinite$3(light.penumbra, `${label}.penumbra`);
+  if (light.decay !== void 0) out.decay = requireFinite$3(light.decay, `${label}.decay`);
+  if (light.distance !== void 0) out.distance = requireFinite$3(light.distance, `${label}.distance`);
   if (light.castShadow !== void 0) {
     if (typeof light.castShadow !== "boolean") throw new Error(`${label}.castShadow must be a boolean`);
     out.castShadow = light.castShadow;
@@ -37099,7 +38470,7 @@ function validateEnvironment(env, label) {
     }
     out.preset = env.preset;
   }
-  if (env.intensity !== void 0) out.intensity = requireFinite$2(env.intensity, `${label}.intensity`);
+  if (env.intensity !== void 0) out.intensity = requireFinite$3(env.intensity, `${label}.intensity`);
   if (env.background !== void 0) {
     if (typeof env.background !== "boolean") throw new Error(`${label}.background must be a boolean`);
     out.background = env.background;
@@ -37109,9 +38480,9 @@ function validateEnvironment(env, label) {
 function validateFog(fog, label) {
   const out = {};
   if (fog.color !== void 0) out.color = requireColor(fog.color, `${label}.color`);
-  if (fog.near !== void 0) out.near = requireFinite$2(fog.near, `${label}.near`);
-  if (fog.far !== void 0) out.far = requireFinite$2(fog.far, `${label}.far`);
-  if (fog.density !== void 0) out.density = requireFinite$2(fog.density, `${label}.density`);
+  if (fog.near !== void 0) out.near = requireFinite$3(fog.near, `${label}.near`);
+  if (fog.far !== void 0) out.far = requireFinite$3(fog.far, `${label}.far`);
+  if (fog.density !== void 0) out.density = requireFinite$3(fog.density, `${label}.density`);
   return out;
 }
 function validatePostProcessing(pp, label) {
@@ -37119,23 +38490,23 @@ function validatePostProcessing(pp, label) {
   if (pp.bloom !== void 0) {
     if (!pp.bloom || typeof pp.bloom !== "object") throw new Error(`${label}.bloom must be an object`);
     out.bloom = {};
-    if (pp.bloom.intensity !== void 0) out.bloom.intensity = requireFinite$2(pp.bloom.intensity, `${label}.bloom.intensity`);
-    if (pp.bloom.threshold !== void 0) out.bloom.threshold = requireFinite$2(pp.bloom.threshold, `${label}.bloom.threshold`);
-    if (pp.bloom.radius !== void 0) out.bloom.radius = requireFinite$2(pp.bloom.radius, `${label}.bloom.radius`);
+    if (pp.bloom.intensity !== void 0) out.bloom.intensity = requireFinite$3(pp.bloom.intensity, `${label}.bloom.intensity`);
+    if (pp.bloom.threshold !== void 0) out.bloom.threshold = requireFinite$3(pp.bloom.threshold, `${label}.bloom.threshold`);
+    if (pp.bloom.radius !== void 0) out.bloom.radius = requireFinite$3(pp.bloom.radius, `${label}.bloom.radius`);
   }
   if (pp.vignette !== void 0) {
     if (!pp.vignette || typeof pp.vignette !== "object") throw new Error(`${label}.vignette must be an object`);
     out.vignette = {};
-    if (pp.vignette.darkness !== void 0) out.vignette.darkness = requireFinite$2(pp.vignette.darkness, `${label}.vignette.darkness`);
-    if (pp.vignette.offset !== void 0) out.vignette.offset = requireFinite$2(pp.vignette.offset, `${label}.vignette.offset`);
+    if (pp.vignette.darkness !== void 0) out.vignette.darkness = requireFinite$3(pp.vignette.darkness, `${label}.vignette.darkness`);
+    if (pp.vignette.offset !== void 0) out.vignette.offset = requireFinite$3(pp.vignette.offset, `${label}.vignette.offset`);
   }
   if (pp.grain !== void 0) {
     if (!pp.grain || typeof pp.grain !== "object") throw new Error(`${label}.grain must be an object`);
     out.grain = {};
-    if (pp.grain.intensity !== void 0) out.grain.intensity = requireFinite$2(pp.grain.intensity, `${label}.grain.intensity`);
+    if (pp.grain.intensity !== void 0) out.grain.intensity = requireFinite$3(pp.grain.intensity, `${label}.grain.intensity`);
   }
   if (pp.toneMappingExposure !== void 0) {
-    out.toneMappingExposure = requireFinite$2(pp.toneMappingExposure, `${label}.toneMappingExposure`);
+    out.toneMappingExposure = requireFinite$3(pp.toneMappingExposure, `${label}.toneMappingExposure`);
   }
   return out;
 }
@@ -37146,7 +38517,7 @@ function validateGround(ground, label) {
     out.visible = ground.visible;
   }
   if (ground.color !== void 0) out.color = requireColor(ground.color, `${label}.color`);
-  if (ground.offset !== void 0) out.offset = requireFinite$2(ground.offset, `${label}.offset`);
+  if (ground.offset !== void 0) out.offset = requireFinite$3(ground.offset, `${label}.offset`);
   if (ground.receiveShadow !== void 0) {
     if (typeof ground.receiveShadow !== "boolean") throw new Error(`${label}.receiveShadow must be a boolean`);
     out.receiveShadow = ground.receiveShadow;
@@ -37156,31 +38527,31 @@ function validateGround(ground, label) {
 function validateCapture(cap, label) {
   const out = {};
   if (cap.framesPerTurn !== void 0) {
-    out.framesPerTurn = requireFinite$2(cap.framesPerTurn, `${label}.framesPerTurn`);
+    out.framesPerTurn = requireFinite$3(cap.framesPerTurn, `${label}.framesPerTurn`);
     if (out.framesPerTurn < 12 || out.framesPerTurn > 720) {
       throw new Error(`${label}.framesPerTurn must be between 12 and 720`);
     }
   }
   if (cap.holdFrames !== void 0) {
-    out.holdFrames = requireFinite$2(cap.holdFrames, `${label}.holdFrames`);
+    out.holdFrames = requireFinite$3(cap.holdFrames, `${label}.holdFrames`);
     if (out.holdFrames < 0 || out.holdFrames > 300) {
       throw new Error(`${label}.holdFrames must be between 0 and 300`);
     }
   }
   if (cap.pitchDeg !== void 0) {
-    out.pitchDeg = requireFinite$2(cap.pitchDeg, `${label}.pitchDeg`);
+    out.pitchDeg = requireFinite$3(cap.pitchDeg, `${label}.pitchDeg`);
     if (out.pitchDeg < -80 || out.pitchDeg > 80) {
       throw new Error(`${label}.pitchDeg must be between -80 and 80`);
     }
   }
   if (cap.fps !== void 0) {
-    out.fps = requireFinite$2(cap.fps, `${label}.fps`);
+    out.fps = requireFinite$3(cap.fps, `${label}.fps`);
     if (out.fps < 1 || out.fps > 60) {
       throw new Error(`${label}.fps must be between 1 and 60`);
     }
   }
   if (cap.size !== void 0) {
-    out.size = requireFinite$2(cap.size, `${label}.size`);
+    out.size = requireFinite$3(cap.size, `${label}.size`);
     if (out.size < 1) {
       throw new Error(`${label}.size must be positive`);
     }
@@ -37881,6 +39252,16 @@ function buildProjectionReplayContext(plan) {
         ok: false,
         reason: "projection replay cannot derive a planar projection basis from fromSlices shapes."
       };
+    case "nurbsSurface":
+      return {
+        ok: false,
+        reason: "projection replay cannot derive a planar projection basis from NURBS surface shapes."
+      };
+    case "importedStep":
+      return {
+        ok: false,
+        reason: "projection replay cannot derive a planar projection basis from imported STEP files."
+      };
     default:
       assertExhaustive(plan);
   }
@@ -42249,6 +43630,138 @@ function hermiteTransitionG2(a, b) {
     { point: b.point, tangent: b.tangent, curvature: b.curvature, weight: b.weight }
   );
 }
+function requireFinite$2(v, label) {
+  if (!Number.isFinite(v)) throw new Error(`nurbs3d: ${label} must be finite, got ${v}`);
+}
+class NurbsCurve3D {
+  constructor(points, options = {}) {
+    __publicField(this, "controlPoints");
+    __publicField(this, "weights");
+    __publicField(this, "knots");
+    __publicField(this, "degree");
+    __publicField(this, "closed");
+    const n = points.length;
+    const degree = options.degree ?? 3;
+    if (degree < 1) throw new Error("nurbs3d: degree must be ≥ 1");
+    if (n < degree + 1) throw new Error(`nurbs3d: need at least ${degree + 1} control points for degree ${degree}, got ${n}`);
+    for (let i = 0; i < n; i++) {
+      requireFinite$2(points[i][0], `controlPoints[${i}][0]`);
+      requireFinite$2(points[i][1], `controlPoints[${i}][1]`);
+      requireFinite$2(points[i][2], `controlPoints[${i}][2]`);
+    }
+    const weights = options.weights ?? new Array(n).fill(1);
+    if (weights.length !== n) throw new Error(`nurbs3d: weights.length (${weights.length}) must equal controlPoints.length (${n})`);
+    for (let i = 0; i < n; i++) {
+      requireFinite$2(weights[i], `weights[${i}]`);
+      if (weights[i] <= 0) throw new Error(`nurbs3d: weights[${i}] must be > 0, got ${weights[i]}`);
+    }
+    const expectedKnotLength = n + degree + 1;
+    const knots = options.knots ?? generateClampedKnots(n, degree);
+    if (knots.length !== expectedKnotLength) {
+      throw new Error(`nurbs3d: knots.length (${knots.length}) must be controlPoints.length + degree + 1 (${expectedKnotLength})`);
+    }
+    for (let i = 0; i < knots.length; i++) {
+      requireFinite$2(knots[i], `knots[${i}]`);
+      if (i > 0 && knots[i] < knots[i - 1]) {
+        throw new Error(`nurbs3d: knot vector must be non-decreasing, but knots[${i - 1}]=${knots[i - 1]} > knots[${i}]=${knots[i]}`);
+      }
+    }
+    this.controlPoints = points.map(([x, y, z]) => [x, y, z]);
+    this.weights = [...weights];
+    this.knots = [...knots];
+    this.degree = degree;
+    this.closed = options.closed ?? false;
+  }
+  /**
+   * Evaluate the curve at parameter t ∈ [0, 1].
+   * Uses De Boor's algorithm — exact, O(degree²).
+   */
+  pointAt(t) {
+    const u = remapToKnotDomain(t, this.controlPoints.length, this.degree, this.knots);
+    return deBoor3D(this.controlPoints, this.weights, this.knots, this.degree, u);
+  }
+  /**
+   * Evaluate the unit tangent vector at parameter t ∈ [0, 1].
+   */
+  tangentAt(t) {
+    const u = remapToKnotDomain(t, this.controlPoints.length, this.degree, this.knots);
+    const d = deBoor3DDeriv(this.controlPoints, this.weights, this.knots, this.degree, u);
+    const len = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
+    if (len < 1e-12) return [0, 0, 1];
+    return [d[0] / len, d[1] / len, d[2] / len];
+  }
+  /**
+   * Sample the curve uniformly at `count` points.
+   */
+  sample(count = 48) {
+    return sampleNurbs3D(this.controlPoints, this.weights, this.knots, this.degree, Math.max(2, count));
+  }
+  /**
+   * Sample with adaptive density — more points in high-curvature regions.
+   */
+  sampleAdaptive(minCount = 32, maxCount = 128) {
+    const probeCount = Math.max(minCount, 64);
+    const curvatures = [];
+    for (let i = 0; i <= probeCount; i++) {
+      curvatures.push(this.estimateCurvature(i / probeCount));
+    }
+    const cumulative = [0];
+    for (let i = 1; i < curvatures.length; i++) {
+      const avgCurv = (curvatures[i - 1] + curvatures[i]) / 2;
+      cumulative.push(cumulative[i - 1] + 1 + avgCurv);
+    }
+    const total = cumulative[cumulative.length - 1];
+    const targetCount = Math.min(maxCount, Math.max(minCount, Math.round(minCount * 1.5)));
+    const pts = [this.pointAt(0)];
+    let probeIdx = 0;
+    for (let i = 1; i < targetCount; i++) {
+      const target = i / targetCount * total;
+      while (probeIdx < cumulative.length - 1 && cumulative[probeIdx + 1] < target) {
+        probeIdx++;
+      }
+      const frac = (target - cumulative[probeIdx]) / (cumulative[probeIdx + 1] - cumulative[probeIdx]);
+      const t = (probeIdx + frac) / probeCount;
+      pts.push(this.pointAt(t));
+    }
+    pts.push(this.pointAt(1));
+    return pts;
+  }
+  /**
+   * Approximate arc length by summing polyline segment lengths.
+   */
+  length(samples = 100) {
+    const pts = this.sample(Math.max(10, samples));
+    let len = 0;
+    for (let i = 1; i < pts.length; i++) {
+      const dx = pts[i][0] - pts[i - 1][0];
+      const dy = pts[i][1] - pts[i - 1][1];
+      const dz = pts[i][2] - pts[i - 1][2];
+      len += Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+    return len;
+  }
+  /** Convert to a format compatible with sweep() path input. */
+  toPolyline(samples = 64) {
+    return this.sampleAdaptive(Math.max(16, samples), samples * 2);
+  }
+  estimateCurvature(t) {
+    const eps = 1e-4;
+    const t0 = Math.max(0, t - eps);
+    const t1 = Math.min(1, t + eps);
+    const tm = (t0 + t1) / 2;
+    const p0 = this.pointAt(t0);
+    const pm = this.pointAt(tm);
+    const p1 = this.pointAt(t1);
+    const dt = (t1 - t0) / 2;
+    const d2x = (p0[0] - 2 * pm[0] + p1[0]) / (dt * dt);
+    const d2y = (p0[1] - 2 * pm[1] + p1[1]) / (dt * dt);
+    const d2z = (p0[2] - 2 * pm[2] + p1[2]) / (dt * dt);
+    return Math.sqrt(d2x * d2x + d2y * d2y + d2z * d2z);
+  }
+}
+function nurbs3d(points, options) {
+  return new NurbsCurve3D(points, options);
+}
 function clamp$4(v, lo, hi) {
   return Math.max(lo, Math.min(hi, v));
 }
@@ -42590,6 +44103,19 @@ function buildPathPlan(path2) {
       sampleForBounds: (samples) => path2.sample(samples)
     };
   }
+  if (path2 instanceof NurbsCurve3D) {
+    return {
+      plan: {
+        kind: "nurbs",
+        controlPoints: path2.controlPoints.map(([x, y, z]) => [x, y, z]),
+        weights: [...path2.weights],
+        knots: [...path2.knots],
+        degree: path2.degree,
+        closed: path2.closed
+      },
+      sampleForBounds: (samples) => path2.sample(samples)
+    };
+  }
   throw new Error("sweep: unsupported path type");
 }
 function sweep(profile, path2, options = {}) {
@@ -57948,6 +59474,16 @@ function sheetMetal(options) {
   deriveSheetMetalModel(model);
   return new SheetMetalPart(model);
 }
+function importStepFromBuffer(fileData, displayName = "import.step") {
+  return buildShapeFromCompilePlan(
+    createOwnedShapeCompilePlan(
+      { kind: "importedStep", filePath: displayName, fileData },
+      "importStep"
+    ),
+    void 0,
+    { fidelity: "exact", sources: ["imported"] }
+  );
+}
 let collectedSheetStock = [];
 let sheetStockCounter = 0;
 function resetSheetStock() {
@@ -270813,6 +272349,75 @@ function resolveErrorLocation(stack, compiledFiles) {
     column: parseInt(anonymousMatch[2], 10)
   };
 }
+function statementTargetVar(stmt) {
+  if (typescriptExports.isVariableStatement(stmt)) {
+    const decl = stmt.declarationList.declarations[0];
+    if (decl && typescriptExports.isIdentifier(decl.name)) return decl.name.text;
+  }
+  if (typescriptExports.isExpressionStatement(stmt)) {
+    const expr = stmt.expression;
+    if (typescriptExports.isBinaryExpression(expr) && expr.operatorToken.kind === typescriptExports.SyntaxKind.EqualsToken && typescriptExports.isIdentifier(expr.left)) {
+      return expr.left.text;
+    }
+  }
+  return null;
+}
+function collectReferencedNames(node, exclude, names) {
+  if (typescriptExports.isIdentifier(node) && !exclude.has(node)) {
+    names.add(node.text);
+  }
+  typescriptExports.forEachChild(node, (child) => collectReferencedNames(child, exclude, names));
+}
+function extractUnusedTopLevelVarNames(code) {
+  const sourceFile = typescriptExports.createSourceFile("__implicit.js", code, typescriptExports.ScriptTarget.ES2020, false, typescriptExports.ScriptKind.JS);
+  const declaredNames = [];
+  const collectBindingNames = (node) => {
+    if (typescriptExports.isIdentifier(node)) {
+      declaredNames.push(node.text);
+    } else if (typescriptExports.isObjectBindingPattern(node) || typescriptExports.isArrayBindingPattern(node)) {
+      for (const element of node.elements) {
+        if (typescriptExports.isBindingElement(element)) {
+          collectBindingNames(element.name);
+        }
+      }
+    }
+  };
+  for (const statement of sourceFile.statements) {
+    if (typescriptExports.isVariableStatement(statement)) {
+      for (const decl of statement.declarationList.declarations) {
+        collectBindingNames(decl.name);
+      }
+    } else if (typescriptExports.isFunctionDeclaration(statement) && statement.name) {
+      declaredNames.push(statement.name.text);
+    }
+  }
+  const excluded = /* @__PURE__ */ new Set(["exports", "module", "require", "__filename", "__dirname"]);
+  const topLevelNames = new Set(declaredNames.filter((n) => !excluded.has(n)));
+  if (topLevelNames.size === 0) return [];
+  const usedByOthers = /* @__PURE__ */ new Set();
+  for (const statement of sourceFile.statements) {
+    const target = statementTargetVar(statement);
+    const refs = /* @__PURE__ */ new Set();
+    const lhsNodes = /* @__PURE__ */ new Set();
+    if (typescriptExports.isVariableStatement(statement)) {
+      for (const decl of statement.declarationList.declarations) {
+        if (typescriptExports.isIdentifier(decl.name)) lhsNodes.add(decl.name);
+      }
+    } else if (typescriptExports.isExpressionStatement(statement)) {
+      const expr = statement.expression;
+      if (typescriptExports.isBinaryExpression(expr) && typescriptExports.isIdentifier(expr.left)) {
+        lhsNodes.add(expr.left);
+      }
+    }
+    collectReferencedNames(statement, lhsNodes, refs);
+    for (const ref of refs) {
+      if (topLevelNames.has(ref) && ref !== target) {
+        usedByOthers.add(ref);
+      }
+    }
+  }
+  return declaredNames.filter((n) => topLevelNames.has(n) && !usedByOthers.has(n));
+}
 function createForgeRuntimeModule(bindings) {
   const runtime = { ...bindings };
   Object.defineProperty(runtime, "__esModule", { value: true });
@@ -270867,6 +272472,34 @@ function finalizeForgeJsImport(moduleExports, importedDims) {
   if (importedDims.length === 0) return base;
   return setShapeDimensions(base, [...getShapeDimensions(base), ...importedDims]);
 }
+function rejectPathTraversal(fnName, userPath, resolvedPath) {
+  if (resolvedPath.startsWith("..")) {
+    throw new Error(`${fnName}("${userPath}"): path traversal blocked — resolved path escapes the project directory`);
+  }
+}
+let _constructorLockdownDepth = 0;
+let _origConstructorDescriptor;
+function withConstructorChainLockdown(fn) {
+  _constructorLockdownDepth++;
+  if (_constructorLockdownDepth === 1) {
+    _origConstructorDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, "constructor");
+    Object.defineProperty(Function.prototype, "constructor", {
+      get() {
+        throw new Error("Dynamic code generation is not allowed in ForgeCAD scripts");
+      },
+      configurable: true
+    });
+  }
+  try {
+    return fn();
+  } finally {
+    _constructorLockdownDepth--;
+    if (_constructorLockdownDepth === 0 && _origConstructorDescriptor) {
+      Object.defineProperty(Function.prototype, "constructor", _origConstructorDescriptor);
+      _origConstructorDescriptor = void 0;
+    }
+  }
+}
 function executeFile(code, fileName, allFiles, visited, scope = {}, options, executionMode = "script", moduleCacheEntry) {
   const trackCircularImports = executionMode === "script";
   if (trackCircularImports) {
@@ -270914,6 +272547,7 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
         throw new Error("importMesh() requires a non-empty file path string");
       }
       const resolvedPath = resolveImportPath(fileName, name.trim());
+      rejectPathTraversal("importMesh", name, resolvedPath);
       const format = detectMeshFormat(resolvedPath);
       if (!format) {
         const ext = resolvedPath.split(".").pop() ?? "";
@@ -270943,6 +272577,25 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
         sources: ["imported"]
       });
     };
+    const importStep = (name) => {
+      var _a3;
+      if (typeof name !== "string" || name.trim().length === 0) {
+        throw new Error("importStep() requires a non-empty file path string");
+      }
+      const resolvedPath = resolveImportPath(fileName, name.trim());
+      rejectPathTraversal("importStep", name, resolvedPath);
+      const ext = ((_a3 = resolvedPath.split(".").pop()) == null ? void 0 : _a3.toLowerCase()) ?? "";
+      if (ext !== "step" && ext !== "stp") {
+        throw new Error(`importStep("${name}"): unsupported extension ".${ext}". Expected .step or .stp`);
+      }
+      if (!options.readBinaryFile) {
+        throw new Error(
+          `importStep("${name}"): binary file reading is not available in this environment. Provide a readBinaryFile callback in RunScriptOptions.`
+        );
+      }
+      const fileData = options.readBinaryFile(resolvedPath);
+      return importStepFromBuffer(fileData, name);
+    };
     const wrappedUnion = union;
     const wrappedDifference = difference;
     const wrappedIntersection = intersection;
@@ -271006,6 +272659,10 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       filletCorners,
       chamfer2d,
       Curve3D,
+      NurbsCurve3D,
+      nurbs3d,
+      NurbsSurface,
+      nurbsSurface,
       spline2d,
       spline3d,
       loft,
@@ -271019,10 +272676,13 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       surfacePatch,
       sheetMetal,
       SheetMetalPart,
+      Param,
       param,
       boolParam,
       choiceParam,
-      listParam,
+      listParam: () => {
+        throw new Error("listParam() has been renamed to Param.list(). Update your script.");
+      },
       sdf,
       Shape,
       Sketch,
@@ -271052,6 +272712,7 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       offsetSolid,
       importSvgSketch,
       importMesh,
+      importStep,
       text2d,
       textWidth,
       loadFont,
@@ -271068,12 +272729,14 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       ShapeGroup,
       console: sandboxConsole,
       cutPlane,
+      cameraTrajectory,
       explodeView,
       jointsView,
       viewConfig,
       scene,
       verify,
       spec,
+      mock,
       gcode,
       GCodeBuilder,
       // ── Laser Kit ──────────────────────────────────────────────────
@@ -271086,7 +272749,19 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       assemblyInstructions,
       formatInstructions,
       lookupKerf,
-      COMMON_KERFS
+      COMMON_KERFS,
+      // ── Sandbox safety: shadow dangerous globals ───────────────────
+      // These prevent user code from accessing escape vectors directly.
+      // The constructor-chain lockdown (below) covers indirect access.
+      Function: void 0,
+      globalThis: void 0,
+      global: void 0,
+      self: void 0,
+      window: void 0,
+      setTimeout: void 0,
+      setInterval: void 0,
+      setImmediate: void 0,
+      queueMicrotask: void 0
     };
     const requireModule = (requestedName, paramOverrides) => {
       if (typeof requestedName !== "string" || requestedName.trim().length === 0) {
@@ -271200,6 +272875,15 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
     const compiled = compileScript(code, fileName, options);
     const bindingNames = Object.keys(runtimeBindings);
     const bindingValues = bindingNames.map((name) => runtimeBindings[name]);
+    let scriptCode = compiled.code;
+    if (executionMode === "script") {
+      const varNames = extractUnusedTopLevelVarNames(compiled.code).filter((n) => !bindingNames.includes(n));
+      if (varNames.length > 0) {
+        const collector = varNames.map((n) => `${JSON.stringify(n)}: ${n}`).join(", ");
+        scriptCode += `
+; try { module.__implicitVars = {${collector}}; } catch(e) {}`;
+      }
+    }
     const fn = new Function(
       "exports",
       "module",
@@ -271207,16 +272891,19 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       "__filename",
       "__dirname",
       ...bindingNames,
-      `${compiled.code}
+      `"use strict";
+${scriptCode}
 //# sourceURL=${fileName}`
     );
     const moduleValue = {
       exports: executionMode === "module" && moduleCacheEntry ? moduleCacheEntry.exports : {}
     };
     const initialExportsRef = moduleValue.exports;
-    const returnValue = runWithParamScope(
-      scope,
-      () => fn(moduleValue.exports, moduleValue, requireModule, fileName, dirnamePath(fileName), ...bindingValues)
+    const returnValue = withConstructorChainLockdown(
+      () => runWithParamScope(
+        scope,
+        () => fn(moduleValue.exports, moduleValue, requireModule, fileName, dirnamePath(fileName), ...bindingValues)
+      )
     );
     if (executionMode === "module") {
       const hasExports = hasExplicitModuleExports(moduleValue.exports, initialExportsRef);
@@ -271241,7 +272928,18 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
     }
     const exportedResult = resolveExportedEntryResult(moduleValue.exports);
     if (returnValue === void 0) {
-      return exportedResult ?? null;
+      if (exportedResult != null) return exportedResult;
+      const implicitVars = moduleValue.__implicitVars;
+      if (implicitVars) {
+        const renderables = {};
+        for (const [key, value] of Object.entries(implicitVars)) {
+          if (isRenderableEntryResult(value)) {
+            renderables[key] = value;
+          }
+        }
+        if (Object.keys(renderables).length > 0) return renderables;
+      }
+      return null;
     }
     return returnValue;
   } finally {
@@ -271278,12 +272976,15 @@ function runScript(code, fileName = "main.forge.js", allFiles = {}, options = {}
   resetSheetStock();
   resetRobotExport();
   resetCutPlanes();
+  resetCameraTrajectory();
   resetExplodeView();
   resetJointsView();
   resetViewConfig();
   resetScene();
   resetVerifications();
+  resetMocks();
   _collectedLogs = [];
+  setRuntimeWarnSink((msg) => _collectedLogs.push({ level: "warn", args: [msg], timestamp: Date.now() }));
   const t0 = performance.now();
   const execOptions = {
     debugImports: options.debugImports ?? envFlagEnabled("FORGECAD_DEBUG_IMPORTS"),
@@ -271523,7 +273224,19 @@ function runScript(code, fileName = "main.forge.js", allFiles = {}, options = {}
         } else {
           const entries = Object.entries(obj);
           entries.forEach(([key, value]) => {
-            if (value instanceof Shape) {
+            if (value instanceof Assembly) {
+              const items = value.solve().toSceneObjects();
+              items.forEach((item, index) => {
+                const label = `${key}.${index + 1}`;
+                processNamedItem(item, label, label);
+              });
+            } else if (value instanceof SolvedAssembly) {
+              const items = value.toSceneObjects();
+              items.forEach((item, index) => {
+                const label = `${key}.${index + 1}`;
+                processNamedItem(item, label, label);
+              });
+            } else if (value instanceof Shape) {
               pushShape(value, key, void 0, void 0, void 0, [key]);
             } else if (value instanceof Sketch) {
               pushSketch(value, key, void 0, [key]);
@@ -271531,6 +273244,21 @@ function runScript(code, fileName = "main.forge.js", allFiles = {}, options = {}
               value.children.forEach((child, i) => {
                 flattenGroupChild(child, groupChildLabel(value, key, i), void 0, [key, shapeGroupChildSegment(value, i)]);
               });
+            } else if (Array.isArray(value)) {
+              value.forEach((item, index) => {
+                const label = `${key}.${index + 1}`;
+                if (item instanceof ShapeGroup) {
+                  item.children.forEach((child, i) => {
+                    flattenGroupChild(child, groupChildLabel(item, label, i), void 0, [key, label, shapeGroupChildSegment(item, i)]);
+                  });
+                } else if (item instanceof Shape) {
+                  pushShape(item, label, void 0, void 0, void 0, [key, label]);
+                } else if (item instanceof Sketch) {
+                  pushSketch(item, label, void 0, [key, label]);
+                } else if (isNamedObject(item)) {
+                  processNamedItem(item, label, label, void 0, [key]);
+                }
+              });
             }
           });
         }
@@ -271559,12 +273287,23 @@ function runScript(code, fileName = "main.forge.js", allFiles = {}, options = {}
       }
       const shape = objects.length === 1 ? objects[0].shape : null;
       const sketch = objects.length === 1 ? objects[0].sketch : null;
+      const collectedMocks = getCollectedMocks();
+      for (const m of collectedMocks) {
+        objects.push({
+          id: m.id,
+          name: `${m.name} (mock)`,
+          shape: m.shape,
+          sketch: null,
+          mock: true
+        });
+      }
       autoFillExplodeHints(objects);
       return {
         shape,
         sketch,
         objects,
         params: getCollectedParams(),
+        stringParams: getCollectedStringParams(),
         listParams: getCollectedListParams(),
         dimensions: [...getCollectedDimensions(), ...shapeDimensions],
         highlights: getCollectedHighlights(),
@@ -271572,6 +273311,7 @@ function runScript(code, fileName = "main.forge.js", allFiles = {}, options = {}
         bom: getCollectedBom(),
         sheetStock: getCollectedSheetStock(),
         cutPlanes: getCollectedCutPlanes(),
+        cameraTrajectory: getCollectedCameraTrajectory(),
         explodeView: getCollectedExplodeView(),
         jointsView: getCollectedJointsView(),
         viewConfig: getCollectedViewConfig(),
@@ -271581,7 +273321,8 @@ function runScript(code, fileName = "main.forge.js", allFiles = {}, options = {}
         error: objects.length > 0 || options.allowEmptyResult ? null : "Script must return a Shape or Sketch",
         timeMs: performance.now() - t0,
         logs: _collectedLogs.slice(),
-        verifications: getCollectedVerifications()
+        verifications: getCollectedVerifications(),
+        mocks: getCollectedMocks()
       };
     });
   } catch (e) {
@@ -271598,6 +273339,7 @@ function runScript(code, fileName = "main.forge.js", allFiles = {}, options = {}
       sketch: null,
       objects: [],
       params: getCollectedParams(),
+      stringParams: getCollectedStringParams(),
       listParams: getCollectedListParams(),
       dimensions: getCollectedDimensions(),
       highlights: getCollectedHighlights(),
@@ -271605,6 +273347,7 @@ function runScript(code, fileName = "main.forge.js", allFiles = {}, options = {}
       bom: getCollectedBom(),
       sheetStock: getCollectedSheetStock(),
       cutPlanes: getCollectedCutPlanes(),
+      cameraTrajectory: getCollectedCameraTrajectory(),
       explodeView: getCollectedExplodeView(),
       jointsView: getCollectedJointsView(),
       viewConfig: getCollectedViewConfig(),
@@ -271614,7 +273357,8 @@ function runScript(code, fileName = "main.forge.js", allFiles = {}, options = {}
       error: `${msg}${lineInfo}`,
       timeMs: performance.now() - t0,
       logs: _collectedLogs.slice(),
-      verifications: getCollectedVerifications()
+      verifications: getCollectedVerifications(),
+      mocks: getCollectedMocks()
     };
   }
 }