forgecad 0.10.2 → 0.10.3

package/dist/assets/{backendInit-ymjonyQp.js → backendInit-DbTkQN9J.js}

@@ -3268,20 +3268,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}.`);
 }
@@ -3294,7 +3294,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}.`);
   }
@@ -3318,7 +3318,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;
@@ -3338,8 +3338,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}].`);
   }
@@ -10242,7 +10242,7 @@ async function initTruckGeometryWasm() {
   if (_initPromise$2) return _initPromise$2;
   _initPromise$2 = (async () => {
     try {
-      const geometryModule = await __vitePreload(() => import("./forgecad_geometry-BlMtqluF.js"), true ? [] : void 0);
+      const geometryModule = await __vitePreload(() => import("./forgecad_geometry-CZ_IfuvA.js"), true ? [] : void 0);
       const isNode = isNodeRuntime();
       if (isNode) {
         const { readFileSync, existsSync } = await __vitePreload(async () => {
@@ -11170,23 +11170,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.
@@ -12557,7 +12596,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);
@@ -12833,15 +12872,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) {
@@ -12897,12 +12936,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;
       }
@@ -12963,7 +13002,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) {
@@ -12990,7 +13029,7 @@ async function initManifoldWasm() {
   if (_wasm) return _wasm;
   performance.mark("manifold:start");
   const Module = (await __vitePreload(async () => {
-    const { default: __vite_default__ } = await import("./manifold-C4r6B-XY.js");
+    const { default: __vite_default__ } = await import("./manifold-CBry38ly.js");
     return { default: __vite_default__ };
   }, true ? [] : void 0)).default;
   performance.mark("manifold:imported");
@@ -13617,6 +13656,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) {
@@ -13625,16 +13678,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);
   }
 }
@@ -14984,12 +15039,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);
@@ -15014,11 +15073,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);
@@ -59626,7 +59686,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) {
@@ -59672,7 +59732,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]);
@@ -59833,7 +59893,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];
@@ -59926,16 +59986,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$4(sub3$5(uSource, origin), `${context} u axis`);
+  const u2 = normalize3$4(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$7(sub3$5(point2, origin), normal2))), 0);
+  const maxPlaneError = points.reduce((max2, point2) => Math.max(max2, Math.abs(dot3$7(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$7(relative, frame.u), dot3$7(relative, frame.v));
   });
   const triangles = ShapeUtils.triangulateShape(projected, []);
@@ -59944,7 +60004,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.`);
@@ -68462,7 +68522,7 @@ function reconstructSdfBackendFromMesh(mesh) {
   return wrapSdfMeshShapeBackend(boundsFromMeshBackend(runtimeMesh, edgeLength2), runtimeMesh);
 }
 const EPS$d = 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) {
@@ -68485,13 +68545,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$d) 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$7(local, u2), dot3$7(local, v));
 }
 function triangulateStepFace(face, filePath) {
@@ -68515,7 +68575,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$d) {
       failStepImport(filePath, `${face.context} triangulates to a degenerate triangle.`);
     }
@@ -69557,7 +69617,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$7(local, frame.xAxis);
   const y2 = dot3$7(local, frame.yAxis);
   if (Math.hypot(x2, y2) <= 1e-12) throw new Error(`${context} torus major angle is degenerate.`);
@@ -69573,11 +69633,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$7(local, frame.axis), dot3$7(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);
@@ -69589,12 +69649,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$7(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$7(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$4(radialVector, context) };
@@ -69663,9 +69723,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$7(sub3$3(line2.point, axis.origin), axis.axis);
+  const startAxial = dot3$7(sub3$4(line2.point, axis.origin), axis.axis);
   const end = linePoint(line2, 1);
-  const endAxial = dot3$7(sub3$3(end, axis.origin), axis.axis);
+  const endAxial = dot3$7(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.`);
@@ -69694,7 +69754,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 {
@@ -69705,10 +69765,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$7(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)
@@ -69720,7 +69780,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$7(local, frame.xAxis);
   const y2 = dot3$7(local, frame.yAxis);
   if (Math.hypot(x2, y2) <= 1e-12) failStepImport(filePath, `${context} major angle is degenerate.`);
@@ -69762,10 +69822,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$7(normal2, outward) >= 0;
     return sameSense === outwardFacing ? triangle : reverseTriangle(triangle);
   });
@@ -69849,7 +69909,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$7(local, frame.xAxis);
       const y2 = dot3$7(local, frame.yAxis);
       const radialLength = Math.hypot(x2, y2);
@@ -70384,7 +70444,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) {
@@ -70423,9 +70483,9 @@ function triangulateBoundedSphericalCap(frame, radius, loop, sameSense, filePath
   }
   const boundaryCenter = centroid(boundary);
   const capDirection = normalize3$4(newellNormal(boundary), `${context} bounded SPHERICAL_SURFACE boundary normal`);
-  const maxPlaneError = boundary.reduce((max2, point2) => Math.max(max2, Math.abs(dot3$7(sub3$3(point2, boundaryCenter), capDirection))), 0);
+  const maxPlaneError = boundary.reduce((max2, point2) => Math.max(max2, Math.abs(dot3$7(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$4(sub3$3(point2, frame.origin), `${context} bounded SPHERICAL_SURFACE point`));
+  const boundaryDirections = boundary.map((point2) => normalize3$4(sub3$4(point2, frame.origin), `${context} bounded SPHERICAL_SURFACE point`));
   const maxAngle = boundaryDirections.reduce((max2, direction2) => Math.max(max2, Math.acos(clamp$8(dot3$7(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)));
@@ -70464,17 +70524,17 @@ function sphericalLoopInfo(frame, radius, loop, filePath, context) {
   }
   const center = centroid(points);
   const normal2 = normalize3$4(newellNormal(points), `${context} bounded SPHERICAL_SURFACE boundary normal`);
-  const maxPlaneError = points.reduce((max2, point2) => Math.max(max2, Math.abs(dot3$7(sub3$3(point2, center), normal2))), 0);
+  const maxPlaneError = points.reduce((max2, point2) => Math.max(max2, Math.abs(dot3$7(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$4(sub3$3(bInfo.center, aInfo.center), `${context} bounded SPHERICAL_SURFACE band axis`);
+  const axis = normalize3$4(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$7(local, axis));
     return Math.hypot(point2[0] - projected[0], point2[1] - projected[1], point2[2] - projected[2]);
   };
@@ -70483,12 +70543,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$7(rawX, axis);
   const xAxis = normalize3$4([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$7(local, yAxis), dot3$7(local, xAxis));
   };
   const rotateLoop = (loop, center, targetAngle) => {
@@ -70509,8 +70569,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$4(sub3$3(point2, frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
-    const bDirection = normalize3$4(sub3$3(bLoop[index2], frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
+    const aDirection = normalize3$4(sub3$4(point2, frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
+    const bDirection = normalize3$4(sub3$4(bLoop[index2], frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
     return Math.max(max2, Math.acos(clamp$8(dot3$7(aDirection, bDirection), -1, 1)));
   }, 0);
   if (angularSpan <= 1e-6) failStepImport(filePath, `${context} bounded SPHERICAL_SURFACE band has zero angular span.`);
@@ -70520,8 +70580,8 @@ function triangulateBoundedSphericalBand(frame, radius, loops, sameSense, filePa
     const t = ringIndex / radialSegments;
     rings.push(
       aLoop.map((point2, index2) => {
-        const aDirection = normalize3$4(sub3$3(point2, frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
-        const bDirection = normalize3$4(sub3$3(bLoop[index2], frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
+        const aDirection = normalize3$4(sub3$4(point2, frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
+        const bDirection = normalize3$4(sub3$4(bLoop[index2], frame.origin), `${context} bounded SPHERICAL_SURFACE band point`);
         return addScaled$2(frame.origin, slerpUnit(aDirection, bDirection, t), radius);
       })
     );
@@ -72570,14 +72630,14 @@ function cross$7(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;
@@ -72594,14 +72654,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) };
     }
@@ -72611,7 +72671,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",
@@ -72626,7 +72686,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 };
     }
   }
@@ -72635,7 +72695,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 };
     }
   }
@@ -72733,7 +72793,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,
@@ -72744,7 +72804,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);
@@ -73089,7 +73149,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);
@@ -73253,6 +73313,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,
@@ -73266,7 +73327,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;
   }
@@ -74487,6 +74549,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;
@@ -74569,16 +74641,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 = [];
@@ -74592,7 +74664,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);
         }
@@ -74637,10 +74709,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;
@@ -75170,9 +75242,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) {
@@ -77056,7 +77132,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 {
@@ -82015,11 +82091,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$3(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];
 }
@@ -82029,7 +82105,7 @@ function dot3$5(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) {
@@ -82052,7 +82128,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");
     }
@@ -82063,7 +82139,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$3(rawAxis);
@@ -82079,12 +82155,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$5(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$3(ortho);
@@ -82148,8 +82224,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$3(rawAxis) : port.axis,
@@ -82201,7 +82277,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 };
@@ -82286,18 +82362,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$2(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) {
@@ -82320,7 +82396,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) {
@@ -82359,8 +82435,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];
@@ -82373,7 +82449,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],
@@ -82395,8 +82471,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) {
@@ -82596,8 +82672,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];
@@ -87839,8 +87915,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 {
@@ -87851,8 +87926,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 {
@@ -87864,8 +87938,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 {
@@ -87876,8 +87949,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 {
@@ -87888,8 +87960,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 } }
+        ]
       };
   }
 }
@@ -89700,7 +89771,7 @@ class Shape2 {
    *
    * 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**
    *
@@ -92096,14 +92167,14 @@ function dot3$3(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$1(v) {
-  const l = len3(v);
+  const l = len3$1(v);
   if (l < EPS$9) return [0, 0, 0];
   return [v[0] / l, v[1] / l, v[2] / l];
 }
@@ -92115,7 +92186,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$3(n1, n2) - 1;
     const normalDist = dot3$3(delta, n1);
     const cx = n1[1] * n2[2] - n1[2] * n2[1];
@@ -92158,7 +92229,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]);
@@ -92182,9 +92253,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$3(n1, n2) + 1;
-    const crossMag = len3(cross3(n1, n2));
+    const crossMag = len3$1(cross3(n1, n2));
     const signedDist = dot3$3(delta, n1) - distance2;
     return [antiParallel, crossMag, signedDist];
   }
@@ -92204,7 +92275,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$3(n1, n2) + 1;
     const normalDist = dot3$3(delta, n1);
     const cx = n1[1] * n2[2] - n1[2] * n2[1];
@@ -92244,7 +92315,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]);
@@ -92260,7 +92331,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$3(delta, face.normal)];
   }
 };
@@ -92809,7 +92880,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");
@@ -92844,10 +92915,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`);
@@ -93097,8 +93168,8 @@ const clampJointValue$1 = (joint2, value) => {
 };
 function resolveJointViewValues(joints, couplings = [], baseValues = {}, options = {}) {
   const shouldClamp = options.clamp ?? false;
-  const jointByName2 = /* @__PURE__ */ new Map();
-  joints.forEach((joint2) => jointByName2.set(joint2.name, joint2));
+  const jointByName = /* @__PURE__ */ new Map();
+  joints.forEach((joint2) => jointByName.set(joint2.name, joint2));
   const couplingByJoint = /* @__PURE__ */ new Map();
   couplings.forEach((coupling) => couplingByJoint.set(coupling.joint, coupling));
   const cache = /* @__PURE__ */ new Map();
@@ -93106,7 +93177,7 @@ function resolveJointViewValues(joints, couplings = [], baseValues = {}, options
   const resolveValue = (jointName) => {
     const cached = cache.get(jointName);
     if (cached !== void 0) return cached;
-    const joint2 = jointByName2.get(jointName);
+    const joint2 = jointByName.get(jointName);
     if (!joint2) return 0;
     if (resolving.has(jointName)) {
       const cycleFallback = baseValues[jointName] ?? joint2.defaultValue;
@@ -93809,7 +93880,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$1(raw);
           }
           break;
@@ -94335,8 +94406,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
    */
@@ -103450,7 +103521,7 @@ function beltDrive(options) {
 }
 const GEAR_META_KEY = Symbol.for("forgecad.library.gearMeta");
 const EPSILON$1 = 1e-9;
-function clamp01$2(value) {
+function clamp01$4(value) {
   return Math.max(-1, Math.min(1, value));
 }
 function isFinitePositive(value) {
@@ -103470,7 +103541,7 @@ function addArcPoints(target, radius, startAngle, endAngle, steps, includeStart
   }
 }
 function flankAngleAtRadius(radius, baseRadius, halfThicknessAtPitch, pressureAngleRad) {
-  const alphaAtRadius = Math.acos(clamp01$2(baseRadius / Math.max(radius, baseRadius)));
+  const alphaAtRadius = Math.acos(clamp01$4(baseRadius / Math.max(radius, baseRadius)));
   return halfThicknessAtPitch + involuteFn(pressureAngleRad) - involuteFn(alphaAtRadius);
 }
 function addRootFilletPoints(target, rootRadius, filletRadius, flankAngle, sign2, fromFlank, steps) {
@@ -104590,7 +104661,7 @@ function gearPair(options) {
       message: `Center distance ${centerDistance.toFixed(4)} exceeds addendum reach ${addendumReach.toFixed(4)} (no mesh contact)`
     });
   }
-  const cosWorking = clamp01$2(baseSum / Math.max(centerDistance, EPSILON$1));
+  const cosWorking = clamp01$4(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);
@@ -105503,7 +105574,8 @@ class FrozenShape extends Shape2 {
 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);
@@ -105535,7 +105607,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];
@@ -105578,7 +105652,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,
@@ -105776,7 +105850,8 @@ function shapeToGeometryFallback(shape) {
     vertProperties: mesh.vertProperties,
     mergeFromVert: mesh.mergeFromVert,
     mergeToVert: mesh.mergeToVert,
-    vertNormals
+    vertNormals,
+    cornerNormals: mesh.cornerNormals && mesh.cornerNormals.length === mesh.numTri * 9 ? mesh.cornerNormals : void 0
   });
   const solid = new BufferGeometry();
   solid.setAttribute("position", new BufferAttribute(positions, 3));
@@ -105806,26 +105881,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++) {
@@ -105864,7 +105939,7 @@ function highlight(target, opts) {
     });
     return;
   }
