forgecad 0.10.2 → 0.10.3

package/dist/assets/{evalWorker-C2pm8LHP.js → evalWorker-CS63PfZu.js}

@@ -3190,20 +3190,20 @@ function flatKnotsToKnotsMults(flatKnots) {
   return { knots, mults };
 }
 const KNOT_EPSILON = 1e-10;
-function sameKnot(a2, b) {
+function sameKnot$1(a2, b) {
   return Math.abs(a2 - b) <= KNOT_EPSILON;
 }
-function knotMultiplicity(knots, u2) {
-  return knots.reduce((count, knot) => count + (sameKnot(knot, u2) ? 1 : 0), 0);
+function knotMultiplicity$1(knots, u2) {
+  return knots.reduce((count, knot) => count + (sameKnot$1(knot, u2) ? 1 : 0), 0);
 }
 function firstKnotIndex(knots, u2) {
-  const index2 = knots.findIndex((knot) => sameKnot(knot, u2));
+  const index2 = knots.findIndex((knot) => sameKnot$1(knot, u2));
   if (index2 < 0) throw new Error(`NURBS subdomain extraction could not find boundary knot ${u2}.`);
   return index2;
 }
 function lastKnotIndex(knots, u2) {
   for (let index2 = knots.length - 1; index2 >= 0; index2 -= 1) {
-    if (sameKnot(knots[index2], u2)) return index2;
+    if (sameKnot$1(knots[index2], u2)) return index2;
   }
   throw new Error(`NURBS subdomain extraction could not find boundary knot ${u2}.`);
 }
@@ -3216,7 +3216,7 @@ function insertKnotOnceHomogeneous(points, knots, degree, u2) {
   const lastPoint = count - 1;
   const lastKnot = knots.length - 1;
   const span = findSpan(count, degree, u2, knots);
-  const multiplicity = knotMultiplicity(knots, u2);
+  const multiplicity = knotMultiplicity$1(knots, u2);
   if (multiplicity >= degree) {
     throw new Error(`NURBS subdomain extraction cannot insert knot ${u2}: multiplicity ${multiplicity} already reaches degree ${degree}.`);
   }
@@ -3240,7 +3240,7 @@ function insertKnotOnceHomogeneous(points, knots, degree, u2) {
 function insertBoundaryToMultiplicity(points, knots, degree, u2, targetMultiplicity) {
   let refinedPoints = points;
   let refinedKnots = knots;
-  while (knotMultiplicity(refinedKnots, u2) < targetMultiplicity) {
+  while (knotMultiplicity$1(refinedKnots, u2) < targetMultiplicity) {
     const refined = insertKnotOnceHomogeneous(refinedPoints, refinedKnots, degree, u2);
     refinedPoints = refined.points;
     refinedKnots = refined.knots;
@@ -3260,8 +3260,8 @@ function extractNurbsCurveSubdomain(controlPoints, weights, knots, degree, uStar
   }
   const activeStart = knots[degree];
   const activeEnd = knots[controlPoints.length];
-  const start = sameKnot(uStart, activeStart) ? activeStart : sameKnot(uStart, activeEnd) ? activeEnd : uStart;
-  const end = sameKnot(uEnd, activeEnd) ? activeEnd : sameKnot(uEnd, activeStart) ? activeStart : uEnd;
+  const start = sameKnot$1(uStart, activeStart) ? activeStart : sameKnot$1(uStart, activeEnd) ? activeEnd : uStart;
+  const end = sameKnot$1(uEnd, activeEnd) ? activeEnd : sameKnot$1(uEnd, activeStart) ? activeStart : uEnd;
   if (start < activeStart - KNOT_EPSILON || end > activeEnd + KNOT_EPSILON) {
     throw new Error(`NURBS subdomain [${uStart}, ${uEnd}] must stay inside active knot domain [${activeStart}, ${activeEnd}].`);
   }
@@ -10172,7 +10172,7 @@ async function initTruckGeometryWasm() {
   if (_initPromise$2) return _initPromise$2;
   _initPromise$2 = (async () => {
     try {
-      const geometryModule = await import("./forgecad_geometry-BlMtqluF.js");
+      const geometryModule = await import("./forgecad_geometry-CZ_IfuvA.js");
       const isNode = isNodeRuntime();
       if (isNode) {
         const { readFileSync, existsSync } = await Promise.resolve().then(function() {
@@ -11100,23 +11100,62 @@ class NurbsSurface {
     return [wx / wSum, wy / wSum, wz / wSum];
   }
   /**
-   * Evaluate the surface normal at (u, v) via cross product of partial derivatives.
+   * Evaluate the surface unit normal at (u, v) from analytic first derivatives.
+   *
+   * Uses Algorithm A2.3 basis-function derivatives with the rational quotient
+   * rule, so the normal is exact (no finite-difference epsilon, no error near
+   * the boundary). Constant chain-rule factors from the parameter remap scale Su
+   * and Sv positively and cancel under normalization, so they are omitted.
    */
   normalAt(u2, v) {
-    const eps = 1e-5;
-    const u0 = Math.max(0, u2 - eps), u1 = Math.min(1, u2 + 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(u2, v1), pmv = this.pointAt(u2, 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 { Su, Sv } = this.derivativesAt(u2, v);
+    const nx = Su[1] * Sv[2] - Su[2] * Sv[1];
+    const ny = Su[2] * Sv[0] - Su[0] * Sv[2];
+    const nz = Su[0] * Sv[1] - Su[1] * Sv[0];
     const len2 = Math.sqrt(nx * nx + ny * ny + nz * nz);
     if (len2 < 1e-12) return [0, 0, 1];
     return [nx / len2, ny / len2, nz / len2];
   }
+  /** Analytic first partial derivatives S_u, S_v (rational quotient rule). */
+  derivativesAt(u2, v) {
+    const uu = this.remapU(Math.max(0, Math.min(1, u2)));
+    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 dU = basisFunsDeriv(spanU, uu, this.degreeU, this.knotsU, 1);
+    const dV = basisFunsDeriv(spanV, vv, this.degreeV, this.knotsV, 1);
+    const A = [0, 0, 0];
+    const Au = [0, 0, 0];
+    const Av = [0, 0, 0];
+    let w2 = 0;
+    let wu = 0;
+    let wv = 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 weight = this.weightsGrid[rowIdx][colIdx];
+        const pt = this.controlGrid[rowIdx][colIdx];
+        const n00 = dU[0][i] * dV[0][j] * weight;
+        const n10 = dU[1][i] * dV[0][j] * weight;
+        const n01 = dU[0][i] * dV[1][j] * weight;
+        w2 += n00;
+        wu += n10;
+        wv += n01;
+        for (let c2 = 0; c2 < 3; c2++) {
+          A[c2] += n00 * pt[c2];
+          Au[c2] += n10 * pt[c2];
+          Av[c2] += n01 * pt[c2];
+        }
+      }
+    }
+    if (w2 === 0) return { S: [0, 0, 0], Su: [0, 0, 0], Sv: [0, 0, 0] };
+    const invW = 1 / w2;
+    const S = [A[0] * invW, A[1] * invW, A[2] * invW];
+    const Su = [(Au[0] - wu * S[0]) * invW, (Au[1] - wu * S[1]) * invW, (Au[2] - wu * S[2]) * invW];
+    const Sv = [(Av[0] - wv * S[0]) * invW, (Av[1] - wv * S[1]) * invW, (Av[2] - wv * S[2]) * invW];
+    return { S, Su, Sv };
+  }
   /**
    * Tessellate the surface into a triangle mesh.
    * Returns positions, normals, and triangle indices.
@@ -12487,7 +12526,7 @@ function maxQuadDeviation(rings, heights, colA, colB) {
     const b = [rings[i][colB][0], rings[i][colB][1], heights[i]];
     const c2 = [rings[i + 1][colB][0], rings[i + 1][colB][1], heights[i + 1]];
     const d2 = [rings[i + 1][colA][0], rings[i + 1][colA][1], heights[i + 1]];
-    const n = cross3$7(sub3$6(b, a2), sub3$6(d2, a2));
+    const n = cross3$7(sub3$7(b, a2), sub3$7(d2, a2));
     const len2 = Math.hypot(n[0], n[1], n[2]);
     if (len2 < 1e-12) continue;
     const deviation = Math.abs((n[0] * (c2[0] - a2[0]) + n[1] * (c2[1] - a2[1]) + n[2] * (c2[2] - a2[2])) / len2);
@@ -12763,15 +12802,15 @@ function buildSpanRows(rings, heights) {
 function stationTangent(stations, t, i, j) {
   const R = stations.length;
   if (i === 0) {
-    return scale3$2(sub3$6(stations[1][j], stations[0][j]), 1 / (t[1] - t[0]));
+    return scale3$2(sub3$7(stations[1][j], stations[0][j]), 1 / (t[1] - t[0]));
   }
   if (i === R - 1) {
-    return scale3$2(sub3$6(stations[R - 1][j], stations[R - 2][j]), 1 / (t[R - 1] - t[R - 2]));
+    return scale3$2(sub3$7(stations[R - 1][j], stations[R - 2][j]), 1 / (t[R - 1] - t[R - 2]));
   }
   const hPrev = t[i] - t[i - 1];
   const hNext = t[i + 1] - t[i];
-  const dPrev = scale3$2(sub3$6(stations[i][j], stations[i - 1][j]), 1 / hPrev);
-  const dNext = scale3$2(sub3$6(stations[i + 1][j], stations[i][j]), 1 / hNext);
+  const dPrev = scale3$2(sub3$7(stations[i][j], stations[i - 1][j]), 1 / hPrev);
+  const dNext = scale3$2(sub3$7(stations[i + 1][j], stations[i][j]), 1 / hNext);
   return scale3$2(add3$2(scale3$2(dPrev, hNext), scale3$2(dNext, hPrev)), 1 / (hPrev + hNext));
 }
 function hermite(p0, m0, p1, m1, h, u2) {
@@ -12827,12 +12866,12 @@ function stitchSingleLoopLoft(loops, heights, wasm, options) {
       const curr = points[j];
       const next = points[(j + 1) % N];
       if (cornerSet.has(j)) {
-        const nFwd = surfaceNormal(sub3$6(next, curr), tangents[j]);
-        const nBwd = surfaceNormal(sub3$6(curr, prev), tangents[j]);
+        const nFwd = surfaceNormal(sub3$7(next, curr), tangents[j]);
+        const nBwd = surfaceNormal(sub3$7(curr, prev), tangents[j]);
         fwd[j] = pushVert(curr, nFwd);
         bwd[j] = pushVert(curr, nBwd);
       } else {
-        const idx = pushVert(curr, surfaceNormal(sub3$6(next, prev), tangents[j]));
+        const idx = pushVert(curr, surfaceNormal(sub3$7(next, prev), tangents[j]));
         fwd[j] = idx;
         bwd[j] = idx;
       }
@@ -12893,7 +12932,7 @@ function surfaceNormal(chord, span) {
   }
   return [n[0] / len2, n[1] / len2, n[2] / len2];
 }
-function sub3$6(a2, b) {
+function sub3$7(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
 function add3$2(a2, b) {
@@ -12919,7 +12958,7 @@ let _wasm = null;
 async function initManifoldWasm() {
   if (_wasm) return _wasm;
   performance.mark("manifold:start");
-  const Module = (await import("./manifold-DjBkyIc8.js")).default;
+  const Module = (await import("./manifold-k2kRcc85.js")).default;
   performance.mark("manifold:imported");
   const wasm = await Module();
   wasm.setup();
@@ -13053,23 +13092,6 @@ let ManifoldShapeBackend = _ManifoldShapeBackend;
 function wrapManifoldShapeBackend(manifold) {
   return new ManifoldShapeBackend(manifold);
 }
-function reconstructBackendFromMesh(mesh) {
-  const wasm = getManifoldWasm();
-  const wasmMesh = new wasm.Mesh({
-    numProp: mesh.numProp,
-    triVerts: mesh.triVerts,
-    vertProperties: mesh.vertProperties,
-    mergeFromVert: mesh.mergeFromVert.length > 0 ? mesh.mergeFromVert : void 0,
-    mergeToVert: mesh.mergeToVert.length > 0 ? mesh.mergeToVert : void 0
-  });
-  let manifold;
-  try {
-    manifold = new wasm.Manifold(wasmMesh);
-  } catch {
-    manifold = wasm.Manifold.cube([0, 0, 0]);
-  }
-  return new ManifoldShapeBackend(manifold);
-}
 function requireManifoldShapeBackend(backend, apiName = "requireManifoldShapeBackend()") {
   if (isManifoldCapableBackend(backend)) {
     return backend.requireManifold(apiName);
@@ -13549,6 +13571,20 @@ function fromSlicesSingleSliceHalfExtentForManifold(plan) {
   }
   return Math.max(1, radius + maxOffsetMagnitude + plan.boundsPadding + plan.edgeLength * 3);
 }
+const BOOLEAN_OPERAND_NORMAL_SHARP_ANGLE_DEG = 60;
+function promoteBooleanOperandNormals(shapes) {
+  let maxExtra = 0;
+  for (const shape of shapes) maxExtra = Math.max(maxExtra, shape.numProp());
+  if (maxExtra < 3) return { operands: shapes, created: [] };
+  const created = [];
+  const operands = shapes.map((shape) => {
+    if (shape.numProp() >= 3) return shape;
+    const promoted = shape.calculateNormals(0, BOOLEAN_OPERAND_NORMAL_SHARP_ANGLE_DEG);
+    created.push(promoted);
+    return promoted;
+  });
+  return { operands, created };
+}
 function lowerShapeBooleanCompilePlan(plan, wasm) {
   const shapes = plan.shapes.map((shape) => lowerShapeCompilePlanToManifold(shape, wasm));
   if (shapes.length === 0) {
@@ -13557,16 +13593,18 @@ function lowerShapeBooleanCompilePlan(plan, wasm) {
   if (shapes.length === 1) {
     return shapes[0];
   }
+  const { operands, created } = promoteBooleanOperandNormals(shapes);
   try {
     switch (plan.op) {
       case "union":
-        return wasm.Manifold.union(shapes);
+        return wasm.Manifold.union(operands);
       case "difference":
-        return wasm.Manifold.difference(shapes);
+        return wasm.Manifold.difference(operands);
       case "intersection":
-        return wasm.Manifold.intersection(shapes);
+        return wasm.Manifold.intersection(operands);
     }
   } finally {
+    disposeWasmObjects(created);
     disposeWasmObjects(shapes);
   }
 }
@@ -14916,12 +14954,16 @@ function lowerNurbsSurfaceToManifold(plan, wasm) {
   const { positions, normals, indices } = surface.tessellate(res, res);
   const thickness = plan.thickness;
   const numVerts = positions.length;
-  const allPositions = [];
-  for (const [x2, y2, z2] of positions) allPositions.push(x2, y2, z2);
+  const vertProps = [];
   for (let i = 0; i < numVerts; i++) {
     const [x2, y2, z2] = positions[i];
     const [nx, ny, nz] = normals[i];
-    allPositions.push(x2 - nx * thickness, y2 - ny * thickness, z2 - nz * thickness);
+    vertProps.push(x2, y2, z2, nx, ny, nz);
+  }
+  for (let i = 0; i < numVerts; i++) {
+    const [x2, y2, z2] = positions[i];
+    const [nx, ny, nz] = normals[i];
+    vertProps.push(x2 - nx * thickness, y2 - ny * thickness, z2 - nz * thickness, -nx, -ny, -nz);
   }
   const allIndices = [];
   for (const idx of indices) allIndices.push(idx);
@@ -14946,11 +14988,12 @@ function lowerNurbsSurfaceToManifold(plan, wasm) {
     allIndices.push(c2, c2 + numVerts, d2, d2, c2 + numVerts, d2 + numVerts);
   }
   const mesh = new wasm.Mesh({
-    numProp: 3,
-    vertProperties: new Float32Array(allPositions),
+    numProp: 6,
+    vertProperties: new Float32Array(vertProps),
     triVerts: new Uint32Array(allIndices)
   });
   try {
+    mesh.merge();
     return new wasm.Manifold(mesh);
   } finally {
     disposeWasmObject(mesh);
@@ -20196,7 +20239,7 @@ function uvInsideTrim(uv, trim) {
 function add3$1(a2, b) {
   return [a2[0] + b[0], a2[1] + b[1], a2[2] + b[2]];
 }
-function sub3$5(a2, b) {
+function sub3$6(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
 function scale3$1(v, scale2) {
@@ -20242,7 +20285,7 @@ function resamplePolyline$1(points, count) {
   if (points.length === 1 || count <= 1) return [points[0]];
   const cumulative = [0];
   for (let index2 = 1; index2 < points.length; index2 += 1) {
-    cumulative.push(cumulative[index2 - 1] + Math.hypot(...sub3$5(points[index2], points[index2 - 1])));
+    cumulative.push(cumulative[index2 - 1] + Math.hypot(...sub3$6(points[index2], points[index2 - 1])));
   }
   const total = cumulative[cumulative.length - 1];
   if (total <= 1e-12) return Array.from({ length: count }, () => points[0]);
@@ -20403,7 +20446,7 @@ function computeGridNormals(positions, indices) {
     const a2 = positions[indices[index2]];
     const b = positions[indices[index2 + 1]];
     const c2 = positions[indices[index2 + 2]];
-    const normal2 = cross3$5(sub3$5(b, a2), sub3$5(c2, a2));
+    const normal2 = cross3$5(sub3$6(b, a2), sub3$6(c2, a2));
     for (const vertexIndex of [indices[index2], indices[index2 + 1], indices[index2 + 2]]) {
       normals[vertexIndex][0] += normal2[0];
       normals[vertexIndex][1] += normal2[1];
@@ -20496,16 +20539,16 @@ function planarProjectionFrame(points, context) {
   const tolerance = pointTolerance(points) * 100;
   const uSource = points.find((point2) => distance3$1(point2, origin) > tolerance);
   if (!uSource) throw new Error(`${context} boundary loop collapsed to one point.`);
-  const u2 = normalize3$5(sub3$5(uSource, origin), `${context} u axis`);
+  const u2 = normalize3$5(sub3$6(uSource, origin), `${context} u axis`);
   const v = cross3$5(normal2, u2);
-  const maxPlaneError = points.reduce((max2, point2) => Math.max(max2, Math.abs(dot3$6(sub3$5(point2, origin), normal2))), 0);
+  const maxPlaneError = points.reduce((max2, point2) => Math.max(max2, Math.abs(dot3$6(sub3$6(point2, origin), normal2))), 0);
   if (maxPlaneError > tolerance) throw new Error(`${context} boundary loop must be planar for sampled SDF triangulation.`);
   return { origin, u: u2, v, tolerance };
 }
 function meshFromPlanarBoundaryLoop(loop, context) {
   const frame = planarProjectionFrame(loop, context);
   const projected = loop.map((point2) => {
-    const relative = sub3$5(point2, frame.origin);
+    const relative = sub3$6(point2, frame.origin);
     return new Vector2(dot3$6(relative, frame.u), dot3$6(relative, frame.v));
   });
   const triangles = ShapeUtils.triangulateShape(projected, []);
@@ -20514,7 +20557,7 @@ function meshFromPlanarBoundaryLoop(loop, context) {
   const indices = [];
   for (const triangle of triangles) {
     const [a2, b, c2] = triangle;
-    const areaNormal = cross3$5(sub3$5(positions[b], positions[a2]), sub3$5(positions[c2], positions[a2]));
+    const areaNormal = cross3$5(sub3$6(positions[b], positions[a2]), sub3$6(positions[c2], positions[a2]));
     if (Math.hypot(...areaNormal) > frame.tolerance * frame.tolerance) indices.push(a2, b, c2);
   }
   if (indices.length === 0) throw new Error(`${context} boundary loop collapsed to zero area.`);
@@ -29031,7 +29074,7 @@ function wrapSdfMeshShapeBackend(field2, mesh) {
   return new SdfShapeBackend(field2, mesh);
 }
 const EPS$c = 1e-8;
-function sub3$4(a2, b) {
+function sub3$5(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
 function unit(v, context) {
@@ -29054,13 +29097,13 @@ function loopNormal(points) {
 }
 function firstEdgeDirection(points, filePath, context) {
   for (let index2 = 0; index2 < points.length; index2 += 1) {
-    const edge = sub3$4(points[(index2 + 1) % points.length], points[index2]);
+    const edge = sub3$5(points[(index2 + 1) % points.length], points[index2]);
     if (Math.hypot(edge[0], edge[1], edge[2]) > EPS$c) return unit(edge, context);
   }
   failStepImport(filePath, `${context} face loop has no non-zero edges.`);
 }
 function project(point2, origin, u2, v) {
-  const local = sub3$4(point2, origin);
+  const local = sub3$5(point2, origin);
   return new Vector2(dot3$6(local, u2), dot3$6(local, v));
 }
 function triangulateStepFace(face, filePath) {
@@ -29084,7 +29127,7 @@ function triangulateStepFace(face, filePath) {
     const a2 = allPoints[ia];
     const b = allPoints[ib];
     const c2 = allPoints[ic];
-    const triNormal = cross3$5(sub3$4(b, a2), sub3$4(c2, a2));
+    const triNormal = cross3$5(sub3$5(b, a2), sub3$5(c2, a2));
     if (Math.hypot(triNormal[0], triNormal[1], triNormal[2]) <= EPS$c) {
       failStepImport(filePath, `${face.context} triangulates to a degenerate triangle.`);
     }
@@ -30126,7 +30169,7 @@ function angleDistance(a2, b) {
   return Math.abs(normalizeAngleDelta(a2 - b));
 }
 function torusMajorAngle(frame, point2, context) {
-  const local = sub3$3(point2, frame.origin);
+  const local = sub3$4(point2, frame.origin);
   const x2 = dot3$6(local, frame.xAxis);
   const y2 = dot3$6(local, frame.yAxis);
   if (Math.hypot(x2, y2) <= 1e-12) throw new Error(`${context} torus major angle is degenerate.`);
@@ -30142,11 +30185,11 @@ function torusRadialDirection(frame, u2) {
 function torusTubeAngle(frame, majorRadius, u2, point2) {
   const radial = torusRadialDirection(frame, u2);
   const tubeCenter = addScaled$2(frame.origin, radial, majorRadius);
-  const local = sub3$3(point2, tubeCenter);
+  const local = sub3$4(point2, tubeCenter);
   return Math.atan2(dot3$6(local, frame.axis), dot3$6(local, radial));
 }
 function rotateAroundAxis(point2, axis, angle) {
-  const local = sub3$3(point2, axis.origin);
+  const local = sub3$4(point2, axis.origin);
   const cos2 = Math.cos(angle);
   const sin2 = Math.sin(angle);
   const cross4 = cross3$5(axis.axis, local);
@@ -30158,12 +30201,12 @@ function rotateAroundAxis(point2, axis, angle) {
   ];
 }
 function distanceFromAxis(point2, axis) {
-  const local = sub3$3(point2, axis.origin);
+  const local = sub3$4(point2, axis.origin);
   const axial = dot3$6(local, axis.axis);
   return Math.hypot(local[0] - axis.axis[0] * axial, local[1] - axis.axis[1] * axial, local[2] - axis.axis[2] * axial);
 }
 function radialFromAxis(frame, point2, context) {
-  const local = sub3$3(point2, frame.origin);
+  const local = sub3$4(point2, frame.origin);
   const axial = dot3$6(local, frame.axis);
   const radialVector = [local[0] - frame.axis[0] * axial, local[1] - frame.axis[1] * axial, local[2] - frame.axis[2] * axial];
   return { axial, radial: Math.hypot(radialVector[0], radialVector[1], radialVector[2]), direction: normalize3$5(radialVector, context) };
@@ -30232,9 +30275,9 @@ function triangulateBoundedLinearSurfaceOfRevolution(records, curveId, axis, loo
   return triangulateBoundedLineCurveSurfaceOfRevolution(line2, axis, loop, sameSense, filePath, context);
 }
 function triangulateBoundedLineCurveSurfaceOfRevolution(line2, axis, loop, sameSense, filePath, context) {
-  const startAxial = dot3$6(sub3$3(line2.point, axis.origin), axis.axis);
+  const startAxial = dot3$6(sub3$4(line2.point, axis.origin), axis.axis);
   const end = linePoint(line2, 1);
-  const endAxial = dot3$6(sub3$3(end, axis.origin), axis.axis);
+  const endAxial = dot3$6(sub3$4(end, axis.origin), axis.axis);
   const axialSpan = endAxial - startAxial;
   if (Math.abs(axialSpan) <= 1e-8)
     failStepImport(filePath, `${context} bounded SURFACE_OF_REVOLUTION LINE profile must change along the revolution axis.`);
@@ -30263,7 +30306,7 @@ function trimmedLineCurveForSurfaceOfRevolution(records, curve, filePath, contex
   const sameSense = stepBoolean(curve.args[4], `TRIMMED_CURVE #${curve.id} sense agreement`);
   const point2 = sameSense ? start : end;
   const target = sameSense ? end : start;
-  const delta = sub3$3(target, point2);
+  const delta = sub3$4(target, point2);
   const magnitude = Math.hypot(delta[0], delta[1], delta[2]);
   if (magnitude <= 1e-10) failStepImport(filePath, `${context} TRIMMED_CURVE LINE profile has zero length.`);
   return {
@@ -30274,10 +30317,10 @@ function trimmedLineCurveForSurfaceOfRevolution(records, curve, filePath, contex
 }
 function revolvedCircleTorus(records, curveId, axis, filePath, context) {
   const circle2 = resolveCircle(records, curveId, filePath);
-  const centerOffset = sub3$3(circle2.frame.origin, axis.origin);
+  const centerOffset = sub3$4(circle2.frame.origin, axis.origin);
   const axial = dot3$6(centerOffset, axis.axis);
   const axisPoint = addScaled$2(axis.origin, axis.axis, axial);
-  const radial = sub3$3(circle2.frame.origin, axisPoint);
+  const radial = sub3$4(circle2.frame.origin, axisPoint);
   const majorRadius = Math.hypot(radial[0], radial[1], radial[2]);
   if (majorRadius <= 1e-8) failStepImport(filePath, `${context} SURFACE_OF_REVOLUTION circle profile is centered on the axis.`);
   if (majorRadius <= circle2.radius)
@@ -30289,7 +30332,7 @@ function revolvedCircleTorus(records, curveId, axis, filePath, context) {
   return { frame, majorRadius, minorRadius: circle2.radius };
 }
 function revolutionAngle(frame, point2, filePath, context) {
-  const local = sub3$3(point2, frame.origin);
+  const local = sub3$4(point2, frame.origin);
   const x2 = dot3$6(local, frame.xAxis);
   const y2 = dot3$6(local, frame.yAxis);
   if (Math.hypot(x2, y2) <= 1e-12) failStepImport(filePath, `${context} major angle is degenerate.`);
@@ -30331,10 +30374,10 @@ function orientRevolvedProfileTriangles(triangles, frame, axis, profileCenter, p
     ];
     const angle = revolutionAngle(frame, sample, filePath, "SURFACE_OF_REVOLUTION");
     const center = rotateAroundAxis(profileCenter, axis, normalizeAngleDelta(angle - profileAngle));
-    const outward = sub3$3(sample, center);
+    const outward = sub3$4(sample, center);
     if (Math.hypot(outward[0], outward[1], outward[2]) <= 1e-12)
       failStepImport(filePath, "SURFACE_OF_REVOLUTION sample hit degenerate profile centerline.");
-    const normal2 = cross3$5(sub3$3(triangle[1], triangle[0]), sub3$3(triangle[2], triangle[0]));
+    const normal2 = cross3$5(sub3$4(triangle[1], triangle[0]), sub3$4(triangle[2], triangle[0]));
     const outwardFacing = dot3$6(normal2, outward) >= 0;
     return sameSense === outwardFacing ? triangle : reverseTriangle(triangle);
   });
@@ -30418,7 +30461,7 @@ function triangulateBoundedToroidalTubeSegment(frame, majorRadius, minorRadius,
     const loop = compactLoops[loopIndex];
     const majorAngle = majorAngles[loopIndex];
     for (const point2 of loop) {
-      const local = sub3$3(point2, frame.origin);
+      const local = sub3$4(point2, frame.origin);
       const x2 = dot3$6(local, frame.xAxis);
       const y2 = dot3$6(local, frame.yAxis);
       const radialLength = Math.hypot(x2, y2);
@@ -30953,7 +30996,7 @@ function triangulateClosedVBSplineSurfaceBand(surface, loops, sameSense, filePat
   }
   return orientBridgeTriangles(triangles, centroid(a2.points), centroid(b.points), sameSense);
 }
-function sub3$3(a2, b) {
+function sub3$4(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
 function newellNormal(points) {
@@ -30992,9 +31035,9 @@ function triangulateBoundedSphericalCap(frame, radius, loop, sameSense, filePath
   }
   const boundaryCenter = centroid(boundary);
   const capDirection = normalize3$5(newellNormal(boundary), `${context} bounded SPHERICAL_SURFACE boundary normal`);
-  const maxPlaneError = boundary.reduce((max2, point2) => Math.max(max2, Math.abs(dot3$6(sub3$3(point2, boundaryCenter), capDirection))), 0);
+  const maxPlaneError = boundary.reduce((max2, point2) => Math.max(max2, Math.abs(dot3$6(sub3$4(point2, boundaryCenter), capDirection))), 0);
   if (maxPlaneError > tolerance) failStepImport(filePath, `${context} bounded SPHERICAL_SURFACE boundary loop is not planar.`);
-  const boundaryDirections = boundary.map((point2) => normalize3$5(sub3$3(point2, frame.origin), `${context} bounded SPHERICAL_SURFACE point`));
+  const boundaryDirections = boundary.map((point2) => normalize3$5(sub3$4(point2, frame.origin), `${context} bounded SPHERICAL_SURFACE point`));
   const maxAngle = boundaryDirections.reduce((max2, direction2) => Math.max(max2, Math.acos(clamp$8(dot3$6(direction2, capDirection), -1, 1))), 0);
   if (Math.PI - maxAngle <= 1e-6) failStepImport(filePath, `${context} bounded SPHERICAL_SURFACE cap is degenerate.`);
   const radialSegments = Math.max(4, Math.ceil(maxAngle / (Math.PI / 24)));
@@ -31033,17 +31076,17 @@ function sphericalLoopInfo(frame, radius, loop, filePath, context) {
   }
   const center = centroid(points);
   const normal2 = normalize3$5(newellNormal(points), `${context} bounded SPHERICAL_SURFACE boundary normal`);
-  const maxPlaneError = points.reduce((max2, point2) => Math.max(max2, Math.abs(dot3$6(sub3$3(point2, center), normal2))), 0);
+  const maxPlaneError = points.reduce((max2, point2) => Math.max(max2, Math.abs(dot3$6(sub3$4(point2, center), normal2))), 0);
   if (maxPlaneError > tolerance) failStepImport(filePath, `${context} bounded SPHERICAL_SURFACE boundary loop is not planar.`);
   return { points, center, normal: normal2 };
 }
 function triangulateBoundedSphericalBand(frame, radius, loops, sameSense, filePath, context) {
   if (loops.length !== 2) failStepImport(filePath, `${context} bounded SPHERICAL_SURFACE band supports exactly two loops right now.`);
   const [aInfo, bInfo] = loops.map((loop) => sphericalLoopInfo(frame, radius, loop, filePath, context));
-  const axis = normalize3$5(sub3$3(bInfo.center, aInfo.center), `${context} bounded SPHERICAL_SURFACE band axis`);
+  const axis = normalize3$5(sub3$4(bInfo.center, aInfo.center), `${context} bounded SPHERICAL_SURFACE band axis`);
   const tolerance = Math.max(1e-5, radius * 1e-4);
   const axisPointError = (point2) => {
-    const local = sub3$3(point2, frame.origin);
+    const local = sub3$4(point2, frame.origin);
     const projected = addScaled$2(frame.origin, axis, dot3$6(local, axis));
     return Math.hypot(point2[0] - projected[0], point2[1] - projected[1], point2[2] - projected[2]);
   };
@@ -31052,12 +31095,12 @@ function triangulateBoundedSphericalBand(frame, radius, loops, sameSense, filePa
   const count = Math.max(aInfo.points.length, bInfo.points.length, 8);
   const aLoop = resampleClosedLoop(aInfo.points, count);
   let bLoop = resampleClosedLoop(bInfo.points, count);
-  const rawX = sub3$3(aLoop[0], aInfo.center);
+  const rawX = sub3$4(aLoop[0], aInfo.center);
   const xProjection = dot3$6(rawX, axis);
   const xAxis = normalize3$5([rawX[0] - axis[0] * xProjection, rawX[1] - axis[1] * xProjection, rawX[2] - axis[2] * xProjection], context);
   const yAxis = cross3$5(axis, xAxis);
   const loopAngle = (point2, center) => {
-    const local = sub3$3(point2, center);
+    const local = sub3$4(point2, center);
     return Math.atan2(dot3$6(local, yAxis), dot3$6(local, xAxis));
   };
   const rotateLoop = (loop, center, targetAngle) => {
@@ -31078,8 +31121,8 @@ function triangulateBoundedSphericalBand(frame, radius, loops, sameSense, filePa
   const reversed = rotateLoop([...bLoop].reverse(), bInfo.center, aAngles[0]);
   bLoop = sequenceMismatch(forward) <= sequenceMismatch(reversed) ? forward : reversed;
   const angularSpan = aLoop.reduce((max2, point2, index2) => {
-    const aDirection = normalize3$5(sub3$3(point2, frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
-    const bDirection = normalize3$5(sub3$3(bLoop[index2], frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
+    const aDirection = normalize3$5(sub3$4(point2, frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
+    const bDirection = normalize3$5(sub3$4(bLoop[index2], frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
     return Math.max(max2, Math.acos(clamp$8(dot3$6(aDirection, bDirection), -1, 1)));
   }, 0);
   if (angularSpan <= 1e-6) failStepImport(filePath, `${context} bounded SPHERICAL_SURFACE band has zero angular span.`);
@@ -31089,8 +31132,8 @@ function triangulateBoundedSphericalBand(frame, radius, loops, sameSense, filePa
     const t = ringIndex / radialSegments;
     rings.push(
       aLoop.map((point2, index2) => {
-        const aDirection = normalize3$5(sub3$3(point2, frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
-        const bDirection = normalize3$5(sub3$3(bLoop[index2], frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
+        const aDirection = normalize3$5(sub3$4(point2, frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
+        const bDirection = normalize3$5(sub3$4(bLoop[index2], frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
         return addScaled$2(frame.origin, slerpUnit(aDirection, bDirection, t), radius);
       })
     );
@@ -33139,14 +33182,14 @@ function cross$6(a2, b) {
 function isFiniteNumber$1(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
-function isVec3$2(value) {
+function isVec3$3(value) {
   return Array.isArray(value) && value.length === 3 && value.every(isFiniteNumber$1);
 }
 function isVec2(value) {
   return Array.isArray(value) && value.length === 2 && value.every(isFiniteNumber$1);
 }
 function isRuledRails(value) {
-  return Array.isArray(value) && value.length === 2 && value.every((rail2) => Array.isArray(rail2) && rail2.length === 2 && rail2.every(isVec3$2));
+  return Array.isArray(value) && value.length === 2 && value.every((rail2) => Array.isArray(rail2) && rail2.length === 2 && rail2.every(isVec3$3));
 }
 function axisSpan(face, axis) {
   if (face.vertices.length === 0) return 0;
@@ -33163,14 +33206,14 @@ function isRationalWeights(weights) {
   return Boolean(weights == null ? void 0 : weights.some((row) => row.some((weight) => Math.abs(weight - 1) > 1e-9)));
 }
 function explicitGeometrySurface(geometry, face) {
-  if ("Plane" in geometry && isVec3$2(geometry.Plane.normal)) {
+  if ("Plane" in geometry && isVec3$3(geometry.Plane.normal)) {
     return { kind: "plane", normal: normalizeVec3$3(geometry.Plane.normal) };
   }
   if ("AnalyticCylinder" in geometry) {
     const origin = geometry.AnalyticCylinder.axis_origin;
     const axis = geometry.AnalyticCylinder.axis_direction;
     const radius = geometry.AnalyticCylinder.radius;
-    if (isVec3$2(origin) && isVec3$2(axis) && isFiniteNumber$1(radius) && radius > 0) {
+    if (isVec3$3(origin) && isVec3$3(axis) && isFiniteNumber$1(radius) && radius > 0) {
       const normalizedAxis = normalizeVec3$3(axis);
       return { kind: "cylinder", origin, axis: normalizedAxis, radius, height: axisSpan(face, normalizedAxis) };
     }
@@ -33180,7 +33223,7 @@ function explicitGeometrySurface(geometry, face) {
     const axis = geometry.AnalyticCone.axis_direction;
     const radiusBottom = geometry.AnalyticCone.radius_start;
     const radiusTop = geometry.AnalyticCone.radius_end;
-    if (isVec3$2(origin) && isVec3$2(axis) && isFiniteNumber$1(radiusBottom) && isFiniteNumber$1(radiusTop)) {
+    if (isVec3$3(origin) && isVec3$3(axis) && isFiniteNumber$1(radiusBottom) && isFiniteNumber$1(radiusTop)) {
       const normalizedAxis = normalizeVec3$3(axis);
       return {
         kind: "cone",
@@ -33195,7 +33238,7 @@ function explicitGeometrySurface(geometry, face) {
   if ("AnalyticSphere" in geometry) {
     const center = geometry.AnalyticSphere.center;
     const radius = geometry.AnalyticSphere.radius;
-    if (isVec3$2(center) && isFiniteNumber$1(radius) && radius > 0) {
+    if (isVec3$3(center) && isFiniteNumber$1(radius) && radius > 0) {
       return { kind: "sphere", center, radius };
     }
   }
@@ -33204,7 +33247,7 @@ function explicitGeometrySurface(geometry, face) {
     const axis = geometry.AnalyticTorus.axis;
     const majorRadius = geometry.AnalyticTorus.major_radius;
     const minorRadius = geometry.AnalyticTorus.minor_radius;
-    if (isVec3$2(center) && isVec3$2(axis) && isFiniteNumber$1(majorRadius) && isFiniteNumber$1(minorRadius) && majorRadius > 0 && minorRadius > 0) {
+    if (isVec3$3(center) && isVec3$3(axis) && isFiniteNumber$1(majorRadius) && isFiniteNumber$1(minorRadius) && majorRadius > 0 && minorRadius > 0) {
       return { kind: "torus", center, axis: normalizeVec3$3(axis), majorRadius, minorRadius };
     }
   }
@@ -33302,7 +33345,7 @@ function explicitEdgeCurve(geometry, faceName) {
   const center = (_a3 = geometry.CircularArc) == null ? void 0 : _a3.center;
   const axis = (_b3 = geometry.CircularArc) == null ? void 0 : _b3.axis;
   const radius = (_c2 = geometry.CircularArc) == null ? void 0 : _c2.radius;
-  if (center !== void 0 && axis !== void 0 && radius !== void 0 && isVec3$2(center) && isVec3$2(axis) && isFiniteNumber$1(radius) && radius > 0) {
+  if (center !== void 0 && axis !== void 0 && radius !== void 0 && isVec3$3(center) && isVec3$3(axis) && isFiniteNumber$1(radius) && radius > 0) {
     return {
       kind: "circle",
       center,
@@ -33313,7 +33356,7 @@ function explicitEdgeCurve(geometry, faceName) {
   }
   const start = (_d2 = geometry.Line) == null ? void 0 : _d2.start;
   const end = (_e2 = geometry.Line) == null ? void 0 : _e2.end;
-  if (isVec3$2(start) && isVec3$2(end)) return makeLineEdgeCurve(start, end, faceName);
+  if (isVec3$3(start) && isVec3$3(end)) return makeLineEdgeCurve(start, end, faceName);
   const polyline = geometry.PolylineUv;
   if (polyline && Array.isArray(polyline.points)) {
     const points = polyline.points.filter(isVec2);
@@ -33658,7 +33701,7 @@ function topologyPayloadToTopology(payload) {
     if (explicitEdge.visual === false) continue;
     const start = explicitVertices[explicitEdge.vertices[0]];
     const end = explicitVertices[explicitEdge.vertices[1]];
-    if (!isVec3$2(start) || !isVec3$2(end)) continue;
+    if (!isVec3$3(start) || !isVec3$3(end)) continue;
     const key2 = edgeKey(start, end);
     if (seenEdges.has(key2)) continue;
     seenEdges.set(key2, edges.size);
@@ -33822,6 +33865,7 @@ const _TruckShapeBackend = class _TruckShapeBackend {
     const payload = JSON.parse(getTruckGeometryWasm().geometry_mesh(this.getLiveHandle("getMesh()")));
     const numTri = payload.triangles.length / 3;
     const numVert = payload.positions.length / 3;
+    const cornerNormals = payload.normals && payload.normals.length === numTri * 9 ? new Float32Array(payload.normals) : void 0;
     this.resource.mesh = {
       numProp: 3,
       numTri,
@@ -33835,7 +33879,8 @@ const _TruckShapeBackend = class _TruckShapeBackend {
       runTransform: new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0]),
       faceID: new Int32Array(payload.face_ids),
       faceIdNames: payload.face_id_names ?? [],
-      halfedgeTangent: new Float32Array(0)
+      halfedgeTangent: new Float32Array(0),
+      cornerNormals
     };
     return this.resource.mesh;
   }
@@ -35056,6 +35101,16 @@ function boundsInteriorOverlap(a2, b) {
   const tolerance = 1e-8;
   return Math.min(a2.max[0], b.max[0]) - Math.max(a2.min[0], b.min[0]) > tolerance && Math.min(a2.max[1], b.max[1]) - Math.max(a2.min[1], b.min[1]) > tolerance && Math.min(a2.max[2], b.max[2]) - Math.max(a2.min[2], b.min[2]) > tolerance;
 }
+function boundsFaceOrInteriorOverlap(a2, b) {
+  const tolerance = 1e-8;
+  const overlaps = [
+    Math.min(a2.max[0], b.max[0]) - Math.max(a2.min[0], b.min[0]),
+    Math.min(a2.max[1], b.max[1]) - Math.max(a2.min[1], b.min[1]),
+    Math.min(a2.max[2], b.max[2]) - Math.max(a2.min[2], b.min[2])
+  ];
+  if (overlaps.some((overlap) => overlap < -tolerance)) return false;
+  return overlaps.filter((overlap) => overlap <= tolerance).length <= 1;
+}
 function boundsFromPoints(points) {
   const first = points[0];
   if (!first) return null;
@@ -35138,16 +35193,16 @@ function shapePlanBounds(plan) {
       return null;
   }
 }
-function hasPairwiseInteriorBoundsOverlap(shapes) {
+function hasPairwiseFaceOrInteriorBoundsOverlap(shapes) {
   const bounds = shapes.map((shape) => shape.boundingBox());
   for (let i = 0; i < bounds.length; i++) {
     for (let j = i + 1; j < bounds.length; j++) {
-      if (boundsInteriorOverlap(bounds[i], bounds[j])) return true;
+      if (boundsFaceOrInteriorOverlap(bounds[i], bounds[j])) return true;
     }
   }
   return false;
 }
-function interiorOverlapComponents(shapes) {
+function faceOrInteriorOverlapComponents(shapes) {
   const bounds = shapes.map((shape) => shape.boundingBox());
   const visited = /* @__PURE__ */ new Set();
   const components = [];
@@ -35161,7 +35216,7 @@ function interiorOverlapComponents(shapes) {
       component.push(current);
       for (let next = 0; next < shapes.length; next++) {
         if (visited.has(next)) continue;
-        if (boundsInteriorOverlap(bounds[current], bounds[next])) {
+        if (boundsFaceOrInteriorOverlap(bounds[current], bounds[next])) {
           visited.add(next);
           queue.push(next);
         }
@@ -35206,10 +35261,10 @@ function lowerGenericBooleanPlan(plan) {
   let returned = null;
   try {
     if (plan.op === "union") {
-      if (!hasPairwiseInteriorBoundsOverlap(shapes)) {
+      if (!hasPairwiseFaceOrInteriorBoundsOverlap(shapes)) {
         return null;
       }
-      const components = interiorOverlapComponents(shapes);
+      const components = faceOrInteriorOverlapComponents(shapes);
       if (components.length > 1) {
         returned = lowerClusteredUnion(shapes, components);
         return returned;
@@ -35739,9 +35794,13 @@ function shapeHasClosedNativeTopology(shape) {
 function normalizeTruckShapeForBooleanInput(shape) {
   if (shapeHasClosedNativeTopology(shape)) return shape;
   if (!meshHasRawBoundaryEdges(shape.getMesh())) return shape;
-  const normalized = normalizeFacetedTruckShape(shape);
-  disposeShapeBackend(shape);
-  return normalized;
+  try {
+    const normalized = normalizeFacetedTruckShape(shape);
+    disposeShapeBackend(shape);
+    return normalized;
+  } catch {
+    return shape;
+  }
 }
 function lowerSdfPlan(plan) {
   if (getUnsupportedSdfProgramReason(plan.tree) === void 0) {
@@ -37625,7 +37684,7 @@ function circleProfilePlan(radius, segments) {
 }
 function annulusProfilePlan(outerRadius, innerRadius, segments) {
   const outer = Math.abs(outerRadius);
-  const inner = Math.abs(innerRadius);
+  const inner = Math.max(0, innerRadius);
   if (outer <= EXACT_PROFILE_EPS) return emptyProfilePlan();
   if (inner <= EXACT_PROFILE_EPS) return circleProfilePlan(outer, segments);
   return {
@@ -42563,11 +42622,11 @@ function requireFiniteVec3$3(v, label) {
   }
   return [x2, y2, z2];
 }
-function len3$2(v) {
+function len3$3(v) {
   return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
 }
 function normalize3$4(v) {
-  const l = len3$2(v);
+  const l = len3$3(v);
   if (l < 1e-10) throw new Error("Cannot normalize zero-length vector");
   return [v[0] / l, v[1] / l, v[2] / l];
 }
@@ -42577,7 +42636,7 @@ function dot3$4(a2, b) {
 function cross3$2(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
-function sub3$2(a2, b) {
+function sub3$3(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
 function negate3$1(v) {
@@ -42600,7 +42659,7 @@ function normalizePortInput(input) {
     const end = requireFiniteVec3$3(input.end, "port end");
     origin = [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2, (start[2] + end[2]) / 2];
     const dir = [end[0] - start[0], end[1] - start[1], end[2] - start[2]];
-    const dirLen = len3$2(dir);
+    const dirLen = len3$3(dir);
     if (dirLen < 1e-10) {
       throw new Error("Port start and end must not be the same point");
     }
@@ -42611,7 +42670,7 @@ function normalizePortInput(input) {
   } else if (hasOriginAxis) {
     origin = requireFiniteVec3$3(input.origin, "port origin");
     const rawAxis = requireFiniteVec3$3(input.axis, "port axis");
-    if (len3$2(rawAxis) < 1e-10) {
+    if (len3$3(rawAxis) < 1e-10) {
       throw new Error("Port axis must be non-zero");
     }
     axis = normalize3$4(rawAxis);
@@ -42627,12 +42686,12 @@ function normalizePortInput(input) {
   let up;
   if (input.up != null) {
     const rawUp = requireFiniteVec3$3(input.up, "port up");
-    if (len3$2(rawUp) < 1e-10) {
+    if (len3$3(rawUp) < 1e-10) {
       throw new Error("Port up vector must be non-zero");
     }
     const proj = dot3$4(rawUp, axis);
     const ortho = [rawUp[0] - proj * axis[0], rawUp[1] - proj * axis[1], rawUp[2] - proj * axis[2]];
-    if (len3$2(ortho) < 1e-10) {
+    if (len3$3(ortho) < 1e-10) {
       throw new Error("Port up vector must not be parallel to axis");
     }
     up = normalize3$4(ortho);
@@ -42696,8 +42755,8 @@ function transformPort(port, matrix) {
   const newOrigin = tx.point(port.origin);
   const rawAxis = tx.vector(port.axis);
   const rawUp = tx.vector(port.up);
-  const axisLen = len3$2(rawAxis);
-  const upLen = len3$2(rawUp);
+  const axisLen = len3$3(rawAxis);
+  const upLen = len3$3(rawUp);
   const out = {
     origin: newOrigin,
     axis: axisLen > 1e-10 ? normalize3$4(rawAxis) : port.axis,
@@ -42749,7 +42808,7 @@ function computeConnectFrame(childBase, childPort, parentPort, _flip, childAlign
     r10 * cI[0] + r11 * cI[1] + r12 * cI[2],
     r20 * cI[0] + r21 * cI[1] + r22 * cI[2]
   ];
-  const t = sub3$2(pOrigin, rcI);
+  const t = sub3$3(pOrigin, rcI);
   const frame = Transform.from([r00, r10, r20, 0, r01, r11, r21, 0, r02, r12, r22, 0, t[0], t[1], t[2], 1]);
   const axis = cAxis;
   return { frame, axis };
@@ -42834,18 +42893,18 @@ function validateConnectorMatch(selfName, selfPort, targetName, targetPort, forc
     }
   }
 }
-function len3$1(v) {
+function len3$2(v) {
   return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
 }
 function normalize3$3(v) {
-  const l = len3$1(v);
+  const l = len3$2(v);
   if (l < 1e-10) throw new Error("Cannot normalize zero-length vector");
   return [v[0] / l, v[1] / l, v[2] / l];
 }
 function cross3$1(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
-function sub3$1(a2, b) {
+function sub3$2(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
 function negate3(v) {
@@ -42868,7 +42927,7 @@ function alignmentMatrix(childOrigin, childAxis, childUp, parentOrigin, parentAx
     r10 * childOrigin[0] + r11 * childOrigin[1] + r12 * childOrigin[2],
     r20 * childOrigin[0] + r21 * childOrigin[1] + r22 * childOrigin[2]
   ];
-  const t = sub3$1(parentOrigin, rc);
+  const t = sub3$2(parentOrigin, rc);
   return Transform.from([r00, r10, r20, 0, r01, r11, r21, 0, r02, r12, r22, 0, t[0], t[1], t[2], 1]);
 }
 function computeSinglePairAlignment(childPort, targetPort) {
@@ -42907,8 +42966,8 @@ function computeMultiPairAlignment(pairs, childPorts, targetPorts, tolerance = 0
     [0, 0, 0]
   ];
   for (const p2 of pairs) {
-    const s = sub3$1(p2.childOrigin, srcCentroid);
-    const t2 = sub3$1(p2.targetOrigin, tgtCentroid);
+    const s = sub3$2(p2.childOrigin, srcCentroid);
+    const t2 = sub3$2(p2.targetOrigin, tgtCentroid);
     for (let i = 0; i < 3; i++) {
       for (let j = 0; j < 3; j++) {
         h[i][j] += s[i] * t2[j];
@@ -42921,7 +42980,7 @@ function computeMultiPairAlignment(pairs, childPorts, targetPorts, tolerance = 0
     R[1][0] * srcCentroid[0] + R[1][1] * srcCentroid[1] + R[1][2] * srcCentroid[2],
     R[2][0] * srcCentroid[0] + R[2][1] * srcCentroid[1] + R[2][2] * srcCentroid[2]
   ];
-  const t = sub3$1(tgtCentroid, rSrc);
+  const t = sub3$2(tgtCentroid, rSrc);
   const transform = Transform.from([
     R[0][0],
     R[1][0],
@@ -42943,8 +43002,8 @@ function computeMultiPairAlignment(pairs, childPorts, targetPorts, tolerance = 0
   const residuals = [];
   for (const p2 of pairs) {
     const transformed = transform.point(p2.childOrigin);
-    const diff = sub3$1(transformed, p2.targetOrigin);
-    residuals.push(len3$1(diff));
+    const diff = sub3$2(transformed, p2.targetOrigin);
+    residuals.push(len3$2(diff));
   }
   const maxResidual = Math.max(...residuals);
   if (maxResidual > tolerance) {
@@ -43144,8 +43203,8 @@ function getConnectorDistance(ports, nameA, nameB) {
   const b = ports[nameB];
   if (!a2) throw new Error(`connectorDistance: unknown connector "${nameA}"`);
   if (!b) throw new Error(`connectorDistance: unknown connector "${nameB}"`);
-  const d2 = sub3$1(a2.origin, b.origin);
-  return len3$1(d2);
+  const d2 = sub3$2(a2.origin, b.origin);
+  return len3$2(d2);
 }
 function getConnectorMeasurements(ports, name) {
   const p2 = ports[name];
@@ -48750,8 +48809,7 @@ function sculptLook(preset = "gallery") {
           { type: "directional", position: [90, -110, 150], color: "#ffffff", intensity: 1.4 },
           { type: "directional", position: [-120, 70, 80], color: "#dcecff", intensity: 0.65 },
           { type: "hemisphere", skyColor: "#d9edff", groundColor: "#f0e6d4", intensity: 0.45 }
-        ],
-        postProcessing: { toneMappingExposure: 1.12, vignette: { darkness: 0.16, offset: 0.6 } }
+        ]
       };
     case "candy-shop":
       return {
@@ -48762,8 +48820,7 @@ function sculptLook(preset = "gallery") {
           { type: "point", position: [70, -60, 90], color: "#ff8ac8", intensity: 2.2, distance: 280, decay: 1.2 },
           { type: "point", position: [-85, 80, 70], color: "#70e1ff", intensity: 1.8, distance: 260, decay: 1.4 },
           { type: "directional", position: [30, -80, 140], color: "#fff6dd", intensity: 0.9 }
-        ],
-        postProcessing: { toneMappingExposure: 1.25, bloom: { intensity: 0.35, threshold: 0.78, radius: 0.45 } }
+        ]
       };
     case "midnight":
       return {
@@ -48775,8 +48832,7 @@ function sculptLook(preset = "gallery") {
           { type: "point", position: [-90, 70, 50], color: "#ff7ac8", intensity: 1.4, distance: 300, decay: 1.3 },
           { type: "directional", position: [30, -30, 160], color: "#d7e9ff", intensity: 0.65 }
         ],
-        fog: { color: "#060814", near: 180, far: 520 },
-        postProcessing: { toneMappingExposure: 1.35, bloom: { intensity: 0.65, threshold: 0.65, radius: 0.6 } }
+        fog: { color: "#060814", near: 180, far: 520 }
       };
     case "workbench":
       return {
@@ -48787,8 +48843,7 @@ function sculptLook(preset = "gallery") {
           { type: "directional", position: [80, -100, 130], color: "#fff5df", intensity: 1.25 },
           { type: "hemisphere", skyColor: "#eef6ff", groundColor: "#d8d0c0", intensity: 0.35 }
         ],
-        ground: { visible: true, color: "#d8d4ca", offset: 1, receiveShadow: true },
-        postProcessing: { toneMappingExposure: 1.05 }
+        ground: { visible: true, color: "#d8d4ca", offset: 1, receiveShadow: true }
       };
     default:
       return {
@@ -48799,8 +48854,7 @@ function sculptLook(preset = "gallery") {
           { type: "directional", position: [110, -130, 150], color: "#ffffff", intensity: 1.5 },
           { type: "directional", position: [-90, 80, 90], color: "#b8d8ff", intensity: 0.55 },
           { type: "hemisphere", skyColor: "#ddefff", groundColor: "#e8e2d8", intensity: 0.45 }
-        ],
-        postProcessing: { toneMappingExposure: 1.18, vignette: { darkness: 0.18, offset: 0.55 } }
+        ]
       };
   }
 }
@@ -50621,7 +50675,7 @@ class Shape {
    *
    * Use `.color()` to set the base diffuse color; `.material()` controls how that color behaves
    * under light (metalness, roughness, clearcoat) and can add emissive glow independent of
-   * lighting. Emissive glow pairs naturally with the `postProcessing.bloom` effect in `scene()`.
+   * lighting.
    *
    * **Example**
    *
@@ -53031,14 +53085,14 @@ function dot3$2(a2, b) {
 function cross3(a2, b) {
   return [a2[1] * b[2] - a2[2] * b[1], a2[2] * b[0] - a2[0] * b[2], a2[0] * b[1] - a2[1] * b[0]];
 }
-function sub3(a2, b) {
+function sub3$1(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
-function len3(v) {
+function len3$1(v) {
   return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
 }
 function normalize3(v) {
-  const l = len3(v);
+  const l = len3$1(v);
   if (l < EPS$8) return [0, 0, 0];
   return [v[0] / l, v[1] / l, v[2] / l];
 }
@@ -53050,7 +53104,7 @@ const alignDef = {
     const faceB = ctx.worldFace(constraint.refB.bodyId, constraint.refB.featureName);
     const n1 = faceA.normal;
     const n2 = faceB.normal;
-    const delta = sub3(faceB.center, faceA.center);
+    const delta = sub3$1(faceB.center, faceA.center);
     const parallel = dot3$2(n1, n2) - 1;
     const normalDist = dot3$2(delta, n1);
     const cx = n1[1] * n2[2] - n1[2] * n2[1];
@@ -53093,7 +53147,7 @@ const concentricDef = {
     const axisA = ctx.worldAxis(constraint.refA.bodyId, constraint.refA.featureName);
     const axisB = ctx.worldAxis(constraint.refB.bodyId, constraint.refB.featureName);
     const dirCross = cross3(axisA.direction, axisB.direction);
-    const delta = sub3(axisB.origin, axisA.origin);
+    const delta = sub3$1(axisB.origin, axisA.origin);
     const offsetCross = cross3(delta, axisA.direction);
     const pickTwo = (v) => {
       const ax = Math.abs(v[0]);
@@ -53117,9 +53171,9 @@ const faceDistanceDef = {
     const distance2 = constraint.value ?? 0;
     const n1 = faceA.normal;
     const n2 = faceB.normal;
-    const delta = sub3(faceB.center, faceA.center);
+    const delta = sub3$1(faceB.center, faceA.center);
     const antiParallel = dot3$2(n1, n2) + 1;
-    const crossMag = len3(cross3(n1, n2));
+    const crossMag = len3$1(cross3(n1, n2));
     const signedDist = dot3$2(delta, n1) - distance2;
     return [antiParallel, crossMag, signedDist];
   }
@@ -53139,7 +53193,7 @@ const flushDef = {
     const faceB = ctx.worldFace(constraint.refB.bodyId, constraint.refB.featureName);
     const n1 = faceA.normal;
     const n2 = faceB.normal;
-    const delta = sub3(faceB.center, faceA.center);
+    const delta = sub3$1(faceB.center, faceA.center);
     const antiParallel = dot3$2(n1, n2) + 1;
     const normalDist = dot3$2(delta, n1);
     const cx = n1[1] * n2[2] - n1[2] * n2[1];
@@ -53179,7 +53233,7 @@ const pointOnAxisDef = {
   residual(constraint, ctx) {
     const point2 = ctx.worldPoint(constraint.refA.bodyId, constraint.refA.featureName);
     const axis = ctx.worldAxis(constraint.refB.bodyId, constraint.refB.featureName);
-    const delta = sub3(point2, axis.origin);
+    const delta = sub3$1(point2, axis.origin);
     const c2 = cross3(delta, axis.direction);
     const ax = Math.abs(c2[0]);
     const ay = Math.abs(c2[1]);
@@ -53195,7 +53249,7 @@ const pointOnFaceDef = {
   residual(constraint, ctx) {
     const point2 = ctx.worldPoint(constraint.refA.bodyId, constraint.refA.featureName);
     const face = ctx.worldFace(constraint.refB.bodyId, constraint.refB.featureName);
-    const delta = sub3(point2, face.center);
+    const delta = sub3$1(point2, face.center);
     return [dot3$2(delta, face.normal)];
   }
 };
@@ -53744,7 +53798,7 @@ function runWithForgeValidationPolicy(policy, fn) {
 }
 let _collected$8 = 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 isVec3$2 = (value) => Array.isArray(value) && value.length === 3 && isFiniteNumber(value[0]) && isFiniteNumber(value[1]) && isFiniteNumber(value[2]);
 const normalizeAxis = (axis) => {
   const len2 = Math.hypot(axis[0], axis[1], axis[2]);
   if (len2 <= 1e-8) throw new Error("jointsView joint axis must be non-zero");
@@ -53779,10 +53833,10 @@ const normalizeJoint = (joint2) => {
     throw new Error(`jointsView joint "${name}" type must be "revolute" or "prismatic"`);
   }
   const axisRaw = joint2.axis ?? [0, 0, 1];
-  if (!isVec3$1(axisRaw)) throw new Error(`jointsView joint "${name}" axis must be [x, y, z]`);
+  if (!isVec3$2(axisRaw)) throw new Error(`jointsView joint "${name}" axis must be [x, y, z]`);
   const axis = normalizeAxis([axisRaw[0], axisRaw[1], axisRaw[2]]);
   const pivotRaw = joint2.pivot ?? [0, 0, 0];
-  if (!isVec3$1(pivotRaw)) throw new Error(`jointsView joint "${name}" pivot must be [x, y, z]`);
+  if (!isVec3$2(pivotRaw)) throw new Error(`jointsView joint "${name}" pivot must be [x, y, z]`);
   const pivot = [pivotRaw[0], pivotRaw[1], pivotRaw[2]];
   if (joint2.min !== void 0 && !isFiniteNumber(joint2.min)) {
     throw new Error(`jointsView joint "${name}" min must be a finite number`);
@@ -54701,7 +54755,7 @@ function deriveExplodeHintsFromMates(constraints, result, bodies, ctx) {
           const posA = result.transforms.get(c2.refA.bodyId);
           const posB = result.transforms.get(c2.refB.bodyId);
           if (posA && posB) {
-            const raw = sub3(bodyA.grounded ? posB.position : posA.position, bodyA.grounded ? posA.position : posB.position);
+            const raw = sub3$1(bodyA.grounded ? posB.position : posA.position, bodyA.grounded ? posA.position : posB.position);
             dir = normalize3(raw);
           }
           break;
@@ -55227,8 +55281,8 @@ class Assembly {
    *
    * Use this after adding physical parts and joints. Robot-body profiles require
    * `rootPart`; asset profiles can describe one-part or multi-part physical assets.
-   * URDF/SDF exporters and `forgecad check simready` read this contract directly,
-   * so model files no longer need a separate `robotExport(...)` side effect.
+   * URDF/SDF/MJCF/USD exporters and `forgecad check simready` read this
+   * contract directly from the returned assembly.
    *
    * @category Assembly
    */
@@ -64532,7 +64586,7 @@ function beltDrive(options) {
 }
 const GEAR_META_KEY = Symbol.for("forgecad.library.gearMeta");
 const EPSILON$1 = 1e-9;
-function clamp01$1(value) {
+function clamp01$2(value) {
   return Math.max(-1, Math.min(1, value));
 }
 function isFinitePositive(value) {
@@ -64552,7 +64606,7 @@ function addArcPoints(target, radius, startAngle, endAngle, steps, includeStart
   }
 }
 function flankAngleAtRadius(radius, baseRadius, halfThicknessAtPitch, pressureAngleRad) {
-  const alphaAtRadius = Math.acos(clamp01$1(baseRadius / Math.max(radius, baseRadius)));
+  const alphaAtRadius = Math.acos(clamp01$2(baseRadius / Math.max(radius, baseRadius)));
   return halfThicknessAtPitch + involuteFn(pressureAngleRad) - involuteFn(alphaAtRadius);
 }
 function addRootFilletPoints(target, rootRadius, filletRadius, flankAngle, sign2, fromFlank, steps) {
@@ -65672,7 +65726,7 @@ function gearPair(options) {
       message: `Center distance ${centerDistance.toFixed(4)} exceeds addendum reach ${addendumReach.toFixed(4)} (no mesh contact)`
     });
   }
-  const cosWorking = clamp01$1(baseSum / Math.max(centerDistance, EPSILON$1));
+  const cosWorking = clamp01$2(baseSum / Math.max(centerDistance, EPSILON$1));
   const alphaWorking = Math.acos(cosWorking);
   const basePitch = Math.PI * module * Math.cos(alpha);
   const pathLength = Math.sqrt(Math.max(0, pinion.meta.outerRadius ** 2 - pinion.meta.baseRadius ** 2)) + Math.sqrt(Math.max(0, gear.meta.outerRadius ** 2 - gear.meta.baseRadius ** 2)) - centerDistance * Math.sin(alphaWorking);
@@ -66385,7 +66439,8 @@ const partLibrary = {
 const EDGE_THRESHOLD_DOT = Math.cos(Math.PI / 180);
 const SMOOTH_THRESHOLD_DOT = Math.cos(30 * Math.PI / 180);
 function computeGeometryArrays(mesh, options = {}) {
-  const { numProp, numTri: triCount, triVerts, vertProperties, vertNormals } = mesh;
+  const { numProp, numTri: triCount, triVerts, vertProperties, vertNormals, cornerNormals } = mesh;
+  const useCornerNormals = !!cornerNormals && cornerNormals.length === triCount * 9;
   const positions = new Float32Array(triCount * 9);
   const normals = new Float32Array(triCount * 9);
   const faceNx = new Float32Array(triCount);
@@ -66417,7 +66472,9 @@ function computeGeometryArrays(mesh, options = {}) {
     positions[o + 6] = cx;
     positions[o + 7] = cy;
     positions[o + 8] = cz;
-    if (vertNormals) {
+    if (useCornerNormals) {
+      for (let k2 = 0; k2 < 9; k2++) normals[o + k2] = cornerNormals[o + k2];
+    } else if (vertNormals) {
       normals[o] = vertNormals[i0 * 3];
       normals[o + 1] = vertNormals[i0 * 3 + 1];
       normals[o + 2] = vertNormals[i0 * 3 + 2];
@@ -66460,7 +66517,7 @@ function computeGeometryArrays(mesh, options = {}) {
     faceNy[t] = fny;
     faceNz[t] = fnz;
   }
-  if (!vertNormals && numProp < 6 && triCount > 0) {
+  if (!useCornerNormals && !vertNormals && numProp < 6 && triCount > 0) {
     computeAutoSmoothNormals(
       triVerts,
       vertProperties,
@@ -66625,26 +66682,26 @@ function getPendingShapeHighlights() {
 function resetPendingShapeHighlights() {
   pendingShapeHighlights = [];
 }
-function isVec3(v) {
+function isVec3$1(v) {
   return Array.isArray(v) && v.length === 3 && typeof v[0] === "number" && typeof v[1] === "number" && typeof v[2] === "number";
 }
 function isEdgePair(v) {
-  return Array.isArray(v) && v.length === 2 && isVec3(v[0]) && isVec3(v[1]);
+  return Array.isArray(v) && v.length === 2 && isVec3$1(v[0]) && isVec3$1(v[1]);
 }
 function isPlaneSpec(v) {
   if (typeof v !== "object" || v === null) return false;
   const obj = v;
-  return isVec3(obj.normal) && (typeof obj.offset === "number" || isVec3(obj.point));
+  return isVec3$1(obj.normal) && (typeof obj.offset === "number" || isVec3$1(obj.point));
 }
 function isFaceRef$1(v) {
   if (typeof v !== "object" || v === null) return false;
   const obj = v;
-  return isVec3(obj.normal) && isVec3(obj.center) && typeof obj.name === "string";
+  return isVec3$1(obj.normal) && isVec3$1(obj.center) && typeof obj.name === "string";
 }
 function isEdgeRef(v) {
   if (typeof v !== "object" || v === null) return false;
   const obj = v;
-  return isVec3(obj.start) && isVec3(obj.end) && typeof obj.name === "string";
+  return isVec3$1(obj.start) && isVec3$1(obj.end) && typeof obj.name === "string";
 }
 function requireFiniteVec3(v, name) {
   for (let i = 0; i < 3; i++) {
@@ -66683,7 +66740,7 @@ function highlight(target, opts) {
     });
     return;
   }
-  if (isVec3(target)) {
+  if (isVec3$1(target)) {
     requireFiniteVec3(target, "point");
     collectedDebugHighlights3D.push({
       kind: "point",
@@ -67727,7 +67784,7 @@ const PRESETS = {
   }
 };
 new Set(Object.keys(PRESETS));
-function clamp01(value) {
+function clamp01$1(value) {
   return Math.max(0, Math.min(1, value));
 }
 function applyMaterial(shape, preset) {
@@ -67749,7 +67806,7 @@ const materials = {
   clearPolycarbonate(options = {}) {
     return {
       color: options.tint ?? "#bdefff",
-      material: { opacity: clamp01(options.opacity ?? 0.34), roughness: 0.08, metalness: 0, clearcoat: 1, clearcoatRoughness: 0.03 }
+      material: { opacity: clamp01$1(options.opacity ?? 0.34), roughness: 0.08, metalness: 0, clearcoat: 1, clearcoatRoughness: 0.03 }
     };
   },
   /** Brushed steel-like material for trim, soleplates, and hardware. */
@@ -68226,31 +68283,6 @@ function validateFog(fog, label) {
   if (fog.density !== void 0) out.density = requireFinite$5(fog.density, `${label}.density`);
   return out;
 }
-function validatePostProcessing(pp, label) {
-  const out = {};
-  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$5(pp.bloom.intensity, `${label}.bloom.intensity`);
-    if (pp.bloom.threshold !== void 0) out.bloom.threshold = requireFinite$5(pp.bloom.threshold, `${label}.bloom.threshold`);
-    if (pp.bloom.radius !== void 0) out.bloom.radius = requireFinite$5(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$5(pp.vignette.darkness, `${label}.vignette.darkness`);
-    if (pp.vignette.offset !== void 0) out.vignette.offset = requireFinite$5(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$5(pp.grain.intensity, `${label}.grain.intensity`);
-  }
-  if (pp.toneMappingExposure !== void 0) {
-    out.toneMappingExposure = requireFinite$5(pp.toneMappingExposure, `${label}.toneMappingExposure`);
-  }
-  return out;
-}
 function validateGround(ground, label) {
   const out = {};
   if (ground.visible !== void 0) {
@@ -68332,7 +68364,6 @@ function scene(options) {
     lights: null,
     environment: null,
     fog: null,
-    postProcessing: null,
     ground: null,
     capture: null
   };
@@ -68372,12 +68403,9 @@ function scene(options) {
     }
     current.fog = validateFog(options.fog, "scene.fog");
   }
-  if (options.postProcessing !== void 0) {
-    if (!options.postProcessing || typeof options.postProcessing !== "object") {
-      throw new Error("scene.postProcessing must be an object");
-    }
-    const validated = validatePostProcessing(options.postProcessing, "scene.postProcessing");
-    current.postProcessing = current.postProcessing ? { ...current.postProcessing, ...validated } : validated;
+  const disabledPostProcessing = options.postProcessing;
+  if (disabledPostProcessing !== void 0) {
+    console.warn("scene.postProcessing is disabled for now while the browser post-processing path is being rebuilt.");
   }
   if (options.ground !== void 0) {
     if (!options.ground || typeof options.ground !== "object") {
@@ -68537,8 +68565,7 @@ function scenePreset(name) {
         { type: "hemisphere", skyColor: "#ffffff", groundColor: "#d5d9de", intensity: 0.75 },
         { type: "directional", position: [90, -120, 180], color: "#ffffff", intensity: 1.8, castShadow: true },
         { type: "directional", position: [-140, 100, 80], color: "#dfe9ff", intensity: 0.55 }
-      ],
-      postProcessing: { toneMappingExposure: 1.08 }
+      ]
     });
     return;
   }
@@ -68780,8 +68807,8 @@ function shapeBoundsCenter(shape) {
   ];
 }
 class ProductSurfaceRef {
-  constructor(skin, query, name) {
-    this.skin = skin;
+  constructor(skin2, query, name) {
+    this.skin = skin2;
     this.query = query;
     this.name = name;
   }
@@ -69298,8 +69325,8 @@ class ProductHandleBuilder {
   }
 }
 class ProductSurfaceBuilder {
-  constructor(skin, side) {
-    this.skin = skin;
+  constructor(skin2, side) {
+    this.skin = skin2;
     this.side = side;
   }
   /** Create a ref on this skin side. */
@@ -69367,9 +69394,9 @@ class ProductRibbonBuilder {
    * ProductSkin.frame(), so the ribbon bends along the selected side as station width/depth changes.
    * All query path points must stay on one side; split side transitions into separate ribbons.
    */
-  on(skin, points, options = {}) {
+  on(skin2, points, options = {}) {
     if (points.length < 2) throw new Error("Product.ribbon().on(skin, points) requires at least two path points");
-    this.skinValue = skin;
+    this.skinValue = skin2;
     this.queryPath = resolvePathQueries(points);
     this.refPath = [];
     return this.applyOptions(options);
@@ -69492,7 +69519,7 @@ class ProductRibbonBuilder {
     const localT = scaled - segment;
     return interpolateQuery(this.queryPath[segment], this.queryPath[segment + 1], localT);
   }
-  buildSkinGrid(skin, path2) {
+  buildSkinGrid(skin2, path2) {
     if (path2.length < 2) throw new Error("Product.ribbon().on(skin, points) must be called before .build()");
     const side = normalizedSide(path2[0].side);
     if (side === "front" || side === "rear") {
@@ -69511,7 +69538,7 @@ class ProductRibbonBuilder {
     for (let i = 0; i < this.samplesValue; i += 1) {
       const along = this.samplesValue === 1 ? 0 : i / (this.samplesValue - 1);
       const center = this.samplePathQuery(along);
-      const station = skin.stationAt(center.v ?? 0.5);
+      const station = skin2.stationAt(center.v ?? 0.5);
       const span = sideSpan(side, station.width, station.depth);
       for (let j = 0; j < this.widthSamplesValue; j += 1) {
         const across = this.widthSamplesValue === 1 ? 0 : j / (this.widthSamplesValue - 1) - 0.5;
@@ -69528,13 +69555,13 @@ class ProductRibbonBuilder {
           u: u2,
           offset: (center.offset ?? 0) + this.offsetValue + this.thicknessValue
         };
-        rows[j].push(skin.frame(query).point);
+        rows[j].push(skin2.frame(query).point);
       }
     }
     return {
       grid: rows,
       diagnostics: this.makeDiagnostics({
-        skin: skin.name,
+        skin: skin2.name,
         side,
         pathPointCount: path2.length,
         clampedUCount,
@@ -69691,16 +69718,16 @@ const Product = {
     return scaleProfileTo(sketch, width, depth);
   },
   /** Create an ad-hoc ProductSurfaceRef from a skin and side/u/v query. */
-  ref(skin, query) {
-    return new ProductSurfaceRef(skin, query);
+  ref(skin2, query) {
+    return new ProductSurfaceRef(skin2, query);
   },
   /**
    * Create a fluent surface helper for refs and conformal features on one side of a skin.
    *
    * Equivalent to skin.surface(side), useful when writing in Product.* namespace style.
    */
-  surface(skin, side) {
-    return skin.surface(side);
+  surface(skin2, side) {
+    return skin2.surface(side);
   },
   /** Start a panel feature builder. */
   panel(name) {
@@ -70169,9 +70196,9 @@ function coordinateOnSide(coordinate, side, label) {
   return { ...coordinate, kind: "productSkin", side };
 }
 class ProductSkinCarrier {
-  constructor(skin, name = skin.name, sideValue2, offsetValue = 0) {
+  constructor(skin2, name = skin2.name, sideValue2, offsetValue = 0) {
     __publicField(this, "kind", "productSkin");
-    this.skin = skin;
+    this.skin = skin2;
     this.name = name;
     this.sideValue = sideValue2;
     this.offsetValue = offsetValue;
@@ -73105,8 +73132,8 @@ const Carrier = {
     return new PlaneCarrier(name);
   },
   /** Adapt an existing ProductSkin into the general surface-member carrier protocol. */
-  productSkin(skin) {
-    return new ProductSkinCarrier(skin);
+  productSkin(skin2) {
+    return new ProductSkinCarrier(skin2);
   },
   /** Reserved stub for future parameterized mesh carriers; arbitrary mesh parameterization is not implemented yet. */
   mesh(name) {
@@ -73174,206 +73201,6 @@ const SurfaceMembers = {
   }
 };
 new TextEncoder();
-let _collectedRobotExport = null;
-function cloneLinkOptions(input) {
-  if (!input) return {};
-  return Object.fromEntries(Object.entries(input).map(([name, opts]) => [name, { ...opts }]));
-}
-function cloneJointOptions(input) {
-  if (!input) return {};
-  return Object.fromEntries(Object.entries(input).map(([name, opts]) => [name, { ...opts }]));
-}
-function cloneDiffDrive(input) {
-  if (!input) return void 0;
-  return {
-    ...input,
-    leftJoints: [...input.leftJoints],
-    rightJoints: [...input.rightJoints]
-  };
-}
-function cloneJointStatePublisher(input) {
-  if (!input) return void 0;
-  return {
-    ...input,
-    joints: input.joints ? [...input.joints] : void 0
-  };
-}
-function cloneWorld(input) {
-  if (!input) return null;
-  return {
-    ...input,
-    spawnPose: input.spawnPose ? [...input.spawnPose] : void 0,
-    keyboardTeleop: input.keyboardTeleop ? { ...input.keyboardTeleop } : void 0
-  };
-}
-function assertFinite(value, label) {
-  if (value !== void 0 && !Number.isFinite(value)) {
-    throw new Error(`${label} must be finite`);
-  }
-}
-function metadataNumber(value) {
-  return typeof value === "number" ? value : void 0;
-}
-function metadataCollision(value) {
-  return value === "none" || value === "visual" || value === "box" || value === "convex" ? value : void 0;
-}
-function colliderCollision(collider2) {
-  if (!collider2) return void 0;
-  if (collider2.mode === "box") return "box";
-  if (collider2.mode === "visual") return "visual";
-  return collider2.mode;
-}
-function velocityDriveEffort(drive) {
-  return (drive == null ? void 0 : drive.kind) === "velocity" ? drive.maxTorqueNm : void 0;
-}
-function velocityDriveVelocityDegS(drive) {
-  return (drive == null ? void 0 : drive.kind) === "velocity" ? drive.maxSpeedRpm * 6 : void 0;
-}
-function driveDamping(drive) {
-  return drive == null ? void 0 : drive.damping;
-}
-function driveFriction(drive) {
-  return drive == null ? void 0 : drive.friction;
-}
-function jointByName(assembly2) {
-  return new Map(assembly2.joints.map((joint2) => [joint2.name, joint2]));
-}
-function diffDriveFromControllers(controllers) {
-  if (!controllers) return void 0;
-  const diffDrives = controllers.filter((controller) => controller.kind === "diffDrive");
-  if (diffDrives.length > 1) {
-    throw new Error("assembly.withSimulation(...) currently supports one Sim.controller.diffDrive(...) controller");
-  }
-  const diffDrive2 = diffDrives[0];
-  return diffDrive2 ? {
-    leftJoints: [...diffDrive2.leftJoints],
-    rightJoints: [...diffDrive2.rightJoints],
-    wheelSeparationMm: diffDrive2.wheelSeparationMm,
-    wheelRadiusMm: diffDrive2.wheelRadiusMm,
-    topic: diffDrive2.topic,
-    odomTopic: diffDrive2.odomTopic,
-    tfTopic: diffDrive2.tfTopic,
-    frameId: diffDrive2.frameId,
-    odomFrameId: diffDrive2.odomFrameId,
-    maxLinearVelocity: diffDrive2.maxLinearVelocity,
-    maxAngularVelocity: diffDrive2.maxAngularVelocity,
-    linearAcceleration: diffDrive2.linearAcceleration,
-    angularAcceleration: diffDrive2.angularAcceleration
-  } : void 0;
-}
-function resetRobotExport() {
-  _collectedRobotExport = null;
-}
-function getCollectedRobotExport() {
-  return _collectedRobotExport;
-}
-function collectSimulationModel(assemblyInput, options = {}) {
-  var _a3, _b3, _c2, _d2, _e2, _f2, _g2, _h2, _i2;
-  const assembly2 = typeof assemblyInput.describe === "function" ? assemblyInput.describe() : assemblyInput;
-  const partNames = new Set(assembly2.parts.map((part) => part.name));
-  const joints = jointByName(assembly2);
-  const links = cloneLinkOptions(options.links);
-  for (const part of assembly2.parts) {
-    const fromSim = part.sim;
-    const fromMaterialDensity = (_a3 = fromSim == null ? void 0 : fromSim.material) == null ? void 0 : _a3.densityKgM3;
-    const current = links[part.name] ?? {};
-    const next = {
-      massKg: current.massKg ?? (fromSim == null ? void 0 : fromSim.massKg) ?? metadataNumber((_b3 = part.metadata) == null ? void 0 : _b3.massKg),
-      densityKgM3: current.densityKgM3 ?? (fromSim == null ? void 0 : fromSim.densityKgM3) ?? fromMaterialDensity ?? metadataNumber((_c2 = part.metadata) == null ? void 0 : _c2.densityKgM3),
-      collision: current.collision ?? colliderCollision(fromSim == null ? void 0 : fromSim.collider) ?? metadataCollision((_d2 = part.metadata) == null ? void 0 : _d2.collision)
-    };
-    if (next.massKg !== void 0 || next.densityKgM3 !== void 0 || next.collision !== void 0) {
-      links[part.name] = next;
-    }
-  }
-  for (const [partName, link] of Object.entries(links)) {
-    if (!partNames.has(partName)) throw new Error(`simulation model references unknown link "${partName}"`);
-    assertFinite(link.massKg, `simulation model link "${partName}" massKg`);
-    assertFinite(link.densityKgM3, `simulation model link "${partName}" densityKgM3`);
-  }
-  const jointOpts = cloneJointOptions(options.joints);
-  for (const joint2 of assembly2.joints) {
-    const drive = (_e2 = joint2.sim) == null ? void 0 : _e2.drive;
-    const current = jointOpts[joint2.name] ?? {};
-    const next = {
-      effort: current.effort ?? velocityDriveEffort(drive) ?? joint2.effort,
-      velocity: current.velocity ?? velocityDriveVelocityDegS(drive) ?? joint2.velocity,
-      damping: current.damping ?? driveDamping(drive) ?? joint2.damping,
-      friction: current.friction ?? driveFriction(drive) ?? joint2.friction
-    };
-    if (next.effort !== void 0 || next.velocity !== void 0 || next.damping !== void 0 || next.friction !== void 0) {
-      jointOpts[joint2.name] = next;
-    }
-  }
-  for (const [jointName, joint2] of Object.entries(jointOpts)) {
-    if (!joints.has(jointName)) throw new Error(`simulation model references unknown joint "${jointName}"`);
-    assertFinite(joint2.effort, `simulation model joint "${jointName}" effort`);
-    assertFinite(joint2.velocity, `simulation model joint "${jointName}" velocity`);
-    assertFinite(joint2.damping, `simulation model joint "${jointName}" damping`);
-    assertFinite(joint2.friction, `simulation model joint "${jointName}" friction`);
-  }
-  const simulation = cloneSimAssemblySimulation(assembly2.sim) ?? null;
-  const simulationDiffDrive = diffDriveFromControllers(simulation == null ? void 0 : simulation.controllers);
-  const diffDrive2 = cloneDiffDrive((_f2 = options.plugins) == null ? void 0 : _f2.diffDrive) ?? simulationDiffDrive;
-  if (diffDrive2) {
-    if (diffDrive2.leftJoints.length === 0 || diffDrive2.rightJoints.length === 0) {
-      throw new Error("simulation model diffDrive requires at least one left joint and one right joint");
-    }
-    assertFinite(diffDrive2.wheelSeparationMm, "simulation model diffDrive wheelSeparationMm");
-    assertFinite(diffDrive2.wheelRadiusMm, "simulation model diffDrive wheelRadiusMm");
-    if (diffDrive2.wheelSeparationMm <= 0 || diffDrive2.wheelRadiusMm <= 0) {
-      throw new Error("simulation model diffDrive wheel separation and radius must be > 0");
-    }
-    [...diffDrive2.leftJoints, ...diffDrive2.rightJoints].forEach((jointName) => {
-      const joint2 = joints.get(jointName);
-      if (!joint2) throw new Error(`simulation model diffDrive references unknown joint "${jointName}"`);
-      if (joint2.type !== "revolute") {
-        throw new Error(`simulation model diffDrive joint "${jointName}" must be revolute`);
-      }
-    });
-  }
-  const jointStatePublisher = cloneJointStatePublisher((_g2 = options.plugins) == null ? void 0 : _g2.jointStatePublisher);
-  if (jointStatePublisher == null ? void 0 : jointStatePublisher.joints) {
-    jointStatePublisher.joints.forEach((jointName) => {
-      if (!joints.has(jointName)) {
-        throw new Error(`simulation model jointStatePublisher references unknown joint "${jointName}"`);
-      }
-    });
-  }
-  const world = cloneWorld(options.world);
-  if (world == null ? void 0 : world.spawnPose) {
-    world.spawnPose.forEach((value, index2) => assertFinite(value, `simulation model world spawnPose[${index2}]`));
-  }
-  assertFinite((_h2 = world == null ? void 0 : world.keyboardTeleop) == null ? void 0 : _h2.linearStep, "simulation model world keyboardTeleop.linearStep");
-  assertFinite((_i2 = world == null ? void 0 : world.keyboardTeleop) == null ? void 0 : _i2.angularStep, "simulation model world keyboardTeleop.angularStep");
-  return {
-    modelName: (options.modelName ?? assembly2.name ?? "ForgeCAD Simulation").trim() || "ForgeCAD Simulation",
-    assembly: assembly2,
-    simulation,
-    source: options.source ?? "assembly",
-    state: { ...options.state ?? {} },
-    static: options.static ?? false,
-    selfCollide: options.selfCollide ?? false,
-    allowAutoDisable: options.allowAutoDisable ?? true,
-    links,
-    joints: jointOpts,
-    plugins: {
-      diffDrive: diffDrive2,
-      jointStatePublisher
-    },
-    world
-  };
-}
-function robotExport(options) {
-  if (!options || typeof options !== "object") {
-    throw new Error("robotExport(...) expects an options object");
-  }
-  if (!options.assembly || typeof options.assembly.describe !== "function") {
-    throw new Error("robotExport(...) requires an assembly");
-  }
-  _collectedRobotExport = collectSimulationModel(options.assembly, { ...options, source: "robotExport" });
-  return _collectedRobotExport;
-}
 class Point2D {
   constructor(x2, y2) {
     this.x = x2;
@@ -95647,6 +95474,847 @@ function sketchOnFace(sketch, parentOrFace, faceOrOpts, maybeOpts = {}) {
 Sketch.prototype.onFace = function(parentOrFace, faceOrOpts, maybeOpts = {}) {
   return sketchOnFace(this, parentOrFace, faceOrOpts, maybeOpts);
 };
+const KNOT_EPS = 1e-10;
+const KNOT_MERGE_EPS = 1e-7;
+function sameKnot(a2, b) {
+  return Math.abs(a2 - b) <= KNOT_EPS;
+}
+function knotMultiplicity(knots, u2) {
+  let count = 0;
+  for (const k2 of knots) if (sameKnot(k2, u2)) count++;
+  return count;
+}
+function computeParamsCentripetal(points, alpha = 0.5) {
+  const n = points.length;
+  const params = new Array(n).fill(0);
+  const seg = new Array(n).fill(0);
+  let total = 0;
+  for (let k2 = 1; k2 < n; k2++) {
+    const dx = points[k2][0] - points[k2 - 1][0];
+    const dy = points[k2][1] - points[k2 - 1][1];
+    const dz = points[k2][2] - points[k2 - 1][2];
+    seg[k2] = Math.hypot(dx, dy, dz) ** alpha;
+    total += seg[k2];
+  }
+  if (total === 0) {
+    for (let k2 = 0; k2 < n; k2++) params[k2] = n > 1 ? k2 / (n - 1) : 0;
+    return params;
+  }
+  let acc = 0;
+  for (let k2 = 1; k2 < n - 1; k2++) {
+    acc += seg[k2];
+    params[k2] = acc / total;
+  }
+  params[n - 1] = 1;
+  return params;
+}
+function knotsFromParamsAveraging(params, degree) {
+  const n = params.length - 1;
+  const m2 = n + degree + 1;
+  const knots = new Array(m2 + 1).fill(0);
+  for (let i = m2 - degree; i <= m2; i++) knots[i] = 1;
+  for (let j = 1; j <= n - degree; j++) {
+    let s = 0;
+    for (let i = j; i <= j + degree - 1; i++) s += params[i];
+    knots[j + degree] = s / degree;
+  }
+  return knots;
+}
+function solveLinear(A, B2) {
+  const n = A.length;
+  const k2 = B2[0].length;
+  const M = A.map((row, i) => [...row, ...B2[i]]);
+  for (let col = 0; col < n; col++) {
+    let piv = col;
+    for (let r = col + 1; r < n; r++) if (Math.abs(M[r][col]) > Math.abs(M[piv][col])) piv = r;
+    if (Math.abs(M[piv][col]) < 1e-14) throw new Error(`Singular interpolation matrix at column ${col}.`);
+    [M[col], M[piv]] = [M[piv], M[col]];
+    const inv = 1 / M[col][col];
+    for (let j = col; j < n + k2; j++) M[col][j] *= inv;
+    for (let r = 0; r < n; r++) {
+      if (r === col) continue;
+      const f3 = M[r][col];
+      if (f3 === 0) continue;
+      for (let j = col; j < n + k2; j++) M[r][j] -= f3 * M[col][j];
+    }
+  }
+  return Array.from({ length: n }, (_2, i) => M[i].slice(n));
+}
+function globalCurveInterp(points, degree, paramsIn) {
+  const last = points.length - 1;
+  if (last < degree) throw new Error(`Curve interpolation needs at least ${degree + 1} points, got ${points.length}.`);
+  const params = paramsIn ? paramsIn.slice() : computeParamsCentripetal(points, 0.5);
+  const knots = knotsFromParamsAveraging(params, degree);
+  const count = last + 1;
+  const N = Array.from({ length: count }, () => new Array(count).fill(0));
+  for (let i = 0; i <= last; i++) {
+    const span = findSpan(count, degree, params[i], knots);
+    const basis = basisFuns(span, params[i], degree, knots);
+    for (let j = 0; j <= degree; j++) N[i][span - degree + j] = basis[j];
+  }
+  const Q = points.map((p2) => [p2[0], p2[1], p2[2]]);
+  const cps = solveLinear(N, Q);
+  return { cps, knots, degree };
+}
+function insertKnotCurve(cps, knots, degree, u2) {
+  const n = cps.length;
+  const span = findSpan(n, degree, u2, knots);
+  const mult = knotMultiplicity(knots, u2);
+  if (mult >= degree) return { cps: cps.slice(), knots: knots.slice() };
+  const newCps = new Array(n + 1);
+  const newKnots = new Array(knots.length + 1);
+  for (let i = 0; i <= span; i++) newKnots[i] = knots[i];
+  newKnots[span + 1] = u2;
+  for (let i = span + 1; i < knots.length; i++) newKnots[i + 1] = knots[i];
+  for (let i = 0; i <= span - degree; i++) newCps[i] = [...cps[i]];
+  for (let i = span - mult; i < n; i++) newCps[i + 1] = [...cps[i]];
+  for (let i = span - degree + 1; i <= span - mult; i++) {
+    const denom = knots[i + degree] - knots[i];
+    const alpha = denom === 0 ? 0 : (u2 - knots[i]) / denom;
+    const a2 = cps[i - 1];
+    const b = cps[i];
+    newCps[i] = [(1 - alpha) * a2[0] + alpha * b[0], (1 - alpha) * a2[1] + alpha * b[1], (1 - alpha) * a2[2] + alpha * b[2]];
+  }
+  return { cps: newCps, knots: newKnots };
+}
+function interiorKnotBuckets(kv, mergeEps = KNOT_MERGE_EPS) {
+  const buckets = [];
+  for (const k2 of kv) {
+    if (k2 <= KNOT_EPS || k2 >= 1 - KNOT_EPS) continue;
+    const b = buckets.find((x2) => Math.abs(x2.value - k2) <= mergeEps);
+    if (b) b.mult++;
+    else buckets.push({ value: k2, mult: 1 });
+  }
+  return buckets;
+}
+function mergeKnotVectors(knotVectors, degree, mergeEps = KNOT_MERGE_EPS) {
+  const merged = [];
+  for (const kv of knotVectors) {
+    for (const { value, mult } of interiorKnotBuckets(kv, mergeEps)) {
+      const b = merged.find((x2) => Math.abs(x2.value - value) <= mergeEps);
+      if (b) b.mult = Math.max(b.mult, mult);
+      else merged.push({ value, mult });
+    }
+  }
+  merged.sort((a2, b) => a2.value - b.value);
+  const out = [];
+  for (let i = 0; i <= degree; i++) out.push(0);
+  for (const { value, mult } of merged) for (let i = 0; i < mult; i++) out.push(value);
+  for (let i = 0; i <= degree; i++) out.push(1);
+  return out;
+}
+function refineKnotsToTarget(cps, knots, degree, targetKnots, mergeEps = KNOT_MERGE_EPS) {
+  let curCps = cps.map((p2) => [...p2]);
+  let curKnots = knots.slice();
+  for (const { value, mult } of interiorKnotBuckets(targetKnots, mergeEps)) {
+    const curMult = () => curKnots.reduce((c2, k2) => c2 + (Math.abs(k2 - value) <= mergeEps ? 1 : 0), 0);
+    let guard = 0;
+    while (curMult() < mult) {
+      const r = insertKnotCurve(curCps, curKnots, degree, value);
+      if (r.cps.length === curCps.length) break;
+      curCps = r.cps;
+      curKnots = r.knots;
+      if (++guard > degree + 2) break;
+    }
+  }
+  return { cps: curCps, knots: curKnots };
+}
+function binomial(a2, b) {
+  if (b < 0 || b > a2) return 0;
+  let r = 1;
+  for (let i = 0; i < b; i++) r = r * (a2 - i) / (i + 1);
+  return r;
+}
+function bezierElevate(bez, p2, t) {
+  const m2 = p2 + t;
+  const out = [];
+  for (let i = 0; i <= m2; i++) {
+    const acc = [0, 0, 0];
+    const lo = Math.max(0, i - t);
+    const hi = Math.min(p2, i);
+    for (let j = lo; j <= hi; j++) {
+      const w2 = binomial(p2, j) * binomial(t, i - j) / binomial(m2, i);
+      acc[0] += w2 * bez[j][0];
+      acc[1] += w2 * bez[j][1];
+      acc[2] += w2 * bez[j][2];
+    }
+    out.push(acc);
+  }
+  return out;
+}
+function elevateCurveDegree(cps, knots, degree, targetDegree) {
+  if (targetDegree === degree) return { cps: cps.map((p2) => [...p2]), knots: knots.slice(), degree };
+  if (targetDegree < degree) throw new Error("Degree reduction is not supported.");
+  const t = targetDegree - degree;
+  let curCps = cps.map((p2) => [...p2]);
+  let curKnots = knots.slice();
+  const breaks = interiorKnotBuckets(curKnots).map((b) => b.value);
+  for (const v of breaks) {
+    let guard = 0;
+    while (knotMultiplicity(curKnots, v) < degree) {
+      const r = insertKnotCurve(curCps, curKnots, degree, v);
+      curCps = r.cps;
+      curKnots = r.knots;
+      if (++guard > degree + 2) break;
+    }
+  }
+  const segVals = [0, ...breaks.slice().sort((a2, b) => a2 - b), 1];
+  const nSeg = segVals.length - 1;
+  const newCps = [];
+  for (let s = 0; s < nSeg; s++) {
+    const bez = curCps.slice(s * degree, s * degree + degree + 1);
+    const elevated = bezierElevate(bez, degree, t);
+    if (s === 0) newCps.push(...elevated);
+    else newCps.push(...elevated.slice(1));
+  }
+  const newKnots = [];
+  for (let i = 0; i <= targetDegree; i++) newKnots.push(0);
+  for (let s = 1; s < nSeg; s++) for (let i = 0; i < targetDegree; i++) newKnots.push(segVals[s]);
+  for (let i = 0; i <= targetDegree; i++) newKnots.push(1);
+  if (newKnots.length !== newCps.length + targetDegree + 1) {
+    throw new Error(
+      `Degree elevation produced inconsistent knots (${newKnots.length}) for ${newCps.length} control points at degree ${targetDegree}.`
+    );
+  }
+  return { cps: newCps, knots: newKnots, degree: targetDegree };
+}
+function unifyCurves(curves) {
+  const targetDeg = Math.max(...curves.map((c2) => c2.degree));
+  const elevated = curves.map((c2) => elevateCurveDegree(c2.cps, c2.knots, c2.degree, targetDeg));
+  const common = mergeKnotVectors(
+    elevated.map((c2) => c2.knots),
+    targetDeg
+  );
+  const refined = elevated.map((c2) => refineKnotsToTarget(c2.cps, c2.knots, targetDeg, common));
+  const ncp = common.length - targetDeg - 1;
+  for (const r of refined) {
+    if (r.cps.length !== ncp) throw new Error(`Curve unification produced ${r.cps.length} control points, expected ${ncp}.`);
+  }
+  return { degree: targetDeg, knots: common, curves: refined.map((r) => r.cps) };
+}
+function transpose(g2) {
+  const out = [];
+  for (let j = 0; j < g2[0].length; j++) {
+    const row = [];
+    for (let i = 0; i < g2.length; i++) row.push(g2[i][j]);
+    out.push(row);
+  }
+  return out;
+}
+function skin(curveCps, spanParams, spanDegree) {
+  const ncp = curveCps[0].length;
+  const cols = [];
+  for (let j = 0; j < ncp; j++) {
+    const pts = curveCps.map((row) => row[j]);
+    cols.push(globalCurveInterp(pts, spanDegree, spanParams).cps);
+  }
+  const spanCp = cols[0].length;
+  const grid = [];
+  for (let s = 0; s < spanCp; s++) {
+    const row = [];
+    for (let j = 0; j < ncp; j++) row.push(cols[j][s]);
+    grid.push(row);
+  }
+  const spanKnots = knotsFromParamsAveraging(spanParams, spanDegree);
+  return { grid, spanKnots };
+}
+function tensorInterp(gridPts, uParams, vParams, degreeU, degreeV) {
+  const rowInterp = gridPts.map((rowPts) => globalCurveInterp(rowPts, degreeV, vParams));
+  const knotsV = rowInterp[0].knots;
+  const ncpV = rowInterp[0].cps.length;
+  const cols = [];
+  for (let j = 0; j < ncpV; j++) {
+    const pts = rowInterp.map((ri) => ri.cps[j]);
+    cols.push(globalCurveInterp(pts, degreeU, uParams));
+  }
+  const knotsU = cols[0].knots;
+  const cpU = cols[0].cps.length;
+  const grid = [];
+  for (let i = 0; i < cpU; i++) {
+    const row = [];
+    for (let j = 0; j < ncpV; j++) row.push(cols[j].cps[i]);
+    grid.push(row);
+  }
+  return { grid, knotsU, knotsV };
+}
+function refineSurface(surf, targetKnotsU, targetKnotsV) {
+  const { grid, knotsU, knotsV, degreeU, degreeV } = surf;
+  const rows = grid.map((row) => refineKnotsToTarget(row, knotsV, degreeV, targetKnotsV).cps);
+  const ncpV = rows[0].length;
+  const cols = [];
+  for (let j = 0; j < ncpV; j++) {
+    const colPts = rows.map((r) => r[j]);
+    cols.push(refineKnotsToTarget(colPts, knotsU, degreeU, targetKnotsU).cps);
+  }
+  const cpU = cols[0].length;
+  const out = [];
+  for (let i = 0; i < cpU; i++) {
+    const row = [];
+    for (let j = 0; j < ncpV; j++) row.push(cols[j][i]);
+    out.push(row);
+  }
+  return { grid: out, knotsU: targetKnotsU, knotsV: targetKnotsV, degreeU, degreeV };
+}
+function averageParams(polylines, alpha = 0.5) {
+  const count = polylines[0].length;
+  const acc = new Array(count).fill(0);
+  for (const pl of polylines) {
+    const p2 = computeParamsCentripetal(pl, alpha);
+    for (let i = 0; i < count; i++) acc[i] += p2[i];
+  }
+  return acc.map((s) => s / polylines.length);
+}
+function gordonGridParams(gridPts) {
+  const rows = gridPts;
+  const cols = gridPts[0].map((_2, l) => gridPts.map((r) => r[l]));
+  return { vParams: averageParams(rows, 0.5), uParams: averageParams(cols, 0.5) };
+}
+function buildGordonFromGrid(gridPts, degreeU = 3, degreeV = 3) {
+  const m2 = gridPts.length - 1;
+  const n = gridPts[0].length - 1;
+  if (m2 < 1 || n < 1) throw new Error("A Gordon surface needs at least a 2x2 curve network.");
+  if (m2 < degreeU) degreeU = m2;
+  if (n < degreeV) degreeV = n;
+  const rows = gridPts;
+  const cols = gridPts[0].map((_2, l) => gridPts.map((r) => r[l]));
+  const { uParams, vParams } = gordonGridParams(gridPts);
+  const uCurves = rows.map((rowPts) => globalCurveInterp(rowPts, degreeV, vParams));
+  const vCurves = cols.map((colPts) => globalCurveInterp(colPts, degreeU, uParams));
+  const uFam = unifyCurves(uCurves);
+  const vFam = unifyCurves(vCurves);
+  const Lu = skin(uFam.curves, uParams, degreeU);
+  const LvRaw = skin(vFam.curves, vParams, degreeV);
+  const Lv = { grid: transpose(LvRaw.grid), knotsU: vFam.knots, knotsV: LvRaw.spanKnots };
+  const T = tensorInterp(gridPts, uParams, vParams, degreeU, degreeV);
+  const knotsU = mergeKnotVectors([Lu.spanKnots, Lv.knotsU, T.knotsU], degreeU);
+  const knotsV = mergeKnotVectors([uFam.knots, Lv.knotsV, T.knotsV], degreeV);
+  const LuS = refineSurface({ grid: Lu.grid, knotsU: Lu.spanKnots, knotsV: uFam.knots, degreeU, degreeV }, knotsU, knotsV);
+  const LvS = refineSurface({ grid: Lv.grid, knotsU: Lv.knotsU, knotsV: Lv.knotsV, degreeU, degreeV }, knotsU, knotsV);
+  const TS = refineSurface({ grid: T.grid, knotsU: T.knotsU, knotsV: T.knotsV, degreeU, degreeV }, knotsU, knotsV);
+  const nuc = LuS.grid.length;
+  const nvc = LuS.grid[0].length;
+  if (LvS.grid.length !== nuc || TS.grid.length !== nuc || LvS.grid[0].length !== nvc || TS.grid[0].length !== nvc) {
+    throw new Error(
+      `Gordon blend grid mismatch: Lu ${nuc}x${nvc}, Lv ${LvS.grid.length}x${LvS.grid[0].length}, T ${TS.grid.length}x${TS.grid[0].length}.`
+    );
+  }
+  const grid = [];
+  for (let i = 0; i < nuc; i++) {
+    const row = [];
+    for (let j = 0; j < nvc; j++) {
+      const a2 = LuS.grid[i][j];
+      const b = LvS.grid[i][j];
+      const c2 = TS.grid[i][j];
+      row.push([a2[0] + b[0] - c2[0], a2[1] + b[1] - c2[1], a2[2] + b[2] - c2[2]]);
+    }
+    grid.push(row);
+  }
+  return { grid, knotsU, knotsV, degreeU, degreeV };
+}
+function evalSurface(surf, u2, v) {
+  const { grid, knotsU, knotsV, degreeU, degreeV } = surf;
+  const nu = grid.length;
+  const nv = grid[0].length;
+  const su = findSpan(nu, degreeU, u2, knotsU);
+  const sv = findSpan(nv, degreeV, v, knotsV);
+  const Nu = basisFuns(su, u2, degreeU, knotsU);
+  const Nv = basisFuns(sv, v, degreeV, knotsV);
+  const out = [0, 0, 0];
+  for (let i = 0; i <= degreeU; i++) {
+    const ui = su - degreeU + i;
+    for (let j = 0; j <= degreeV; j++) {
+      const vj = sv - degreeV + j;
+      const w2 = Nu[i] * Nv[j];
+      const p2 = grid[ui][vj];
+      out[0] += w2 * p2[0];
+      out[1] += w2 * p2[1];
+      out[2] += w2 * p2[2];
+    }
+  }
+  return out;
+}
+function evalSurfaceJet(surf, u2, v) {
+  const { grid, knotsU, knotsV, degreeU, degreeV } = surf;
+  const nu = grid.length;
+  const nv = grid[0].length;
+  const su = findSpan(nu, degreeU, u2, knotsU);
+  const sv = findSpan(nv, degreeV, v, knotsV);
+  const dU = basisFunsDeriv(su, u2, degreeU, knotsU, 2);
+  const dV = basisFunsDeriv(sv, v, degreeV, knotsV, 2);
+  const S = [0, 0, 0];
+  const Su = [0, 0, 0];
+  const Sv = [0, 0, 0];
+  const Suu = [0, 0, 0];
+  const Suv = [0, 0, 0];
+  const Svv = [0, 0, 0];
+  for (let i = 0; i <= degreeU; i++) {
+    const ui = su - degreeU + i;
+    for (let j = 0; j <= degreeV; j++) {
+      const vj = sv - degreeV + j;
+      const p2 = grid[ui][vj];
+      const w00 = dU[0][i] * dV[0][j];
+      const w10 = dU[1][i] * dV[0][j];
+      const w01 = dU[0][i] * dV[1][j];
+      const w20 = dU[2][i] * dV[0][j];
+      const w11 = dU[1][i] * dV[1][j];
+      const w02 = dU[0][i] * dV[2][j];
+      for (let c2 = 0; c2 < 3; c2++) {
+        S[c2] += w00 * p2[c2];
+        Su[c2] += w10 * p2[c2];
+        Sv[c2] += w01 * p2[c2];
+        Suu[c2] += w20 * p2[c2];
+        Suv[c2] += w11 * p2[c2];
+        Svv[c2] += w02 * p2[c2];
+      }
+    }
+  }
+  let nx = Su[1] * Sv[2] - Su[2] * Sv[1];
+  let ny = Su[2] * Sv[0] - Su[0] * Sv[2];
+  let nz = Su[0] * Sv[1] - Su[1] * Sv[0];
+  const len2 = Math.hypot(nx, ny, nz) || 1;
+  nx /= len2;
+  ny /= len2;
+  nz /= len2;
+  return { S, Su, Sv, Suu, Suv, Svv, normal: [nx, ny, nz] };
+}
+function surfaceCurvature(jet) {
+  const { Su, Sv, Suu, Suv, Svv, normal: normal2 } = jet;
+  const E = Su[0] * Su[0] + Su[1] * Su[1] + Su[2] * Su[2];
+  const F = Su[0] * Sv[0] + Su[1] * Sv[1] + Su[2] * Sv[2];
+  const G = Sv[0] * Sv[0] + Sv[1] * Sv[1] + Sv[2] * Sv[2];
+  const e = Suu[0] * normal2[0] + Suu[1] * normal2[1] + Suu[2] * normal2[2];
+  const f3 = Suv[0] * normal2[0] + Suv[1] * normal2[1] + Suv[2] * normal2[2];
+  const g2 = Svv[0] * normal2[0] + Svv[1] * normal2[1] + Svv[2] * normal2[2];
+  const denom = E * G - F * F;
+  if (Math.abs(denom) < 1e-20) return { k1: 0, k2: 0, K: 0, H: 0 };
+  const K = (e * g2 - f3 * f3) / denom;
+  const H = (e * G - 2 * f3 * F + g2 * E) / (2 * denom);
+  const disc = Math.max(0, H * H - K);
+  const root = Math.sqrt(disc);
+  return { k1: H + root, k2: H - root, K, H };
+}
+function isVec3(v) {
+  return Array.isArray(v) && v.length === 3 && typeof v[0] === "number" && typeof v[1] === "number" && typeof v[2] === "number";
+}
+function requireFiniteVec(p2, label) {
+  for (let i = 0; i < 3; i++)
+    if (!Number.isFinite(p2[i])) throw new Error(`Surface.Net: ${label} component ${i} must be finite, got ${p2[i]}`);
+  return [p2[0], p2[1], p2[2]];
+}
+function toSampler(input, label) {
+  if (input instanceof NurbsCurve3D) {
+    return (t) => input.pointAt(t);
+  }
+  if (Array.isArray(input) && input.length > 0 && isVec3(input[0])) {
+    const pts = input.map((p2, i) => requireFiniteVec(p2, `${label}[${i}]`));
+    if (pts.length < 2) throw new Error(`Surface.Net: ${label} needs at least 2 points.`);
+    if (pts.length === 2) {
+      const [a2, b] = pts;
+      return (t) => [a2[0] + (b[0] - a2[0]) * t, a2[1] + (b[1] - a2[1]) * t, a2[2] + (b[2] - a2[2]) * t];
+    }
+    const curve = globalCurveInterp(pts, Math.min(3, pts.length - 1));
+    const nc = new NurbsCurve3D(curve.cps, { degree: curve.degree, knots: curve.knots });
+    return (t) => nc.pointAt(t);
+  }
+  throw new Error(`Surface.Net: ${label} must be a Curve.Fit/Curve.Nurbs value or an array of [x,y,z] points.`);
+}
+function sampleCurve(sampler, count) {
+  const out = [];
+  for (let i = 0; i < count; i++) out.push(sampler(i / (count - 1)));
+  return out;
+}
+const DEFAULT_THICKEN_RESOLUTION = 48;
+class Sheet {
+  constructor(surface) {
+    this.surface = surface;
+  }
+  /** Edge naming follows parameter direction (documented): front=v0, rear=v1, left=u0, right=u1. */
+  get frontEdge() {
+    return { sheet: this, fixed: "v", value: 0 };
+  }
+  get rearEdge() {
+    return { sheet: this, fixed: "v", value: 1 };
+  }
+  get leftEdge() {
+    return { sheet: this, fixed: "u", value: 0 };
+  }
+  get rightEdge() {
+    return { sheet: this, fixed: "u", value: 1 };
+  }
+  pointAt(u2, v) {
+    return evalSurface(this.surface, clamp01(u2), clamp01(v));
+  }
+  normalAt(u2, v) {
+    return evalSurfaceJet(this.surface, clamp01(u2), clamp01(v)).normal;
+  }
+  curvatureAt(u2, v) {
+    return surfaceCurvature(evalSurfaceJet(this.surface, clamp01(u2), clamp01(v)));
+  }
+  /** Largest principal curvature magnitude over a sampling grid (for offset safety). */
+  maxAbsPrincipalCurvature(samples = 9) {
+    let maxK = 0;
+    for (let i = 0; i <= samples; i++) {
+      for (let j = 0; j <= samples; j++) {
+        const c2 = this.curvatureAt(i / samples, j / samples);
+        maxK = Math.max(maxK, Math.abs(c2.k1), Math.abs(c2.k2));
+      }
+    }
+    return maxK;
+  }
+  /**
+   * Offset the sheet along its analytic normals into a watertight solid shell of
+   * the given wall thickness. Throws if the wall would self-intersect on a
+   * concave region (no silent degenerate solid).
+   */
+  thicken(wall, options = {}) {
+    if (!Number.isFinite(wall) || wall <= 0) throw new Error(`Sheet.thicken: wall must be a positive finite number, got ${wall}`);
+    const maxK = this.maxAbsPrincipalCurvature();
+    if (wall * maxK >= 1) {
+      throw new Error(
+        `Sheet.thicken: wall ${wall} exceeds the minimum radius of curvature (1/${maxK.toFixed(4)} = ${(1 / maxK).toFixed(3)}). The offset surface would self-intersect. Reduce the wall thickness or relax the curvature.`
+      );
+    }
+    const resolution = options.resolution ?? DEFAULT_THICKEN_RESOLUTION;
+    return nurbsSurface(this.surface.grid, {
+      degreeU: this.surface.degreeU,
+      degreeV: this.surface.degreeV,
+      knotsU: this.surface.knotsU,
+      knotsV: this.surface.knotsV,
+      thickness: wall,
+      resolution
+    });
+  }
+  /** Per-edge continuity match against a neighbor (returns a NEW Sheet). */
+  matchEdge(edge) {
+    if (edge.sheet !== this) throw new Error("Sheet.matchEdge: the edge must belong to this sheet.");
+    return new MatchEdgeBuilder(this, edge);
+  }
+}
+function clamp01(t) {
+  return t < 0 ? 0 : t > 1 ? 1 : t;
+}
+class CurveNetBuilder {
+  constructor() {
+    __publicField(this, "lengthwiseCurves", []);
+    __publicField(this, "crosswiseCurves", []);
+    __publicField(this, "railCurves", []);
+    __publicField(this, "cageGrid", null);
+    __publicField(this, "degU");
+    __publicField(this, "degV");
+    __publicField(this, "built", null);
+  }
+  lengthwise(...curves) {
+    this.lengthwiseCurves = curves;
+    this.built = null;
+    return this;
+  }
+  crosswise(...curves) {
+    this.crosswiseCurves = curves;
+    this.built = null;
+    return this;
+  }
+  alongRails(railA, railB) {
+    this.railCurves = [railA, railB];
+    this.built = null;
+    return this;
+  }
+  sections(...curves) {
+    this.crosswiseCurves = curves;
+    this.built = null;
+    return this;
+  }
+  cage(grid) {
+    if (!Array.isArray(grid) || grid.length < 2 || !Array.isArray(grid[0]) || grid[0].length < 2) {
+      throw new Error("Surface.Net().cage: grid must be at least a 2x2 array of [x,y,z] points.");
+    }
+    const cols = grid[0].length;
+    this.cageGrid = grid.map((row, k2) => {
+      if (row.length !== cols) throw new Error(`Surface.Net().cage: row ${k2} has ${row.length} points, expected ${cols}.`);
+      return row.map((p2, l) => requireFiniteVec(p2, `cage[${k2}][${l}]`));
+    });
+    this.built = null;
+    return this;
+  }
+  degree(u2, v) {
+    if (!Number.isInteger(u2) || u2 < 1) throw new Error(`Surface.Net().degree: degree must be a positive integer, got ${u2}`);
+    this.degU = u2;
+    this.degV = v === void 0 ? u2 : v;
+    if (v !== void 0 && (!Number.isInteger(v) || v < 1))
+      throw new Error(`Surface.Net().degree: degree must be a positive integer, got ${v}`);
+    this.built = null;
+    return this;
+  }
+  /** Build (once) and return the Sheet. */
+  toSheet() {
+    if (this.built) return this.built;
+    const grid = this.buildGrid();
+    const m2 = grid.length - 1;
+    const n = grid[0].length - 1;
+    const degreeU = Math.max(1, Math.min(this.degU ?? 3, m2));
+    const degreeV = Math.max(1, Math.min(this.degV ?? 3, n));
+    const surface = buildGordonFromGrid(grid, degreeU, degreeV);
+    this.built = new Sheet(surface);
+    return this.built;
+  }
+  buildGrid() {
+    if (this.cageGrid) return this.cageGrid;
+    const lengthwise = this.railCurves.length > 0 ? this.railCurves : this.lengthwiseCurves;
+    const crosswise = this.crosswiseCurves;
+    const SAMPLES = 17;
+    if (lengthwise.length >= 2) {
+      const samplers = lengthwise.map((c2, l) => toSampler(c2, `lengthwise[${l}]`));
+      const grid = [];
+      for (let i = 0; i < SAMPLES; i++) {
+        const u2 = i / (SAMPLES - 1);
+        grid.push(samplers.map((s) => s(u2)));
+      }
+      return grid;
+    }
+    if (crosswise.length >= 2) {
+      const samplers = crosswise.map((c2, k2) => toSampler(c2, `crosswise[${k2}]`));
+      const grid = [];
+      for (const s of samplers) grid.push(sampleCurve(s, SAMPLES));
+      return grid;
+    }
+    throw new Error(
+      "Surface.Net: provide a .cage(grid), or a family of at least 2 curves via .lengthwise(...) / .crosswise(...) / .alongRails(a,b).sections(...). Intersecting two independent hand-drawn families is not available yet — supply the denser family or a cage."
+    );
+  }
+  // ── Sheet delegation (build on first access) ──────────────────────────────
+  get frontEdge() {
+    return this.toSheet().frontEdge;
+  }
+  get rearEdge() {
+    return this.toSheet().rearEdge;
+  }
+  get leftEdge() {
+    return this.toSheet().leftEdge;
+  }
+  get rightEdge() {
+    return this.toSheet().rightEdge;
+  }
+  get surface() {
+    return this.toSheet().surface;
+  }
+  pointAt(u2, v) {
+    return this.toSheet().pointAt(u2, v);
+  }
+  normalAt(u2, v) {
+    return this.toSheet().normalAt(u2, v);
+  }
+  curvatureAt(u2, v) {
+    return this.toSheet().curvatureAt(u2, v);
+  }
+  thicken(wall, options) {
+    return this.toSheet().thicken(wall, options);
+  }
+  matchEdge(edge) {
+    return this.toSheet().matchEdge(edge);
+  }
+}
+function createCurveNet() {
+  return new CurveNetBuilder();
+}
+class MatchEdgeBuilder {
+  constructor(sheet, edge) {
+    this.sheet = sheet;
+    this.edge = edge;
+  }
+  toG0(neighbor) {
+    return applyEdgeMatch(this.sheet, this.edge, neighbor, 0);
+  }
+  toG1(neighbor) {
+    return applyEdgeMatch(this.sheet, this.edge, neighbor, 1);
+  }
+  toG2(neighbor) {
+    return applyEdgeMatch(this.sheet, this.edge, neighbor, 2);
+  }
+}
+function boundaryRows(surf, fixed, value, depth) {
+  const rows = [];
+  if (fixed === "u") {
+    const nU = surf.grid.length;
+    for (let d2 = 0; d2 <= depth; d2++) {
+      const i = value === 0 ? d2 : nU - 1 - d2;
+      rows.push(surf.grid[i].map((p2) => [p2[0], p2[1], p2[2]]));
+    }
+  } else {
+    const nV = surf.grid[0].length;
+    for (let d2 = 0; d2 <= depth; d2++) {
+      const j = value === 0 ? d2 : nV - 1 - d2;
+      rows.push(surf.grid.map((p2) => [p2[j][0], p2[j][1], p2[j][2]]));
+    }
+  }
+  return rows;
+}
+function setBoundaryRow(surf, fixed, value, depth, row) {
+  if (fixed === "u") {
+    const nU = surf.grid.length;
+    const i = value === 0 ? depth : nU - 1 - depth;
+    for (let l = 0; l < surf.grid[i].length; l++) surf.grid[i][l] = [row[l][0], row[l][1], row[l][2]];
+  } else {
+    const nV = surf.grid[0].length;
+    const j = value === 0 ? depth : nV - 1 - depth;
+    for (let k2 = 0; k2 < surf.grid.length; k2++) surf.grid[k2][j] = [row[k2][0], row[k2][1], row[k2][2]];
+  }
+}
+function cloneSurface(surf) {
+  return {
+    grid: surf.grid.map((row) => row.map((p2) => [p2[0], p2[1], p2[2]])),
+    knotsU: [...surf.knotsU],
+    knotsV: [...surf.knotsV],
+    degreeU: surf.degreeU,
+    degreeV: surf.degreeV
+  };
+}
+function applyEdgeMatch(sheet, edge, neighbor, order) {
+  const result = cloneSurface(sheet.surface);
+  const my = boundaryRows(result, edge.fixed, edge.value, order);
+  const their = boundaryRows(neighbor.sheet.surface, neighbor.fixed, neighbor.value, order);
+  if (my[0].length !== their[0].length) {
+    throw new Error(
+      `Sheet.matchEdge: edge control-point counts differ (${my[0].length} vs ${their[0].length}). Both sheets must share section sampling along the matched edge for continuity.`
+    );
+  }
+  const len2 = my[0].length;
+  const b0 = their[0].map((p2) => [p2[0], p2[1], p2[2]]);
+  setBoundaryRow(result, edge.fixed, edge.value, 0, b0);
+  if (order === 0) return new Sheet(result);
+  const b1 = [];
+  for (let i = 0; i < len2; i++) {
+    const p0 = their[0][i];
+    const p1 = their[1][i];
+    b1.push([2 * p0[0] - p1[0], 2 * p0[1] - p1[1], 2 * p0[2] - p1[2]]);
+  }
+  setBoundaryRow(result, edge.fixed, edge.value, 1, b1);
+  if (order === 1) return new Sheet(result);
+  const b22 = [];
+  for (let i = 0; i < len2; i++) {
+    const p0 = their[0][i];
+    const p1 = their[1][i];
+    const p2 = their[2][i];
+    b22.push([3 * p0[0] - 3 * p1[0] + p2[0], 3 * p0[1] - 3 * p1[1] + p2[1], 3 * p0[2] - 3 * p1[2] + p2[2]]);
+  }
+  setBoundaryRow(result, edge.fixed, edge.value, 2, b22);
+  return new Sheet(result);
+}
+function edgeJet(edge, t) {
+  const surf = edge.sheet.surface;
+  if (edge.fixed === "u") {
+    const j2 = evalSurfaceJet(surf, edge.value, clamp01(t));
+    return { point: j2.S, cross: j2.Su, cross2: j2.Suu };
+  }
+  const j = evalSurfaceJet(surf, clamp01(t), edge.value);
+  return { point: j.S, cross: j.Sv, cross2: j.Svv };
+}
+function sub3(a2, b) {
+  return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
+}
+function len3(a2) {
+  return Math.hypot(a2[0], a2[1], a2[2]);
+}
+function unit3(a2) {
+  const l = len3(a2) || 1;
+  return [a2[0] / l, a2[1] / l, a2[2] / l];
+}
+function edgeMatchReport(edgeA, edgeB, samples = 24) {
+  let maxPositionGap = 0;
+  let maxTangentAngleDeg = 0;
+  let maxCurvatureRelErr = 0;
+  for (let i = 0; i <= samples; i++) {
+    const t = i / samples;
+    const a2 = edgeJet(edgeA, t);
+    const b = edgeJet(edgeB, t);
+    maxPositionGap = Math.max(maxPositionGap, len3(sub3(a2.point, b.point)));
+    const ua = unit3(a2.cross);
+    const ub = unit3(b.cross);
+    const dot2 = Math.max(-1, Math.min(1, ua[0] * ub[0] + ua[1] * ub[1] + ua[2] * ub[2]));
+    const angle = Math.acos(Math.abs(dot2)) * 180 / Math.PI;
+    maxTangentAngleDeg = Math.max(maxTangentAngleDeg, angle);
+    const la = len3(a2.cross) ** 2 || 1;
+    const lb = len3(b.cross) ** 2 || 1;
+    const ka = (a2.cross2[0] * ua[0] + a2.cross2[1] * ua[1] + a2.cross2[2] * ua[2]) / la;
+    const kb = (b.cross2[0] * ub[0] + b.cross2[1] * ub[1] + b.cross2[2] * ub[2]) / lb;
+    maxCurvatureRelErr = Math.max(maxCurvatureRelErr, Math.abs(ka - kb) / (Math.abs(ka) + Math.abs(kb) + 1e-9));
+  }
+  return { maxPositionGap, maxTangentAngleDeg, maxCurvatureRelErr };
+}
+function bridgeBetween(edgeA, edgeB) {
+  return new BridgeBuilder(edgeA, edgeB);
+}
+class BridgeBuilder {
+  constructor(edgeA, edgeB) {
+    __publicField(this, "bulgeA", 0.5);
+    __publicField(this, "bulgeB", 0.5);
+    this.edgeA = edgeA;
+    this.edgeB = edgeB;
+  }
+  /** Tune the influence of each side (Rhino-style bulge). */
+  bulge(a2, b) {
+    if (!Number.isFinite(a2) || !Number.isFinite(b)) throw new Error("Surfaces.bridge.bulge: both factors must be finite.");
+    this.bulgeA = a2;
+    this.bulgeB = b;
+    return this;
+  }
+  g0() {
+    return this.build(0);
+  }
+  g1() {
+    return this.build(1);
+  }
+  g2() {
+    return this.build(2);
+  }
+  build(order) {
+    const SAMPLES = 21;
+    const CROSS = 11;
+    const cage = [];
+    for (let i = 0; i < SAMPLES; i++) {
+      const t = i / (SAMPLES - 1);
+      const a2 = edgeJet(this.edgeA, t);
+      const b = edgeJet(this.edgeB, t);
+      const chord = len3(sub3(b.point, a2.point));
+      const toward = unit3(sub3(b.point, a2.point));
+      const tA = orientToward(unit3(a2.cross), toward);
+      const tB = orientToward(unit3(b.cross), [-toward[0], -toward[1], -toward[2]]);
+      const poles = bridgePoles(a2.point, b.point, tA, tB, chord, this.bulgeA, this.bulgeB, order);
+      const row = [];
+      for (let c2 = 0; c2 < CROSS; c2++) row.push(deCasteljau(poles, c2 / (CROSS - 1)));
+      cage.push(row);
+    }
+    return new CurveNetBuilder().cage(cage).degree(Math.min(3, SAMPLES - 1), Math.min(2 * order + 1 || 1, CROSS - 1)).toSheet();
+  }
+}
+function orientToward(v, toward) {
+  const dot2 = v[0] * toward[0] + v[1] * toward[1] + v[2] * toward[2];
+  return dot2 < 0 ? [-v[0], -v[1], -v[2]] : v;
+}
+function bridgePoles(a2, b, tA, tB, chord, bulgeA, bulgeB, order) {
+  if (order === 0) return [a2, b];
+  const dA = chord * bulgeA / (order === 1 ? 3 : 5);
+  const dB = chord * bulgeB / (order === 1 ? 3 : 5);
+  const a1 = [a2[0] + tA[0] * dA, a2[1] + tA[1] * dA, a2[2] + tA[2] * dA];
+  const b1 = [b[0] + tB[0] * dB, b[1] + tB[1] * dB, b[2] + tB[2] * dB];
+  if (order === 1) return [a2, a1, b1, b];
+  const a22 = [a1[0] + tA[0] * dA, a1[1] + tA[1] * dA, a1[2] + tA[2] * dA];
+  const b22 = [b1[0] + tB[0] * dB, b1[1] + tB[1] * dB, b1[2] + tB[2] * dB];
+  return [a2, a1, a22, b22, b1, b];
+}
+function deCasteljau(poles, s) {
+  let pts = poles.map((p2) => [p2[0], p2[1], p2[2]]);
+  while (pts.length > 1) {
+    const next = [];
+    for (let i = 0; i < pts.length - 1; i++) {
+      next.push([
+        pts[i][0] + (pts[i + 1][0] - pts[i][0]) * s,
+        pts[i][1] + (pts[i + 1][1] - pts[i][1]) * s,
+        pts[i][2] + (pts[i + 1][2] - pts[i][2]) * s
+      ]);
+    }
+    pts = next;
+  }
+  return pts[0];
+}
 const CORNER_Y_ALPHA_ISSUE_URL = "https://github.com/KoStard/forgecad-private/issues/162";
 function isVec3Array(value) {
   return Array.isArray(value) && (value.length === 0 || Array.isArray(value[0]));
@@ -97038,7 +97706,16 @@ const Surface = {
     "Surface.MatchEdge",
     "Surface.Match()",
     (shape, options) => Surface.Match(shape, options)
-  )
+  ),
+  /**
+   * Begin a curve-network (Gordon) surface — the class-A keystone. Chain
+   * `.lengthwise(...)/.crosswise(...)` (or `.alongRails(a,b).sections(...)`, or
+   * `.cage(grid)`), then `.thicken(wall)` to get a solid Shape. Returns a fluent
+   * `Sheet` builder with analytic point/normal/curvature queries and named edges.
+   */
+  Net() {
+    return createCurveNet();
+  }
 };
 const Blend = {
   Edge(options) {
@@ -97058,6 +97735,14 @@ const Blend = {
   Surface(options) {
     return Surface.Fill(options);
   },
+  /**
+   * Build a transition strip between two `Surface.Net` sheet edges. Chain
+   * `.bulge(a, b)` then `.g0()/.g1()/.g2()` for the continuity order. Returns a
+   * `Sheet`; verify the seam with `Analysis.EdgeMatch`.
+   */
+  Bridge(edgeA, edgeB) {
+    return bridgeBetween(edgeA, edgeB);
+  },
   /**
    * @alpha
    * Current implementation uses continuity-controlled edge fillets on solid edges.
@@ -97092,6 +97777,14 @@ const Analysis = {
   SurfaceContinuity(shape, options = {}) {
     return evaluateEdgeContinuityReport(shape, options, "Analysis.SurfaceContinuity()");
   },
+  /**
+   * Measure G0/G1/G2 agreement between two `Surface.Net` sheet edges: worst
+   * position gap, cross-boundary tangent angle (0 = G1), and normal-curvature
+   * mismatch (0 = G2). The reflection/fairness check for matched panel seams.
+   */
+  EdgeMatch(edgeA, edgeB, options = {}) {
+    return edgeMatchReport(edgeA, edgeB, options.samples);
+  },
   CurvatureComb(input, options = {}) {
     if (input instanceof NurbsCurve3D) {
       const count = Math.max(8, options.samples ?? 32);
@@ -100544,22 +101237,10 @@ function roundNum(n, digits = 4) {
   return Number.isFinite(n) ? n.toFixed(digits).replace(/\.?0+$/, "") : String(n);
 }
 const COLLISION_OVERLAP_VOLUME_TOLERANCE = 1e-6;
-function meshDerivedManifoldBackend(shape) {
-  const mesh = getShapeRuntimeBackend(shape).getMesh();
-  return reconstructBackendFromMesh({
-    numProp: mesh.numProp,
-    triVerts: mesh.triVerts,
-    vertProperties: mesh.vertProperties,
-    mergeFromVert: mesh.mergeFromVert ?? new Uint32Array(),
-    mergeToVert: mesh.mergeToVert ?? new Uint32Array()
-  });
-}
 function backendForMinGap(shape) {
   const backend = getShapeRuntimeBackend(shape);
   if (isManifoldCapableBackend(backend)) return { kind: "manifold", backend, method: "exact", dispose: false };
-  if (isSdfCapableBackend(backend) || getActiveBackend() === "sdf")
-    return { kind: "mesh", backend, method: "mesh-derived", dispose: false };
-  return { kind: "manifold", backend: meshDerivedManifoldBackend(shape), method: "mesh-derived", dispose: true };
+  return { kind: "mesh", backend, method: "mesh-derived", dispose: false };
 }
 function meshHasPointInsideSdf(source, target) {
   const mesh = source.getMesh();
@@ -101732,7 +102413,6 @@ function resetExecutionSession(logs) {
   resetHighlights();
   resetBom();
   resetSheetStock();
-  resetRobotExport();
   resetCutPlanes();
   resetRenderLabels();
   resetCameraTrajectory();
@@ -101815,7 +102495,6 @@ function collectSuccessfulExecutionSnapshot(args) {
     jointsView: getCollectedJointsView(),
     viewConfig: getCollectedViewConfig(),
     sceneConfig: getCollectedScene(),
-    robotExport: getCollectedRobotExport(),
     quality: args.quality,
     logs: args.logs.slice(),
     verifications: getCollectedVerifications(),
@@ -101840,7 +102519,6 @@ function collectFailedExecutionSnapshot(args) {
     jointsView: getCollectedJointsView(),
     viewConfig: getCollectedViewConfig(),
     sceneConfig: getCollectedScene(),
-    robotExport: getCollectedRobotExport(),
     quality: args.quality,
     logs: args.logs.slice(),
     verifications: getCollectedVerifications(),
@@ -314439,7 +315117,6 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       sketchToDxf,
       bom,
       sheetStock,
-      robotExport,
       Sim,
       group,
       ShapeGroup,
@@ -315142,7 +315819,8 @@ function serializeShape(obj, timings) {
         vertProperties: meshVertProperties,
         mergeFromVert: meshMergeFromVert.length > 0 ? meshMergeFromVert : void 0,
         mergeToVert: meshMergeToVert.length > 0 ? meshMergeToVert : void 0,
-        vertNormals: vertNormals ?? void 0
+        vertNormals: vertNormals ?? void 0,
+        cornerNormals: rawMesh.cornerNormals && rawMesh.cornerNormals.length === numTriangles * 9 ? rawMesh.cornerNormals : void 0
       },
       { skipEdges: occtBackend !== null }
     );