-  if (isVec3(target)) {
+  if (isVec3$1(target)) {
     requireFiniteVec3(target, "point");
     collectedDebugHighlights3D.push({
       kind: "point",
@@ -106958,7 +107033,7 @@ function resolveForgeRenderStyle(value) {
 function getRenderStylePreset(style) {
   return PRESETS[resolveForgeRenderStyle(style)];
 }
-function clamp01$1(value) {
+function clamp01$3(value) {
   return Math.max(0, Math.min(1, value));
 }
 function applyMaterial(shape, preset) {
@@ -106980,7 +107055,7 @@ const materials = {
   clearPolycarbonate(options = {}) {
     return {
       color: options.tint ?? "#bdefff",
-      material: { opacity: clamp01$1(options.opacity ?? 0.34), roughness: 0.08, metalness: 0, clearcoat: 1, clearcoatRoughness: 0.03 }
+      material: { opacity: clamp01$3(options.opacity ?? 0.34), roughness: 0.08, metalness: 0, clearcoat: 1, clearcoatRoughness: 0.03 }
     };
   },
   /** Brushed steel-like material for trim, soleplates, and hardware. */
@@ -107457,31 +107532,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) {
@@ -107563,7 +107613,6 @@ function scene(options) {
     lights: null,
     environment: null,
     fog: null,
-    postProcessing: null,
     ground: null,
     capture: null
   };
@@ -107603,12 +107652,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") {
@@ -107768,8 +107814,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;
   }
@@ -108011,8 +108056,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;
   }
@@ -108529,8 +108574,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. */
@@ -108598,9 +108643,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);
@@ -108723,7 +108768,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") {
@@ -108742,7 +108787,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;
@@ -108759,13 +108804,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,
@@ -108922,16 +108967,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) {
@@ -109400,9 +109445,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;
@@ -112336,8 +112381,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) {
@@ -112501,206 +112546,6 @@ ${xrefPos}
     return encoder.encode(parts.join(""));
   }
 }
-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, _f3, _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((_f3 = options.plugins) == null ? void 0 : _f3.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;
@@ -134990,6 +134835,847 @@ function getSketchWorldMatrix(sketch) {
 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 common2 = mergeKnotVectors(
+    elevated.map((c2) => c2.knots),
+    targetDeg
+  );
+  const refined = elevated.map((c2) => refineKnotsToTarget(c2.cps, c2.knots, targetDeg, common2));
+  const ncp = common2.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: common2, 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$2(u2), clamp01$2(v));
+  }
+  normalAt(u2, v) {
+    return evalSurfaceJet(this.surface, clamp01$2(u2), clamp01$2(v)).normal;
+  }
+  curvatureAt(u2, v) {
+    return surfaceCurvature(evalSurfaceJet(this.surface, clamp01$2(u2), clamp01$2(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$2(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$2(t));
+    return { point: j2.S, cross: j2.Su, cross2: j2.Suu };
+  }
+  const j = evalSurfaceJet(surf, clamp01$2(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]));
@@ -136381,7 +137067,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) {
@@ -136401,6 +137096,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.
@@ -136435,6 +137138,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);
@@ -140329,22 +141040,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();
@@ -141600,7 +142299,6 @@ function resetExecutionSession(logs) {
   resetHighlights();
   resetBom();
   resetSheetStock();
-  resetRobotExport();
   resetCutPlanes();
   resetRenderLabels();
   resetCameraTrajectory();
@@ -141683,7 +142381,6 @@ function collectSuccessfulExecutionSnapshot(args) {
     jointsView: getCollectedJointsView(),
     viewConfig: getCollectedViewConfig(),
     sceneConfig: getCollectedScene(),
-    robotExport: getCollectedRobotExport(),
     quality: args.quality,
     logs: args.logs.slice(),
     verifications: getCollectedVerifications(),
@@ -141708,7 +142405,6 @@ function collectFailedExecutionSnapshot(args) {
     jointsView: getCollectedJointsView(),
     viewConfig: getCollectedViewConfig(),
     sceneConfig: getCollectedScene(),
-    robotExport: getCollectedRobotExport(),
     quality: args.quality,
     logs: args.logs.slice(),
     verifications: getCollectedVerifications(),
@@ -355208,7 +355904,6 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       sketchToDxf,
       bom,
       sheetStock,
-      robotExport,
       Sim,
       group,
       ShapeGroup,
@@ -356075,6 +356770,1135 @@ function pointFromProjectedTriangle(u2, v, a2, normal2, uAxis, vAxis, dropAxis,
   const dropped = axisValue(a2, dropAxis) - (axisValue(normal2, uAxis) * (u2 - axisValue(a2, uAxis)) + axisValue(normal2, vAxis) * (v - axisValue(a2, vAxis))) / axisValue(normal2, dropAxis);
   setAxisValue(target, dropAxis, dropped);
 }
+const VIRIDIS_256 = [
+  [68, 1, 84],
+  [68, 2, 86],
+  [69, 4, 87],
+  [69, 5, 89],
+  [70, 7, 90],
+  [70, 8, 92],
+  [70, 10, 93],
+  [70, 11, 94],
+  [71, 13, 96],
+  [71, 14, 97],
+  [71, 16, 99],
+  [71, 17, 100],
+  [71, 19, 101],
+  [72, 20, 103],
+  [72, 22, 104],
+  [72, 23, 105],
+  [72, 24, 106],
+  [72, 26, 108],
+  [72, 27, 109],
+  [72, 28, 110],
+  [72, 29, 111],
+  [72, 31, 112],
+  [72, 32, 113],
+  [72, 33, 115],
+  [72, 35, 116],
+  [72, 36, 117],
+  [72, 37, 118],
+  [72, 38, 119],
+  [72, 40, 120],
+  [72, 41, 121],
+  [71, 42, 122],
+  [71, 44, 122],
+  [71, 45, 123],
+  [71, 46, 124],
+  [71, 47, 125],
+  [70, 48, 126],
+  [70, 50, 126],
+  [70, 51, 127],
+  [70, 52, 128],
+  [69, 53, 129],
+  [69, 55, 129],
+  [69, 56, 130],
+  [68, 57, 131],
+  [68, 58, 131],
+  [68, 59, 132],
+  [67, 61, 132],
+  [67, 62, 133],
+  [66, 63, 133],
+  [66, 64, 134],
+  [66, 65, 134],
+  [65, 66, 135],
+  [65, 68, 135],
+  [64, 69, 136],
+  [64, 70, 136],
+  [63, 71, 136],
+  [63, 72, 137],
+  [62, 73, 137],
+  [62, 74, 137],
+  [62, 76, 138],
+  [61, 77, 138],
+  [61, 78, 138],
+  [60, 79, 138],
+  [60, 80, 139],
+  [59, 81, 139],
+  [59, 82, 139],
+  [58, 83, 139],
+  [58, 84, 140],
+  [57, 85, 140],
+  [57, 86, 140],
+  [56, 88, 140],
+  [56, 89, 140],
+  [55, 90, 140],
+  [55, 91, 141],
+  [54, 92, 141],
+  [54, 93, 141],
+  [53, 94, 141],
+  [53, 95, 141],
+  [52, 96, 141],
+  [52, 97, 141],
+  [51, 98, 141],
+  [51, 99, 141],
+  [50, 100, 142],
+  [50, 101, 142],
+  [49, 102, 142],
+  [49, 103, 142],
+  [49, 104, 142],
+  [48, 105, 142],
+  [48, 106, 142],
+  [47, 107, 142],
+  [47, 108, 142],
+  [46, 109, 142],
+  [46, 110, 142],
+  [46, 111, 142],
+  [45, 112, 142],
+  [45, 113, 142],
+  [44, 113, 142],
+  [44, 114, 142],
+  [44, 115, 142],
+  [43, 116, 142],
+  [43, 117, 142],
+  [42, 118, 142],
+  [42, 119, 142],
+  [42, 120, 142],
+  [41, 121, 142],
+  [41, 122, 142],
+  [41, 123, 142],
+  [40, 124, 142],
+  [40, 125, 142],
+  [39, 126, 142],
+  [39, 127, 142],
+  [39, 128, 142],
+  [38, 129, 142],
+  [38, 130, 142],
+  [38, 130, 142],
+  [37, 131, 142],
+  [37, 132, 142],
+  [37, 133, 142],
+  [36, 134, 142],
+  [36, 135, 142],
+  [35, 136, 142],
+  [35, 137, 142],
+  [35, 138, 141],
+  [34, 139, 141],
+  [34, 140, 141],
+  [34, 141, 141],
+  [33, 142, 141],
+  [33, 143, 141],
+  [33, 144, 141],
+  [33, 145, 140],
+  [32, 146, 140],
+  [32, 146, 140],
+  [32, 147, 140],
+  [31, 148, 140],
+  [31, 149, 139],
+  [31, 150, 139],
+  [31, 151, 139],
+  [31, 152, 139],
+  [31, 153, 138],
+  [31, 154, 138],
+  [30, 155, 138],
+  [30, 156, 137],
+  [30, 157, 137],
+  [31, 158, 137],
+  [31, 159, 136],
+  [31, 160, 136],
+  [31, 161, 136],
+  [31, 161, 135],
+  [31, 162, 135],
+  [32, 163, 134],
+  [32, 164, 134],
+  [33, 165, 133],
+  [33, 166, 133],
+  [34, 167, 133],
+  [34, 168, 132],
+  [35, 169, 131],
+  [36, 170, 131],
+  [37, 171, 130],
+  [37, 172, 130],
+  [38, 173, 129],
+  [39, 173, 129],
+  [40, 174, 128],
+  [41, 175, 127],
+  [42, 176, 127],
+  [44, 177, 126],
+  [45, 178, 125],
+  [46, 179, 124],
+  [47, 180, 124],
+  [49, 181, 123],
+  [50, 182, 122],
+  [52, 182, 121],
+  [53, 183, 121],
+  [55, 184, 120],
+  [56, 185, 119],
+  [58, 186, 118],
+  [59, 187, 117],
+  [61, 188, 116],
+  [63, 188, 115],
+  [64, 189, 114],
+  [66, 190, 113],
+  [68, 191, 112],
+  [70, 192, 111],
+  [72, 193, 110],
+  [74, 193, 109],
+  [76, 194, 108],
+  [78, 195, 107],
+  [80, 196, 106],
+  [82, 197, 105],
+  [84, 197, 104],
+  [86, 198, 103],
+  [88, 199, 101],
+  [90, 200, 100],
+  [92, 200, 99],
+  [94, 201, 98],
+  [96, 202, 96],
+  [99, 203, 95],
+  [101, 203, 94],
+  [103, 204, 92],
+  [105, 205, 91],
+  [108, 205, 90],
+  [110, 206, 88],
+  [112, 207, 87],
+  [115, 208, 86],
+  [117, 208, 84],
+  [119, 209, 83],
+  [122, 209, 81],
+  [124, 210, 80],
+  [127, 211, 78],
+  [129, 211, 77],
+  [132, 212, 75],
+  [134, 213, 73],
+  [137, 213, 72],
+  [139, 214, 70],
+  [142, 214, 69],
+  [144, 215, 67],
+  [147, 215, 65],
+  [149, 216, 64],
+  [152, 216, 62],
+  [155, 217, 60],
+  [157, 217, 59],
+  [160, 218, 57],
+  [162, 218, 55],
+  [165, 219, 54],
+  [168, 219, 52],
+  [170, 220, 50],
+  [173, 220, 48],
+  [176, 221, 47],
+  [178, 221, 45],
+  [181, 222, 43],
+  [184, 222, 41],
+  [186, 222, 40],
+  [189, 223, 38],
+  [192, 223, 37],
+  [194, 223, 35],
+  [197, 224, 33],
+  [200, 224, 32],
+  [202, 225, 31],
+  [205, 225, 29],
+  [208, 225, 28],
+  [210, 226, 27],
+  [213, 226, 26],
+  [216, 226, 25],
+  [218, 227, 25],
+  [221, 227, 24],
+  [223, 227, 24],
+  [226, 228, 24],
+  [229, 228, 25],
+  [231, 228, 25],
+  [234, 229, 26],
+  [236, 229, 27],
+  [239, 229, 28],
+  [241, 229, 29],
+  [244, 230, 30],
+  [246, 230, 32],
+  [248, 230, 33],
+  [251, 231, 35],
+  [253, 231, 37]
+];
+const INFERNO_256 = [
+  [0, 0, 4],
+  [1, 0, 5],
+  [1, 1, 6],
+  [1, 1, 8],
+  [2, 1, 10],
+  [2, 2, 12],
+  [2, 2, 14],
+  [3, 2, 16],
+  [4, 3, 18],
+  [4, 3, 20],
+  [5, 4, 23],
+  [6, 4, 25],
+  [7, 5, 27],
+  [8, 5, 29],
+  [9, 6, 31],
+  [10, 7, 34],
+  [11, 7, 36],
+  [12, 8, 38],
+  [13, 8, 41],
+  [14, 9, 43],
+  [16, 9, 45],
+  [17, 10, 48],
+  [18, 10, 50],
+  [20, 11, 52],
+  [21, 11, 55],
+  [22, 11, 57],
+  [24, 12, 60],
+  [25, 12, 62],
+  [27, 12, 65],
+  [28, 12, 67],
+  [30, 12, 69],
+  [31, 12, 72],
+  [33, 12, 74],
+  [35, 12, 76],
+  [36, 12, 79],
+  [38, 12, 81],
+  [40, 11, 83],
+  [41, 11, 85],
+  [43, 11, 87],
+  [45, 11, 89],
+  [47, 10, 91],
+  [49, 10, 92],
+  [50, 10, 94],
+  [52, 10, 95],
+  [54, 9, 97],
+  [56, 9, 98],
+  [57, 9, 99],
+  [59, 9, 100],
+  [61, 9, 101],
+  [62, 9, 102],
+  [64, 10, 103],
+  [66, 10, 104],
+  [68, 10, 104],
+  [69, 10, 105],
+  [71, 11, 106],
+  [73, 11, 106],
+  [74, 12, 107],
+  [76, 12, 107],
+  [77, 13, 108],
+  [79, 13, 108],
+  [81, 14, 108],
+  [82, 14, 109],
+  [84, 15, 109],
+  [85, 15, 109],
+  [87, 16, 110],
+  [89, 16, 110],
+  [90, 17, 110],
+  [92, 18, 110],
+  [93, 18, 110],
+  [95, 19, 110],
+  [97, 19, 110],
+  [98, 20, 110],
+  [100, 21, 110],
+  [101, 21, 110],
+  [103, 22, 110],
+  [105, 22, 110],
+  [106, 23, 110],
+  [108, 24, 110],
+  [109, 24, 110],
+  [111, 25, 110],
+  [113, 25, 110],
+  [114, 26, 110],
+  [116, 26, 110],
+  [117, 27, 110],
+  [119, 28, 109],
+  [120, 28, 109],
+  [122, 29, 109],
+  [124, 29, 109],
+  [125, 30, 109],
+  [127, 30, 108],
+  [128, 31, 108],
+  [130, 32, 108],
+  [132, 32, 107],
+  [133, 33, 107],
+  [135, 33, 107],
+  [136, 34, 106],
+  [138, 34, 106],
+  [140, 35, 105],
+  [141, 35, 105],
+  [143, 36, 105],
+  [144, 37, 104],
+  [146, 37, 104],
+  [147, 38, 103],
+  [149, 38, 103],
+  [151, 39, 102],
+  [152, 39, 102],
+  [154, 40, 101],
+  [155, 41, 100],
+  [157, 41, 100],
+  [159, 42, 99],
+  [160, 42, 99],
+  [162, 43, 98],
+  [163, 44, 97],
+  [165, 44, 96],
+  [166, 45, 96],
+  [168, 46, 95],
+  [169, 46, 94],
+  [171, 47, 94],
+  [173, 48, 93],
+  [174, 48, 92],
+  [176, 49, 91],
+  [177, 50, 90],
+  [179, 50, 90],
+  [180, 51, 89],
+  [182, 52, 88],
+  [183, 53, 87],
+  [185, 53, 86],
+  [186, 54, 85],
+  [188, 55, 84],
+  [189, 56, 83],
+  [191, 57, 82],
+  [192, 58, 81],
+  [193, 58, 80],
+  [195, 59, 79],
+  [196, 60, 78],
+  [198, 61, 77],
+  [199, 62, 76],
+  [200, 63, 75],
+  [202, 64, 74],
+  [203, 65, 73],
+  [204, 66, 72],
+  [206, 67, 71],
+  [207, 68, 70],
+  [208, 69, 69],
+  [210, 70, 68],
+  [211, 71, 67],
+  [212, 72, 66],
+  [213, 74, 65],
+  [215, 75, 63],
+  [216, 76, 62],
+  [217, 77, 61],
+  [218, 78, 60],
+  [219, 80, 59],
+  [221, 81, 58],
+  [222, 82, 56],
+  [223, 83, 55],
+  [224, 85, 54],
+  [225, 86, 53],
+  [226, 87, 52],
+  [227, 89, 51],
+  [228, 90, 49],
+  [229, 92, 48],
+  [230, 93, 47],
+  [231, 94, 46],
+  [232, 96, 45],
+  [233, 97, 43],
+  [234, 99, 42],
+  [235, 100, 41],
+  [235, 102, 40],
+  [236, 103, 38],
+  [237, 105, 37],
+  [238, 106, 36],
+  [239, 108, 35],
+  [239, 110, 33],
+  [240, 111, 32],
+  [241, 113, 31],
+  [241, 115, 29],
+  [242, 116, 28],
+  [243, 118, 27],
+  [243, 120, 25],
+  [244, 121, 24],
+  [245, 123, 23],
+  [245, 125, 21],
+  [246, 126, 20],
+  [246, 128, 19],
+  [247, 130, 18],
+  [247, 132, 16],
+  [248, 133, 15],
+  [248, 135, 14],
+  [248, 137, 12],
+  [249, 139, 11],
+  [249, 140, 10],
+  [249, 142, 9],
+  [250, 144, 8],
+  [250, 146, 7],
+  [250, 148, 7],
+  [251, 150, 6],
+  [251, 151, 6],
+  [251, 153, 6],
+  [251, 155, 6],
+  [251, 157, 7],
+  [252, 159, 7],
+  [252, 161, 8],
+  [252, 163, 9],
+  [252, 165, 10],
+  [252, 166, 12],
+  [252, 168, 13],
+  [252, 170, 15],
+  [252, 172, 17],
+  [252, 174, 18],
+  [252, 176, 20],
+  [252, 178, 22],
+  [252, 180, 24],
+  [251, 182, 26],
+  [251, 184, 29],
+  [251, 186, 31],
+  [251, 188, 33],
+  [251, 190, 35],
+  [250, 192, 38],
+  [250, 194, 40],
+  [250, 196, 42],
+  [250, 198, 45],
+  [249, 199, 47],
+  [249, 201, 50],
+  [249, 203, 53],
+  [248, 205, 55],
+  [248, 207, 58],
+  [247, 209, 61],
+  [247, 211, 64],
+  [246, 213, 67],
+  [246, 215, 70],
+  [245, 217, 73],
+  [245, 219, 76],
+  [244, 221, 79],
+  [244, 223, 83],
+  [244, 225, 86],
+  [243, 227, 90],
+  [243, 229, 93],
+  [242, 230, 97],
+  [242, 232, 101],
+  [242, 234, 105],
+  [241, 236, 109],
+  [241, 237, 113],
+  [241, 239, 117],
+  [241, 241, 121],
+  [242, 242, 125],
+  [242, 244, 130],
+  [243, 245, 134],
+  [243, 246, 138],
+  [244, 248, 142],
+  [245, 249, 146],
+  [246, 250, 150],
+  [248, 251, 154],
+  [249, 252, 157],
+  [250, 253, 161],
+  [252, 255, 164]
+];
+const TURBO_256 = [
+  [48, 18, 59],
+  [50, 21, 67],
+  [51, 24, 74],
+  [52, 27, 81],
+  [53, 30, 88],
+  [54, 33, 95],
+  [55, 36, 102],
+  [56, 39, 109],
+  [57, 42, 115],
+  [58, 45, 121],
+  [59, 47, 128],
+  [60, 50, 134],
+  [61, 53, 139],
+  [62, 56, 145],
+  [63, 59, 151],
+  [63, 62, 156],
+  [64, 64, 162],
+  [65, 67, 167],
+  [65, 70, 172],
+  [66, 73, 177],
+  [66, 75, 181],
+  [67, 78, 186],
+  [68, 81, 191],
+  [68, 84, 195],
+  [68, 86, 199],
+  [69, 89, 203],
+  [69, 92, 207],
+  [69, 94, 211],
+  [70, 97, 214],
+  [70, 100, 218],
+  [70, 102, 221],
+  [70, 105, 224],
+  [70, 107, 227],
+  [71, 110, 230],
+  [71, 113, 233],
+  [71, 115, 235],
+  [71, 118, 238],
+  [71, 120, 240],
+  [71, 123, 242],
+  [70, 125, 244],
+  [70, 128, 246],
+  [70, 130, 248],
+  [70, 133, 250],
+  [70, 135, 251],
+  [69, 138, 252],
+  [69, 140, 253],
+  [68, 143, 254],
+  [67, 145, 254],
+  [66, 148, 255],
+  [65, 150, 255],
+  [64, 153, 255],
+  [62, 155, 254],
+  [61, 158, 254],
+  [59, 160, 253],
+  [58, 163, 252],
+  [56, 165, 251],
+  [55, 168, 250],
+  [53, 171, 248],
+  [51, 173, 247],
+  [49, 175, 245],
+  [47, 178, 244],
+  [46, 180, 242],
+  [44, 183, 240],
+  [42, 185, 238],
+  [40, 188, 235],
+  [39, 190, 233],
+  [37, 192, 231],
+  [35, 195, 228],
+  [34, 197, 226],
+  [32, 199, 223],
+  [31, 201, 221],
+  [30, 203, 218],
+  [28, 205, 216],
+  [27, 208, 213],
+  [26, 210, 210],
+  [26, 212, 208],
+  [25, 213, 205],
+  [24, 215, 202],
+  [24, 217, 200],
+  [24, 219, 197],
+  [24, 221, 194],
+  [24, 222, 192],
+  [24, 224, 189],
+  [25, 226, 187],
+  [25, 227, 185],
+  [26, 228, 182],
+  [28, 230, 180],
+  [29, 231, 178],
+  [31, 233, 175],
+  [32, 234, 172],
+  [34, 235, 170],
+  [37, 236, 167],
+  [39, 238, 164],
+  [42, 239, 161],
+  [44, 240, 158],
+  [47, 241, 155],
+  [50, 242, 152],
+  [53, 243, 148],
+  [56, 244, 145],
+  [60, 245, 142],
+  [63, 246, 138],
+  [67, 247, 135],
+  [70, 248, 132],
+  [74, 248, 128],
+  [78, 249, 125],
+  [82, 250, 122],
+  [85, 250, 118],
+  [89, 251, 115],
+  [93, 252, 111],
+  [97, 252, 108],
+  [101, 253, 105],
+  [105, 253, 102],
+  [109, 254, 98],
+  [113, 254, 95],
+  [117, 254, 92],
+  [121, 254, 89],
+  [125, 255, 86],
+  [128, 255, 83],
+  [132, 255, 81],
+  [136, 255, 78],
+  [139, 255, 75],
+  [143, 255, 73],
+  [146, 255, 71],
+  [150, 254, 68],
+  [153, 254, 66],
+  [156, 254, 64],
+  [159, 253, 63],
+  [161, 253, 61],
+  [164, 252, 60],
+  [167, 252, 58],
+  [169, 251, 57],
+  [172, 251, 56],
+  [175, 250, 55],
+  [177, 249, 54],
+  [180, 248, 54],
+  [183, 247, 53],
+  [185, 246, 53],
+  [188, 245, 52],
+  [190, 244, 52],
+  [193, 243, 52],
+  [195, 241, 52],
+  [198, 240, 52],
+  [200, 239, 52],
+  [203, 237, 52],
+  [205, 236, 52],
+  [208, 234, 52],
+  [210, 233, 53],
+  [212, 231, 53],
+  [215, 229, 53],
+  [217, 228, 54],
+  [219, 226, 54],
+  [221, 224, 55],
+  [223, 223, 55],
+  [225, 221, 55],
+  [227, 219, 56],
+  [229, 217, 56],
+  [231, 215, 57],
+  [233, 213, 57],
+  [235, 211, 57],
+  [236, 209, 58],
+  [238, 207, 58],
+  [239, 205, 58],
+  [241, 203, 58],
+  [242, 201, 58],
+  [244, 199, 58],
+  [245, 197, 58],
+  [246, 195, 58],
+  [247, 193, 58],
+  [248, 190, 57],
+  [249, 188, 57],
+  [250, 186, 57],
+  [251, 184, 56],
+  [251, 182, 55],
+  [252, 179, 54],
+  [252, 177, 54],
+  [253, 174, 53],
+  [253, 172, 52],
+  [254, 169, 51],
+  [254, 167, 50],
+  [254, 164, 49],
+  [254, 161, 48],
+  [254, 158, 47],
+  [254, 155, 45],
+  [254, 153, 44],
+  [254, 150, 43],
+  [254, 147, 42],
+  [254, 144, 41],
+  [253, 141, 39],
+  [253, 138, 38],
+  [252, 135, 37],
+  [252, 132, 35],
+  [251, 129, 34],
+  [251, 126, 33],
+  [250, 123, 31],
+  [249, 120, 30],
+  [249, 117, 29],
+  [248, 114, 28],
+  [247, 111, 26],
+  [246, 108, 25],
+  [245, 105, 24],
+  [244, 102, 23],
+  [243, 99, 21],
+  [242, 96, 20],
+  [241, 93, 19],
+  [240, 91, 18],
+  [239, 88, 17],
+  [237, 85, 16],
+  [236, 83, 15],
+  [235, 80, 14],
+  [234, 78, 13],
+  [232, 75, 12],
+  [231, 73, 12],
+  [229, 71, 11],
+  [228, 69, 10],
+  [226, 67, 10],
+  [225, 65, 9],
+  [223, 63, 8],
+  [221, 61, 8],
+  [220, 59, 7],
+  [218, 57, 7],
+  [216, 55, 6],
+  [214, 53, 6],
+  [212, 51, 5],
+  [210, 49, 5],
+  [208, 47, 5],
+  [206, 45, 4],
+  [204, 43, 4],
+  [202, 42, 4],
+  [200, 40, 3],
+  [197, 38, 3],
+  [195, 37, 3],
+  [193, 35, 2],
+  [190, 33, 2],
+  [188, 32, 2],
+  [185, 30, 2],
+  [183, 29, 2],
+  [180, 27, 1],
+  [178, 26, 1],
+  [175, 24, 1],
+  [172, 23, 1],
+  [169, 22, 1],
+  [167, 20, 1],
+  [164, 19, 1],
+  [161, 18, 1],
+  [158, 16, 1],
+  [155, 15, 1],
+  [152, 14, 1],
+  [149, 13, 1],
+  [146, 11, 1],
+  [142, 10, 1],
+  [139, 9, 2],
+  [136, 8, 2],
+  [133, 7, 2],
+  [129, 6, 2],
+  [126, 5, 2],
+  [122, 4, 3]
+];
+const COOLWARM_256 = [
+  [59, 76, 192],
+  [60, 78, 194],
+  [61, 80, 195],
+  [62, 81, 197],
+  [63, 83, 198],
+  [64, 85, 200],
+  [66, 87, 201],
+  [67, 88, 203],
+  [68, 90, 204],
+  [69, 92, 206],
+  [70, 94, 207],
+  [72, 95, 209],
+  [73, 97, 210],
+  [74, 99, 211],
+  [75, 100, 213],
+  [76, 102, 214],
+  [78, 104, 216],
+  [79, 105, 217],
+  [80, 107, 218],
+  [81, 109, 219],
+  [83, 110, 221],
+  [84, 112, 222],
+  [85, 114, 223],
+  [86, 115, 224],
+  [88, 117, 225],
+  [89, 119, 227],
+  [90, 120, 228],
+  [91, 122, 229],
+  [93, 124, 230],
+  [94, 125, 231],
+  [95, 127, 232],
+  [97, 128, 233],
+  [98, 130, 234],
+  [99, 132, 235],
+  [100, 133, 236],
+  [102, 135, 237],
+  [103, 136, 238],
+  [104, 138, 239],
+  [106, 139, 239],
+  [107, 141, 240],
+  [108, 143, 241],
+  [110, 144, 242],
+  [111, 146, 243],
+  [112, 147, 243],
+  [114, 149, 244],
+  [115, 150, 245],
+  [117, 151, 246],
+  [118, 153, 246],
+  [119, 154, 247],
+  [121, 156, 248],
+  [122, 157, 248],
+  [123, 159, 249],
+  [125, 160, 249],
+  [126, 161, 250],
+  [128, 163, 250],
+  [129, 164, 251],
+  [130, 166, 251],
+  [132, 167, 252],
+  [133, 168, 252],
+  [134, 169, 252],
+  [136, 171, 253],
+  [137, 172, 253],
+  [139, 173, 253],
+  [140, 175, 254],
+  [141, 176, 254],
+  [143, 177, 254],
+  [144, 178, 254],
+  [146, 180, 254],
+  [147, 181, 254],
+  [148, 182, 255],
+  [150, 183, 255],
+  [151, 184, 255],
+  [152, 185, 255],
+  [154, 187, 255],
+  [155, 188, 255],
+  [157, 189, 255],
+  [158, 190, 255],
+  [159, 191, 255],
+  [161, 192, 255],
+  [162, 193, 255],
+  [163, 194, 254],
+  [165, 195, 254],
+  [166, 196, 254],
+  [167, 197, 254],
+  [169, 198, 253],
+  [170, 199, 253],
+  [171, 200, 253],
+  [173, 201, 253],
+  [174, 201, 252],
+  [175, 202, 252],
+  [177, 203, 252],
+  [178, 204, 251],
+  [179, 205, 251],
+  [181, 205, 250],
+  [182, 206, 250],
+  [183, 207, 249],
+  [185, 208, 249],
+  [186, 208, 248],
+  [187, 209, 248],
+  [188, 210, 247],
+  [190, 210, 246],
+  [191, 211, 246],
+  [192, 212, 245],
+  [193, 212, 244],
+  [195, 213, 244],
+  [196, 213, 243],
+  [197, 214, 242],
+  [198, 214, 241],
+  [199, 215, 240],
+  [201, 215, 240],
+  [202, 216, 239],
+  [203, 216, 238],
+  [204, 217, 237],
+  [205, 217, 236],
+  [206, 218, 235],
+  [207, 218, 234],
+  [209, 218, 233],
+  [210, 219, 232],
+  [211, 219, 231],
+  [212, 219, 230],
+  [213, 219, 229],
+  [214, 220, 228],
+  [215, 220, 227],
+  [216, 220, 226],
+  [217, 220, 225],
+  [218, 220, 224],
+  [219, 220, 222],
+  [220, 221, 221],
+  [221, 220, 220],
+  [222, 220, 219],
+  [223, 219, 217],
+  [224, 219, 216],
+  [225, 218, 214],
+  [226, 218, 213],
+  [227, 217, 211],
+  [228, 217, 210],
+  [229, 216, 209],
+  [230, 215, 207],
+  [231, 215, 206],
+  [232, 214, 204],
+  [233, 213, 203],
+  [234, 213, 201],
+  [234, 212, 200],
+  [235, 211, 198],
+  [236, 211, 197],
+  [237, 210, 195],
+  [237, 209, 194],
+  [238, 208, 192],
+  [239, 207, 191],
+  [239, 206, 189],
+  [240, 205, 187],
+  [241, 205, 186],
+  [241, 204, 184],
+  [242, 203, 183],
+  [242, 202, 181],
+  [242, 201, 180],
+  [243, 200, 178],
+  [243, 199, 177],
+  [244, 198, 175],
+  [244, 197, 173],
+  [245, 196, 172],
+  [245, 194, 170],
+  [245, 193, 169],
+  [245, 192, 167],
+  [246, 191, 166],
+  [246, 190, 164],
+  [246, 189, 162],
+  [247, 188, 161],
+  [247, 186, 159],
+  [247, 185, 158],
+  [247, 184, 156],
+  [247, 183, 155],
+  [247, 181, 153],
+  [247, 180, 151],
+  [247, 179, 150],
+  [247, 177, 148],
+  [247, 176, 147],
+  [247, 175, 145],
+  [247, 173, 144],
+  [247, 172, 142],
+  [247, 170, 140],
+  [247, 169, 139],
+  [247, 168, 137],
+  [247, 166, 136],
+  [246, 165, 134],
+  [246, 163, 133],
+  [246, 162, 131],
+  [245, 160, 129],
+  [245, 159, 128],
+  [245, 157, 126],
+  [245, 156, 125],
+  [244, 154, 123],
+  [244, 152, 122],
+  [243, 151, 120],
+  [243, 149, 119],
+  [243, 148, 117],
+  [242, 146, 116],
+  [242, 144, 114],
+  [241, 143, 113],
+  [241, 141, 111],
+  [240, 139, 110],
+  [240, 138, 108],
+  [239, 136, 107],
+  [238, 134, 105],
+  [238, 132, 104],
+  [237, 131, 102],
+  [236, 129, 101],
+  [236, 127, 99],
+  [235, 125, 98],
+  [234, 123, 96],
+  [233, 122, 95],
+  [233, 120, 93],
+  [232, 118, 92],
+  [231, 116, 91],
+  [230, 114, 89],
+  [229, 112, 88],
+  [228, 110, 86],
+  [227, 108, 85],
+  [227, 107, 84],
+  [226, 105, 82],
+  [225, 103, 81],
+  [224, 101, 79],
+  [223, 99, 78],
+  [222, 97, 77],
+  [221, 95, 75],
+  [220, 93, 74],
+  [218, 90, 73],
+  [217, 88, 71],
+  [216, 86, 70],
+  [215, 84, 69],
+  [214, 82, 68],
+  [213, 80, 66],
+  [212, 78, 65],
+  [210, 75, 64],
+  [209, 73, 63],
+  [208, 71, 61],
+  [207, 69, 60],
+  [205, 66, 59],
+  [204, 64, 58],
+  [203, 62, 56],
+  [202, 59, 55],
+  [200, 56, 54],
+  [199, 54, 53],
+  [197, 51, 52],
+  [196, 48, 50],
+  [195, 46, 49],
+  [193, 43, 48],
+  [192, 40, 47],
+  [190, 36, 46],
+  [189, 31, 45],
+  [187, 27, 44],
+  [186, 22, 43],
+  [184, 18, 42],
+  [183, 13, 40],
+  [181, 9, 39],
+  [180, 4, 38]
+];
+const COLOR_SCALE_LUT_SIZE = 256;
+const THICKNESS_CLASSIC_STOPS = [
+  [255, 28, 28],
+  [255, 222, 0],
+  [60, 220, 90],
+  [70, 145, 255]
+];
+const COLORMAP_STOPS = {
+  viridis: VIRIDIS_256,
+  inferno: INFERNO_256,
+  turbo: TURBO_256,
+  coolwarm: COOLWARM_256,
+  grayscale: [[0, 0, 0], [255, 255, 255]],
+  "thickness-classic": THICKNESS_CLASSIC_STOPS
+};
+const COLORMAP_LABELS = {
+  viridis: "Viridis",
+  inferno: "Inferno",
+  turbo: "Turbo",
+  coolwarm: "Cool–Warm",
+  grayscale: "Grayscale",
+  "thickness-classic": "Thickness (classic)"
+};
+const COLORMAP_OPTIONS = [
+  { name: "viridis", label: COLORMAP_LABELS.viridis },
+  { name: "inferno", label: COLORMAP_LABELS.inferno },
+  { name: "turbo", label: COLORMAP_LABELS.turbo },
+  { name: "coolwarm", label: COLORMAP_LABELS.coolwarm },
+  { name: "grayscale", label: COLORMAP_LABELS.grayscale },
+  { name: "thickness-classic", label: COLORMAP_LABELS["thickness-classic"] }
+];
+function clamp01$1(t) {
+  if (t <= 0) return 0;
+  if (t >= 1) return 1;
+  return t;
+}
+function sampleStops(stops, t) {
+  const clamped = clamp01$1(t);
+  const scaled = clamped * (stops.length - 1);
+  const leftIndex = Math.min(stops.length - 2, Math.floor(scaled));
+  const frac = scaled - leftIndex;
+  const left = stops[leftIndex];
+  const right = stops[leftIndex + 1];
+  return [
+    Math.round(left[0] + (right[0] - left[0]) * frac),
+    Math.round(left[1] + (right[1] - left[1]) * frac),
+    Math.round(left[2] + (right[2] - left[2]) * frac)
+  ];
+}
+function resolveStops(name) {
+  const stops = COLORMAP_STOPS[name];
+  if (!stops) {
+    throw new Error(`Unknown colormap '${String(name)}'. Valid names: ${COLORMAP_OPTIONS.map((o) => o.name).join(", ")}.`);
+  }
+  return stops;
+}
+const DEFAULT_COLORMAP = "viridis";
+function resolveColormapName(value) {
+  return typeof value === "string" && value in COLORMAP_STOPS ? value : DEFAULT_COLORMAP;
+}
+function colorScaleHexStops(name, n = 8) {
+  const count = Math.max(2, Math.floor(n));
+  const stops = resolveStops(name);
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    const [r, g2, b] = sampleStops(stops, i / (count - 1));
+    out.push(`#${(1 << 24 | r << 16 | g2 << 8 | b).toString(16).slice(1)}`);
+  }
+  return out;
+}
+function colorScaleLUT(name) {
+  const stops = resolveStops(name);
+  const lut = new Uint8Array(COLOR_SCALE_LUT_SIZE * 4);
+  for (let i = 0; i < COLOR_SCALE_LUT_SIZE; i++) {
+    const [r, g2, b] = sampleStops(stops, i / (COLOR_SCALE_LUT_SIZE - 1));
+    const o = i * 4;
+    lut[o] = r;
+    lut[o + 1] = g2;
+    lut[o + 2] = b;
+    lut[o + 3] = 255;
+  }
+  return lut;
+}
+function sampleColorScale(scale2, value) {
+  const stops = resolveStops(scale2.colormap);
+  const span = scale2.domainMax - scale2.domainMin;
+  const t = span > 0 ? (value - scale2.domainMin) / span : 0;
+  return sampleStops(stops, Number.isFinite(t) ? t : 0);
+}
+const DEFAULT_THICKNESS_COLOR_SCALE = {
+  colormap: "viridis"
+};
+const DEFAULT_ROUGHNESS_COLOR_SCALE = {
+  colormap: "viridis",
+  domainMin: 0,
+  domainMax: 1
+};
 const MIN_PATCH_TRIANGLES = 1;
 function finitePoint(point2) {
   return point2.point.every((value) => Number.isFinite(value));
@@ -356198,6 +358022,121 @@ const formatPerformanceCount = (value) => INTEGER_FORMATTER.format(Math.max(0, M
 const waitForAnimationFrame = () => new Promise((resolve) => {
   requestAnimationFrame(() => resolve());
 });
+const VECTOR_KEYS = /* @__PURE__ */ new Set(["pos", "position", "target", "lookat", "aim", "up"]);
+const roundNumber = (value, digits) => {
+  const scale2 = 10 ** digits;
+  return Math.round(value * scale2) / scale2;
+};
+const isFiniteTuple3 = (value) => Array.isArray(value) && value.length === 3 && value.every((entry) => typeof entry === "number" && Number.isFinite(entry));
+function parseViewportCameraState(value) {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value;
+  if (candidate.projectionMode !== "perspective" && candidate.projectionMode !== "orthographic") return null;
+  if (!isFiniteTuple3(candidate.position)) return null;
+  if (!isFiniteTuple3(candidate.target)) return null;
+  if (!isFiniteTuple3(candidate.up)) return null;
+  if (candidate.fov !== void 0 && (!Number.isFinite(candidate.fov) || candidate.fov <= 0 || candidate.fov >= 180)) {
+    return null;
+  }
+  if (candidate.orthoZoom !== void 0 && (!Number.isFinite(candidate.orthoZoom) || candidate.orthoZoom <= 0)) {
+    return null;
+  }
+  const parsed = {
+    projectionMode: candidate.projectionMode,
+    position: candidate.position,
+    target: candidate.target,
+    up: candidate.up
+  };
+  if (candidate.fov !== void 0) parsed.fov = candidate.fov;
+  if (candidate.orthoZoom !== void 0) parsed.orthoZoom = candidate.orthoZoom;
+  return parsed;
+}
+function parseVector(name, raw) {
+  const parts = raw.split(",").map((entry) => Number.parseFloat(entry.trim()));
+  if (parts.length !== 3 || parts.some((entry) => !Number.isFinite(entry))) {
+    throw new Error(`Camera ${name} must be three comma-separated numbers.`);
+  }
+  return [parts[0], parts[1], parts[2]];
+}
+function parseCameraCliSpec(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error("Camera spec cannot be empty.");
+  }
+  if (trimmed.startsWith("{")) {
+    const parsed2 = parseViewportCameraState(JSON.parse(trimmed));
+    if (!parsed2) {
+      throw new Error("Camera JSON does not match the expected shape.");
+    }
+    return parsed2;
+  }
+  const parsed = {};
+  const segments = trimmed.split(";").map((segment) => segment.trim()).filter(Boolean);
+  if (segments.length === 0) {
+    throw new Error("Camera spec cannot be empty.");
+  }
+  for (const segment of segments) {
+    const eqIndex = segment.indexOf("=");
+    if (eqIndex === -1) {
+      throw new Error(`Invalid camera segment "${segment}". Expected key=value.`);
+    }
+    const rawKey = segment.slice(0, eqIndex).trim().toLowerCase();
+    const rawValue = segment.slice(eqIndex + 1).trim();
+    if (!rawValue) {
+      throw new Error(`Camera segment "${segment}" is missing a value.`);
+    }
+    if (rawKey === "proj" || rawKey === "projection" || rawKey === "projectionmode") {
+      if (rawValue !== "perspective" && rawValue !== "orthographic") {
+        throw new Error(`Camera projection must be "perspective" or "orthographic" (got "${rawValue}").`);
+      }
+      parsed.projectionMode = rawValue;
+      continue;
+    }
+    if (rawKey === "zoom" || rawKey === "orthozoom") {
+      const zoom = Number.parseFloat(rawValue);
+      if (!Number.isFinite(zoom) || zoom <= 0) {
+        throw new Error(`Camera zoom must be a positive number (got "${rawValue}").`);
+      }
+      parsed.orthoZoom = zoom;
+      continue;
+    }
+    if (rawKey === "fov") {
+      const fov2 = Number.parseFloat(rawValue);
+      if (!Number.isFinite(fov2) || fov2 <= 0 || fov2 >= 180) {
+        throw new Error(`Camera fov must be between 0 and 180 degrees (got "${rawValue}").`);
+      }
+      parsed.fov = fov2;
+      continue;
+    }
+    if (VECTOR_KEYS.has(rawKey)) {
+      const vector = parseVector(rawKey, rawValue);
+      if (rawKey === "pos" || rawKey === "position") parsed.position = vector;
+      if (rawKey === "target" || rawKey === "lookat" || rawKey === "aim") parsed.target = vector;
+      if (rawKey === "up") parsed.up = vector;
+      continue;
+    }
+    throw new Error(`Unknown camera key "${rawKey}".`);
+  }
+  const finalized = parseViewportCameraState({
+    projectionMode: parsed.projectionMode ?? "perspective",
+    position: parsed.position,
+    target: parsed.target,
+    up: parsed.up ?? [0, 0, 1],
+    fov: parsed.fov,
+    orthoZoom: parsed.orthoZoom
+  });
+  if (!finalized) {
+    throw new Error("Camera spec must include position, target, and up vectors.");
+  }
+  return finalized;
+}
+function getCameraForwardVector(state, digits = 3) {
+  const dx = state.target[0] - state.position[0];
+  const dy = state.target[1] - state.position[1];
+  const dz = state.target[2] - state.position[2];
+  const length4 = Math.hypot(dx, dy, dz) || 1;
+  return [roundNumber(dx / length4, digits), roundNumber(dy / length4, digits), roundNumber(dz / length4, digits)];
+}
 const SURFACE_FIELD_VERTEX_SHADER = `
   #include <common>
   #include <logdepthbuf_pars_vertex>
@@ -356506,79 +358445,6 @@ function localAabbPlaneRelation(min2, max2, plane, eps = 1e-7) {
   if (minDistance > -eps) return "positive";
   return "crossing";
 }
-const DEFAULT_ROUGHNESS_INSPECTION_OPTIONS = {
-  smoothAngleDeg: 5,
-  sharpAngleDeg: 30,
-  harshAngleDeg: 90,
-  maxSamplesPerObject: 5e3
-};
-const ROUGHNESS_COLORS = {
-  smooth: [62, 72, 84],
-  moderate: [255, 214, 0],
-  sharp: [255, 124, 34],
-  harsh: [255, 42, 96]
-};
-function resolveRoughnessInspectionOptions(raw = {}) {
-  const options = {
-    smoothAngleDeg: raw.smoothAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.smoothAngleDeg,
-    sharpAngleDeg: raw.sharpAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.sharpAngleDeg,
-    harshAngleDeg: raw.harshAngleDeg ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.harshAngleDeg,
-    maxSamplesPerObject: raw.maxSamplesPerObject ?? DEFAULT_ROUGHNESS_INSPECTION_OPTIONS.maxSamplesPerObject
-  };
-  if (!Number.isFinite(options.smoothAngleDeg) || options.smoothAngleDeg < 0) {
-    throw new Error(`smoothAngleDeg must be a finite non-negative angle (got ${options.smoothAngleDeg}).`);
-  }
-  if (!Number.isFinite(options.sharpAngleDeg) || options.sharpAngleDeg <= options.smoothAngleDeg) {
-    throw new Error(`sharpAngleDeg must be greater than smoothAngleDeg (got ${options.sharpAngleDeg}).`);
-  }
-  if (!Number.isFinite(options.harshAngleDeg) || options.harshAngleDeg <= options.sharpAngleDeg || options.harshAngleDeg > 180) {
-    throw new Error(`harshAngleDeg must be greater than sharpAngleDeg and <= 180 (got ${options.harshAngleDeg}).`);
-  }
-  if (!Number.isFinite(options.maxSamplesPerObject) || options.maxSamplesPerObject <= 0) {
-    throw new Error(`maxSamplesPerObject must be a positive finite number (got ${options.maxSamplesPerObject}).`);
-  }
-  return {
-    ...options,
-    maxSamplesPerObject: Math.max(1, Math.floor(options.maxSamplesPerObject))
-  };
-}
-function roughnessClassForAngle(angleDeg, options) {
-  if (angleDeg >= options.harshAngleDeg) return "harsh";
-  if (angleDeg >= options.sharpAngleDeg) return "sharp";
-  if (angleDeg >= options.smoothAngleDeg) return "moderate";
-  return "smooth";
-}
-function roughnessScoreForAngle(angleDeg, options) {
-  if (angleDeg < options.sharpAngleDeg) return 0;
-  if (angleDeg < options.harshAngleDeg) {
-    return MathUtils.lerp(0.48, 0.82, (angleDeg - options.sharpAngleDeg) / (options.harshAngleDeg - options.sharpAngleDeg));
-  }
-  return 1;
-}
-function roughnessColorForAngle(angleDeg, options) {
-  const cls = roughnessClassForAngle(angleDeg, options);
-  if (cls === "smooth" || cls === "harsh") return ROUGHNESS_COLORS[cls];
-  if (cls === "moderate") {
-    return lerpRgb(
-      ROUGHNESS_COLORS.moderate,
-      ROUGHNESS_COLORS.sharp,
-      (angleDeg - options.smoothAngleDeg) / (options.sharpAngleDeg - options.smoothAngleDeg)
-    );
-  }
-  return lerpRgb(
-    ROUGHNESS_COLORS.sharp,
-    ROUGHNESS_COLORS.harsh,
-    (angleDeg - options.sharpAngleDeg) / (options.harshAngleDeg - options.sharpAngleDeg)
-  );
-}
-function lerpRgb(a2, b, t) {
-  const clamped = MathUtils.clamp(t, 0, 1);
-  return [
-    Math.round(MathUtils.lerp(a2[0], b[0], clamped)),
-    Math.round(MathUtils.lerp(a2[1], b[1], clamped)),
-    Math.round(MathUtils.lerp(a2[2], b[2], clamped))
-  ];
-}
 const DEFAULT_LEAF_SIZE = 8;
 function cloneVec3$2(value) {
   return [value[0], value[1], value[2]];
@@ -357368,121 +359234,6 @@ function summarizeThicknessSamples(samples, options) {
     unresolvedAreaPercent: percent(unresolvedArea, totalArea)
   };
 }
-const VECTOR_KEYS = /* @__PURE__ */ new Set(["pos", "position", "target", "lookat", "aim", "up"]);
-const roundNumber = (value, digits) => {
-  const scale2 = 10 ** digits;
-  return Math.round(value * scale2) / scale2;
-};
-const isFiniteTuple3 = (value) => Array.isArray(value) && value.length === 3 && value.every((entry) => typeof entry === "number" && Number.isFinite(entry));
-function parseViewportCameraState(value) {
-  if (!value || typeof value !== "object") return null;
-  const candidate = value;
-  if (candidate.projectionMode !== "perspective" && candidate.projectionMode !== "orthographic") return null;
-  if (!isFiniteTuple3(candidate.position)) return null;
-  if (!isFiniteTuple3(candidate.target)) return null;
-  if (!isFiniteTuple3(candidate.up)) return null;
-  if (candidate.fov !== void 0 && (!Number.isFinite(candidate.fov) || candidate.fov <= 0 || candidate.fov >= 180)) {
-    return null;
-  }
-  if (candidate.orthoZoom !== void 0 && (!Number.isFinite(candidate.orthoZoom) || candidate.orthoZoom <= 0)) {
-    return null;
-  }
-  const parsed = {
-    projectionMode: candidate.projectionMode,
-    position: candidate.position,
-    target: candidate.target,
-    up: candidate.up
-  };
-  if (candidate.fov !== void 0) parsed.fov = candidate.fov;
-  if (candidate.orthoZoom !== void 0) parsed.orthoZoom = candidate.orthoZoom;
-  return parsed;
-}
-function parseVector(name, raw) {
-  const parts = raw.split(",").map((entry) => Number.parseFloat(entry.trim()));
-  if (parts.length !== 3 || parts.some((entry) => !Number.isFinite(entry))) {
-    throw new Error(`Camera ${name} must be three comma-separated numbers.`);
-  }
-  return [parts[0], parts[1], parts[2]];
-}
-function parseCameraCliSpec(input) {
-  const trimmed = input.trim();
-  if (!trimmed) {
-    throw new Error("Camera spec cannot be empty.");
-  }
-  if (trimmed.startsWith("{")) {
-    const parsed2 = parseViewportCameraState(JSON.parse(trimmed));
-    if (!parsed2) {
-      throw new Error("Camera JSON does not match the expected shape.");
-    }
-    return parsed2;
-  }
-  const parsed = {};
-  const segments = trimmed.split(";").map((segment) => segment.trim()).filter(Boolean);
-  if (segments.length === 0) {
-    throw new Error("Camera spec cannot be empty.");
-  }
-  for (const segment of segments) {
-    const eqIndex = segment.indexOf("=");
-    if (eqIndex === -1) {
-      throw new Error(`Invalid camera segment "${segment}". Expected key=value.`);
-    }
-    const rawKey = segment.slice(0, eqIndex).trim().toLowerCase();
-    const rawValue = segment.slice(eqIndex + 1).trim();
-    if (!rawValue) {
-      throw new Error(`Camera segment "${segment}" is missing a value.`);
-    }
-    if (rawKey === "proj" || rawKey === "projection" || rawKey === "projectionmode") {
-      if (rawValue !== "perspective" && rawValue !== "orthographic") {
-        throw new Error(`Camera projection must be "perspective" or "orthographic" (got "${rawValue}").`);
-      }
-      parsed.projectionMode = rawValue;
-      continue;
-    }
-    if (rawKey === "zoom" || rawKey === "orthozoom") {
-      const zoom = Number.parseFloat(rawValue);
-      if (!Number.isFinite(zoom) || zoom <= 0) {
-        throw new Error(`Camera zoom must be a positive number (got "${rawValue}").`);
-      }
-      parsed.orthoZoom = zoom;
-      continue;
-    }
-    if (rawKey === "fov") {
-      const fov2 = Number.parseFloat(rawValue);
-      if (!Number.isFinite(fov2) || fov2 <= 0 || fov2 >= 180) {
-        throw new Error(`Camera fov must be between 0 and 180 degrees (got "${rawValue}").`);
-      }
-      parsed.fov = fov2;
-      continue;
-    }
-    if (VECTOR_KEYS.has(rawKey)) {
-      const vector = parseVector(rawKey, rawValue);
-      if (rawKey === "pos" || rawKey === "position") parsed.position = vector;
-      if (rawKey === "target" || rawKey === "lookat" || rawKey === "aim") parsed.target = vector;
-      if (rawKey === "up") parsed.up = vector;
-      continue;
-    }
-    throw new Error(`Unknown camera key "${rawKey}".`);
-  }
-  const finalized = parseViewportCameraState({
-    projectionMode: parsed.projectionMode ?? "perspective",
-    position: parsed.position,
-    target: parsed.target,
-    up: parsed.up ?? [0, 0, 1],
-    fov: parsed.fov,
-    orthoZoom: parsed.orthoZoom
-  });
-  if (!finalized) {
-    throw new Error("Camera spec must include position, target, and up vectors.");
-  }
-  return finalized;
-}
-function getCameraForwardVector(state, digits = 3) {
-  const dx = state.target[0] - state.position[0];
-  const dy = state.target[1] - state.position[1];
-  const dz = state.target[2] - state.position[2];
-  const length4 = Math.hypot(dx, dy, dz) || 1;
-  return [roundNumber(dx / length4, digits), roundNumber(dy / length4, digits), roundNumber(dz / length4, digits)];
-}
 const SECTION_EXPLORER_PLANE_NAME = "__section_explorer__";
 function resolveSectionHatchMetrics(geometry) {
   const planeUv = geometry.getAttribute("planeUv");
@@ -359219,88 +360970,88 @@ export {
   Vector4 as Z,
   __vitePreload as _,
   Scene as a,
-  AlwaysDepth as a$,
+  AmbientLight as a$,
   Matrix4 as a0,
   MathUtils as a1,
   Uniform as a2,
   WebGLRenderTarget as a3,
   DepthTexture as a4,
   BackSide as a5,
-  ClampToEdgeWrapping as a6,
-  PlaneGeometry as a7,
-  UVMapping as a8,
-  DataTexture as a9,
-  DEFAULT_ACTIVE_BACKEND as aA,
-  isConstraintSketch as aB,
-  updateConstraintValue as aC,
-  linearizeMultiObjectSteps as aD,
-  getShapeCompilePlan as aE,
-  SCAN_PROXY_GRANULARITY_DEFAULT as aF,
-  publishSolverWasmRunDebug as aG,
-  resolveForgeQualityPreset as aH,
-  SCAN_PROXY_MATRIX_GRANULARITY_MAX as aI,
-  findJointAnimationClip as aJ,
-  resolveJointAnimation as aK,
-  resolveJointViewValues as aL,
-  resolveImportPath as aM,
-  resolveScanProxyGranularity as aN,
-  BufferGeometry as aO,
-  LineBasicMaterial as aP,
-  Line as aQ,
-  LineDashedMaterial as aR,
-  DepthStencilFormat as aS,
-  UnsignedInt248Type as aT,
-  MeshNormalMaterial as aU,
-  NearestFilter as aV,
-  BasicDepthPacking as aW,
-  EventDispatcher as aX,
-  NoColorSpace as aY,
-  FrontSide as aZ,
-  Material as a_,
-  Texture as aa,
-  MeshBasicMaterial as ab,
-  IntType as ac,
-  ShortType as ad,
-  ByteType as ae,
-  UnsignedIntType as af,
-  Loader as ag,
-  LoadingManager as ah,
-  LinearMipMapLinearFilter as ai,
-  FileLoader as aj,
-  NoBlending as ak,
-  CubeReflectionMapping as al,
-  EquirectangularReflectionMapping as am,
-  CubeTextureLoader as an,
-  WebGLCubeRenderTarget as ao,
-  ConstraintSketch as ap,
-  setSketchPlacement3D as aq,
-  Sketch as ar,
-  PROFILE_BACKEND_MARKER as as,
-  FrozenShape as at,
-  setShapeCompilePlan as au,
-  hasAnyPorts as av,
-  setShapePortsInternal as aw,
-  markShapePortsUsed as ax,
-  setParamOverrides as ay,
-  resolveForgeRenderStyle as az,
+  BufferAttribute as a6,
+  Triangle as a7,
+  FrontSide as a8,
+  BatchedMesh as a9,
+  setShapePortsInternal as aA,
+  markShapePortsUsed as aB,
+  resolveColormapName as aC,
+  setParamOverrides as aD,
+  resolveForgeRenderStyle as aE,
+  DEFAULT_ACTIVE_BACKEND as aF,
+  isConstraintSketch as aG,
+  updateConstraintValue as aH,
+  linearizeMultiObjectSteps as aI,
+  getShapeCompilePlan as aJ,
+  SCAN_PROXY_GRANULARITY_DEFAULT as aK,
+  publishSolverWasmRunDebug as aL,
+  resolveForgeQualityPreset as aM,
+  SCAN_PROXY_MATRIX_GRANULARITY_MAX as aN,
+  findJointAnimationClip as aO,
+  resolveJointAnimation as aP,
+  resolveJointViewValues as aQ,
+  resolveImportPath as aR,
+  resolveScanProxyGranularity as aS,
+  BufferGeometry as aT,
+  LineBasicMaterial as aU,
+  Line as aV,
+  LineDashedMaterial as aW,
+  CanvasTexture as aX,
+  Object3D as aY,
+  FogExp2 as aZ,
+  Fog as a_,
+  ClampToEdgeWrapping as aa,
+  PlaneGeometry as ab,
+  UVMapping as ac,
+  DataTexture as ad,
+  Texture as ae,
+  MeshBasicMaterial as af,
+  IntType as ag,
+  ShortType as ah,
+  ByteType as ai,
+  UnsignedIntType as aj,
+  Loader as ak,
+  LoadingManager as al,
+  LinearMipMapLinearFilter as am,
+  FileLoader as an,
+  NoBlending as ao,
+  CubeReflectionMapping as ap,
+  EquirectangularReflectionMapping as aq,
+  CubeTextureLoader as ar,
+  WebGLCubeRenderTarget as as,
+  ConstraintSketch as at,
+  setSketchPlacement3D as au,
+  Sketch as av,
+  PROFILE_BACKEND_MARKER as aw,
+  FrozenShape as ax,
+  setShapeCompilePlan as ay,
+  hasAnyPorts as az,
   PCFSoftShadowMap as b,
-  PERFORMANCE_SAMPLE_INTERVAL_SEC as b$,
-  BufferAttribute as b0,
-  CanvasTexture as b1,
-  Object3D as b2,
-  FogExp2 as b3,
-  Fog as b4,
-  AmbientLight as b5,
-  HemisphereLight as b6,
-  SpotLight as b7,
-  PointLight as b8,
-  DirectionalLight as b9,
-  SDF_RAYMARCH_PROXY_VERTEX_SHADER as bA,
-  scanProxySourceBytes as bB,
-  disposeScanProxyGeometry as bC,
-  scanProxyGeometryFromPayload as bD,
-  AdditiveBlending as bE,
-  geometryWithVisibleVertexColors as bF,
+  formatPerformanceCount as b$,
+  HemisphereLight as b0,
+  SpotLight as b1,
+  PointLight as b2,
+  DirectionalLight as b3,
+  heatPointsForSide as b4,
+  COMPARISON_COLORS as b5,
+  comparisonHeatDepthTest as b6,
+  comparisonHeatEdgeOpacity as b7,
+  comparisonHeatPatchOpacity as b8,
+  shapeToGeometry as b9,
+  scanProxySourceBytes as bA,
+  disposeScanProxyGeometry as bB,
+  scanProxyGeometryFromPayload as bC,
+  AdditiveBlending as bD,
+  geometryWithVisibleVertexColors as bE,
+  colorScaleLUT as bF,
   getRenderStylePreset as bG,
   SCAN_RENDER_COLORS as bH,
   NormalBlending as bI,
@@ -359319,121 +361070,118 @@ export {
   WORLD_UP as bV,
   CatmullRomCurve3 as bW,
   TubeGeometry as bX,
-  THICKNESS_GRADIENT_COLORS as bY,
-  ROUGHNESS_COLORS as bZ,
-  DEFAULT_ROUGHNESS_INSPECTION_OPTIONS as b_,
-  heatPointsForSide as ba,
-  COMPARISON_COLORS as bb,
-  comparisonHeatDepthTest as bc,
-  comparisonHeatEdgeOpacity as bd,
-  comparisonHeatPatchOpacity as be,
-  shapeToGeometry as bf,
-  buildComparisonHeatPatchGeometry as bg,
-  EdgesGeometry as bh,
-  buildShapeFromCompilePlan as bi,
-  buildVisibleHistoryStacks as bj,
-  sketchToSvg as bk,
-  sketchToDxf as bl,
-  runScript as bm,
-  MeshPhysicalMaterial as bn,
-  LineSegments as bo,
-  findDesignTraceNodeForConstructionStep as bp,
-  formatDesignTraceAnchor as bq,
-  waitForAnimationFrame as br,
-  selectBuildLedgerNodes as bs,
-  worldAuthorPlaneToLocal as bt,
-  compileSdfProgramEvaluator3 as bu,
-  SDF_LINEAR_OUTPUT_COLOR_GLSL as bv,
-  GLSL3 as bw,
-  BoxGeometry as bx,
-  Data3DTexture as by,
-  buildSdfRaymarchFragmentShader as bz,
+  DEFAULT_COLORMAP as bY,
+  colorScaleHexStops as bZ,
+  PERFORMANCE_SAMPLE_INTERVAL_SEC as b_,
+  buildComparisonHeatPatchGeometry as ba,
+  EdgesGeometry as bb,
+  buildShapeFromCompilePlan as bc,
+  VIEWPORT_CAMERA_STORAGE_KEY as bd,
+  parseViewportCameraState as be,
+  getKernelFaceNameForTriangle as bf,
+  OBJECT_CONTEXT_MENU_MARGIN as bg,
+  buildVisibleHistoryStacks as bh,
+  sketchToSvg as bi,
+  sketchToDxf as bj,
+  runScript as bk,
+  MeshPhysicalMaterial as bl,
+  LineSegments as bm,
+  findDesignTraceNodeForConstructionStep as bn,
+  formatDesignTraceAnchor as bo,
+  waitForAnimationFrame as bp,
+  selectBuildLedgerNodes as bq,
+  NoColorSpace as br,
+  worldAuthorPlaneToLocal as bs,
+  compileSdfProgramEvaluator3 as bt,
+  SDF_LINEAR_OUTPUT_COLOR_GLSL as bu,
+  GLSL3 as bv,
+  BoxGeometry as bw,
+  Data3DTexture as bx,
+  buildSdfRaymarchFragmentShader as by,
+  SDF_RAYMARCH_PROXY_VERTEX_SHADER as bz,
   PCFShadowMap as c,
-  setActiveBackend as c$,
-  formatPerformanceCount as c0,
-  NON_TEXT_INPUT_TYPES as c1,
-  MeshStandardMaterial as c2,
-  Shape$1 as c3,
-  ShapeGeometry as c4,
-  ShaderLib as c5,
-  CylinderGeometry as c6,
-  VIEWPORT_CAMERA_STORAGE_KEY as c7,
-  parseViewportCameraState as c8,
-  createResolvedExplodeConfig as c9,
-  buildGeometryComparisonPointCloud as cA,
-  aabbOverlaps as cB,
-  aabbOverlapVolume as cC,
-  DEFAULT_COLLISION_INSPECTION_OPTIONS as cD,
-  resolveScalarSceneSampleBudget as cE,
-  FOCUS_MODE_DIM_OPACITY as cF,
-  comparisonCandidateContextOpacity as cG,
-  Matrix3 as cH,
-  initBackendForEvaluation as cI,
-  localAabbPlaneRelation as cJ,
-  ShapeUtils as cK,
-  analyzePhysicalConnectivity as cL,
-  Frustum as cM,
-  meshContactDataFor as cN,
-  AabbSpatialIndex as cO,
-  detectPhysicalContact as cP,
-  resolveThicknessInspectionOptions as cQ,
-  thicknessColor as cR,
-  thicknessClass as cS,
-  roughnessClassForAngle as cT,
-  resolveRoughnessInspectionOptions as cU,
-  roughnessColorForAngle as cV,
-  roughnessScoreForAngle as cW,
-  Group as cX,
-  createScanProxyGeometry as cY,
-  resolveSectionHatchMetrics as cZ,
-  intersectWithPlane as c_,
-  explodeBoundsCenter as ca,
-  explodeMergeBounds as cb,
-  resolveExplodeDirective as cc,
-  computeExplodeMotion as cd,
-  getSketchWorldMatrix as ce,
-  explodeAdd as cf,
-  hasExplodeOverride as cg,
-  resolveExplodeLocalFanDirection as ch,
-  explodeMul as ci,
-  explodeLeafFanStage as cj,
-  normalizeCutPlane as ck,
-  toClippingPlane as cl,
-  isObjectExcludedFromCutPlane as cm,
-  getShapePorts as cn,
-  getShapeUsedPorts as co,
-  DEFAULT_VIEW_CONFIG as cp,
-  SECTION_EXPLORER_PLANE_NAME as cq,
-  ZERO_OFFSET as cr,
-  scanProxyGridForBounds as cs,
-  IDENTITY_MATRIX as ct,
-  OBJECT_CONTEXT_MENU_MARGIN as cu,
-  OBJECT_CONTEXT_MENU_WIDTH as cv,
-  OBJECT_CONTEXT_MENU_HEIGHT as cw,
-  getKernelFaceNameForTriangle as cx,
-  triangleSoupFromMeshes as cy,
-  compareTriangleSoups as cz,
+  summarizeThicknessSamples as c$,
+  NON_TEXT_INPUT_TYPES as c0,
+  MeshStandardMaterial as c1,
+  Shape$1 as c2,
+  ShapeGeometry as c3,
+  ShaderLib as c4,
+  CylinderGeometry as c5,
+  createResolvedExplodeConfig as c6,
+  explodeBoundsCenter as c7,
+  explodeMergeBounds as c8,
+  resolveExplodeDirective as c9,
+  FOCUS_MODE_DIM_OPACITY as cA,
+  DEFAULT_THICKNESS_INSPECTION_OPTIONS as cB,
+  comparisonCandidateContextOpacity as cC,
+  Matrix3 as cD,
+  initBackendForEvaluation as cE,
+  localAabbPlaneRelation as cF,
+  ShapeUtils as cG,
+  analyzePhysicalConnectivity as cH,
+  Frustum as cI,
+  meshContactDataFor as cJ,
+  AabbSpatialIndex as cK,
+  detectPhysicalContact as cL,
+  resolveThicknessInspectionOptions as cM,
+  thicknessColor as cN,
+  thicknessClass as cO,
+  Group as cP,
+  createScanProxyGeometry as cQ,
+  resolveSectionHatchMetrics as cR,
+  intersectWithPlane as cS,
+  setActiveBackend as cT,
+  parseCameraCliSpec as cU,
+  PMREMGenerator as cV,
+  DEFAULT_ROUGHNESS_COLOR_SCALE as cW,
+  PointsMaterial as cX,
+  Points$1 as cY,
+  analyzeCollisionIntersections as cZ,
+  serializeCollisionFinding as c_,
+  computeExplodeMotion as ca,
+  getSketchWorldMatrix as cb,
+  explodeAdd as cc,
+  hasExplodeOverride as cd,
+  resolveExplodeLocalFanDirection as ce,
+  explodeMul as cf,
+  explodeLeafFanStage as cg,
+  normalizeCutPlane as ch,
+  toClippingPlane as ci,
+  isObjectExcludedFromCutPlane as cj,
+  getShapePorts as ck,
+  getShapeUsedPorts as cl,
+  DEFAULT_VIEW_CONFIG as cm,
+  SECTION_EXPLORER_PLANE_NAME as cn,
+  ZERO_OFFSET as co,
+  scanProxyGridForBounds as cp,
+  IDENTITY_MATRIX as cq,
+  OBJECT_CONTEXT_MENU_WIDTH as cr,
+  OBJECT_CONTEXT_MENU_HEIGHT as cs,
+  triangleSoupFromMeshes as ct,
+  compareTriangleSoups as cu,
+  buildGeometryComparisonPointCloud as cv,
+  aabbOverlaps as cw,
+  aabbOverlapVolume as cx,
+  DEFAULT_COLLISION_INSPECTION_OPTIONS as cy,
+  resolveScalarSceneSampleBudget as cz,
   SRGBColorSpace as d,
-  parseCameraCliSpec as d0,
-  PMREMGenerator as d1,
-  PointsMaterial as d2,
-  Points$1 as d3,
-  analyzeCollisionIntersections as d4,
-  serializeCollisionFinding as d5,
-  summarizeThicknessSamples as d6,
-  THICKNESS_COLORS as d7,
-  TorusGeometry as d8,
-  SphereGeometry as d9,
-  ConeGeometry as da,
-  DEFAULT_COMPARISON_CANDIDATE_OPACITY as db,
-  computeCuttingLayout as dc,
-  generateCuttingLayoutPdf as dd,
-  buildDesignTraceNeighborhood as de,
-  getCameraForwardVector as df,
-  RENDER_STYLE_OPTIONS as dg,
-  SCAN_PROXY_GRANULARITY_MAX as dh,
-  SCAN_PROXY_GRANULARITY_MIN as di,
-  __viteBrowserExternal$1 as dj,
+  THICKNESS_GRADIENT_COLORS as d0,
+  THICKNESS_COLORS as d1,
+  DEFAULT_THICKNESS_COLOR_SCALE as d2,
+  TorusGeometry as d3,
+  sampleColorScale as d4,
+  SphereGeometry as d5,
+  ConeGeometry as d6,
+  DEFAULT_COMPARISON_CANDIDATE_OPACITY as d7,
+  computeCuttingLayout as d8,
+  generateCuttingLayoutPdf as d9,
+  buildDesignTraceNeighborhood as da,
+  getCameraForwardVector as db,
+  RENDER_STYLE_OPTIONS as dc,
+  SCAN_PROXY_GRANULARITY_MAX as dd,
+  SCAN_PROXY_GRANULARITY_MIN as de,
+  COLORMAP_OPTIONS as df,
+  __viteBrowserExternal$1 as dg,
   Layers as e,
   Color as f,
   RGBAFormat as g,