forgecad 0.10.2 → 0.10.3

package/dist/assets/{reportWorker-CwenM7wB.js → reportWorker-CWvn0CEv.js}

@@ -3175,20 +3175,20 @@ function generateClampedKnots(n, degree) {
   return knots;
 }
 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}.`);
 }
@@ -3201,7 +3201,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}.`);
   }
@@ -3225,7 +3225,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;
@@ -3245,8 +3245,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}].`);
   }
@@ -9653,7 +9653,7 @@ async function initTruckGeometryWasm() {
   if (_initPromise$1) return _initPromise$1;
   _initPromise$1 = (async () => {
     try {
-      const geometryModule = await import("./forgecad_geometry-BlMtqluF.js");
+      const geometryModule = await import("./forgecad_geometry-CZ_IfuvA.js");
       const isNode = isNodeRuntime();
       if (isNode) {
         const { readFileSync, existsSync } = await Promise.resolve().then(function() {
@@ -10451,23 +10451,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.
@@ -11833,7 +11872,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$4(b, a2), sub3$4(d2, a2));
+    const n = cross3$7(sub3$5(b, a2), sub3$5(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);
@@ -12109,15 +12148,15 @@ function buildSpanRows(rings, heights) {
 function stationTangent(stations, t, i, j) {
   const R = stations.length;
   if (i === 0) {
-    return scale3$1(sub3$4(stations[1][j], stations[0][j]), 1 / (t[1] - t[0]));
+    return scale3$1(sub3$5(stations[1][j], stations[0][j]), 1 / (t[1] - t[0]));
   }
   if (i === R - 1) {
-    return scale3$1(sub3$4(stations[R - 1][j], stations[R - 2][j]), 1 / (t[R - 1] - t[R - 2]));
+    return scale3$1(sub3$5(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$1(sub3$4(stations[i][j], stations[i - 1][j]), 1 / hPrev);
-  const dNext = scale3$1(sub3$4(stations[i + 1][j], stations[i][j]), 1 / hNext);
+  const dPrev = scale3$1(sub3$5(stations[i][j], stations[i - 1][j]), 1 / hPrev);
+  const dNext = scale3$1(sub3$5(stations[i + 1][j], stations[i][j]), 1 / hNext);
   return scale3$1(add3$1(scale3$1(dPrev, hNext), scale3$1(dNext, hPrev)), 1 / (hPrev + hNext));
 }
 function hermite(p0, m0, p1, m1, h, u2) {
@@ -12173,12 +12212,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$4(next, curr), tangents[j]);
-        const nBwd = surfaceNormal(sub3$4(curr, prev), tangents[j]);
+        const nFwd = surfaceNormal(sub3$5(next, curr), tangents[j]);
+        const nBwd = surfaceNormal(sub3$5(curr, prev), tangents[j]);
         fwd[j] = pushVert(curr, nFwd);
         bwd[j] = pushVert(curr, nBwd);
       } else {
-        const idx = pushVert(curr, surfaceNormal(sub3$4(next, prev), tangents[j]));
+        const idx = pushVert(curr, surfaceNormal(sub3$5(next, prev), tangents[j]));
         fwd[j] = idx;
         bwd[j] = idx;
       }
@@ -12239,7 +12278,7 @@ function surfaceNormal(chord, span) {
   }
   return [n[0] / len2, n[1] / len2, n[2] / len2];
 }
-function sub3$4(a2, b) {
+function sub3$5(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
 function add3$1(a2, b) {
@@ -12265,7 +12304,7 @@ let _wasm = null;
 async function initManifoldWasm() {
   if (_wasm) return _wasm;
   performance.mark("manifold:start");
-  const Module = (await import("./manifold-5PP1eGLN.js")).default;
+  const Module = (await import("./manifold-Crd_F2qx.js")).default;
   performance.mark("manifold:imported");
   const wasm = await Module();
   wasm.setup();
@@ -12890,6 +12929,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) {
@@ -12898,16 +12951,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);
   }
 }
@@ -14257,12 +14312,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];
+    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];
-    allPositions.push(x2 - nx * thickness, y2 - ny * thickness, z2 - nz * thickness);
+    vertProps.push(x2 - nx * thickness, y2 - ny * thickness, z2 - nz * thickness, -nx, -ny, -nz);
   }
   const allIndices = [];
   for (const idx of indices) allIndices.push(idx);
@@ -14287,11 +14346,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);
@@ -30984,14 +31044,14 @@ function cross$6(a2, b) {
 function isFiniteNumber$1(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
-function isVec3$2(value) {
+function isVec3$3(value) {
   return Array.isArray(value) && value.length === 3 && value.every(isFiniteNumber$1);
 }
 function isVec2(value) {
   return Array.isArray(value) && value.length === 2 && value.every(isFiniteNumber$1);
 }
 function isRuledRails(value) {
-  return Array.isArray(value) && value.length === 2 && value.every((rail2) => Array.isArray(rail2) && rail2.length === 2 && rail2.every(isVec3$2));
+  return Array.isArray(value) && value.length === 2 && value.every((rail2) => Array.isArray(rail2) && rail2.length === 2 && rail2.every(isVec3$3));
 }
 function axisSpan(face, axis) {
   if (face.vertices.length === 0) return 0;
@@ -31008,14 +31068,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) };
     }
@@ -31025,7 +31085,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",
@@ -31040,7 +31100,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 };
     }
   }
@@ -31049,7 +31109,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 };
     }
   }
@@ -31147,7 +31207,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,
@@ -31158,7 +31218,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);
@@ -31503,7 +31563,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 key = edgeKey(start, end);
     if (seenEdges.has(key)) continue;
     seenEdges.set(key, edges.size);
@@ -31667,6 +31727,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,
@@ -31680,7 +31741,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;
   }
@@ -32898,6 +32960,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;
@@ -32980,16 +33052,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 = [];
@@ -33003,7 +33075,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);
         }
@@ -33048,10 +33120,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;
@@ -33581,9 +33653,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) {
@@ -35467,7 +35543,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 {
@@ -40405,11 +40481,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$2(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];
 }
@@ -40419,7 +40495,7 @@ function dot3$5(a2, b) {
 function cross3$3(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$3(a2, b) {
+function sub3$4(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
 function negate3$1(v) {
@@ -40442,7 +40518,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");
     }
@@ -40453,7 +40529,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$2(rawAxis);
@@ -40469,12 +40545,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$2(ortho);
@@ -40538,8 +40614,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$2(rawAxis) : port.axis,
@@ -40591,7 +40667,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$3(pOrigin, rcI);
+  const t = sub3$4(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 };
@@ -40676,18 +40752,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$1(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$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(v) {
@@ -40710,7 +40786,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$2(parentOrigin, rc);
+  const t = sub3$3(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) {
@@ -40749,8 +40825,8 @@ function computeMultiPairAlignment(pairs, childPorts, targetPorts, tolerance = 0
     [0, 0, 0]
   ];
   for (const p2 of pairs) {
-    const s = sub3$2(p2.childOrigin, srcCentroid);
-    const t2 = sub3$2(p2.targetOrigin, tgtCentroid);
+    const s = sub3$3(p2.childOrigin, srcCentroid);
+    const t2 = sub3$3(p2.targetOrigin, tgtCentroid);
     for (let i = 0; i < 3; i++) {
       for (let j = 0; j < 3; j++) {
         h[i][j] += s[i] * t2[j];
@@ -40763,7 +40839,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$2(tgtCentroid, rSrc);
+  const t = sub3$3(tgtCentroid, rSrc);
   const transform = Transform.from([
     R[0][0],
     R[1][0],
@@ -40785,8 +40861,8 @@ function computeMultiPairAlignment(pairs, childPorts, targetPorts, tolerance = 0
   const residuals = [];
   for (const p2 of pairs) {
     const transformed = transform.point(p2.childOrigin);
-    const diff = sub3$2(transformed, p2.targetOrigin);
-    residuals.push(len3$1(diff));
+    const diff = sub3$3(transformed, p2.targetOrigin);
+    residuals.push(len3$2(diff));
   }
   const maxResidual = Math.max(...residuals);
   if (maxResidual > tolerance) {
@@ -40986,8 +41062,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$2(a2.origin, b.origin);
-  return len3$1(d2);
+  const d2 = sub3$3(a2.origin, b.origin);
+  return len3$2(d2);
 }
 function getConnectorMeasurements(ports, name) {
   const p2 = ports[name];
@@ -46096,8 +46172,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 {
@@ -46108,8 +46183,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 {
@@ -46121,8 +46195,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 {
@@ -46133,8 +46206,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 {
@@ -46145,8 +46217,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 } }
+        ]
       };
   }
 }
@@ -47319,7 +47390,7 @@ class Shape {
    *
    * Use `.color()` to set the base diffuse color; `.material()` controls how that color behaves
    * under light (metalness, roughness, clearcoat) and can add emissive glow independent of
-   * lighting. Emissive glow pairs naturally with the `postProcessing.bloom` effect in `scene()`.
+   * lighting.
    *
    * **Example**
    *
@@ -49693,14 +49764,14 @@ function dot3$3(a2, b) {
 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 len3(v) {
+function len3$1(v) {
   return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
 }
 function normalize3(v) {
-  const l = len3(v);
+  const l = len3$1(v);
   if (l < EPS$8) return [0, 0, 0];
   return [v[0] / l, v[1] / l, v[2] / l];
 }
@@ -49712,7 +49783,7 @@ const alignDef = {
     const faceB = ctx.worldFace(constraint.refB.bodyId, constraint.refB.featureName);
     const n1 = faceA.normal;
     const n2 = faceB.normal;
-    const delta = sub3$1(faceB.center, faceA.center);
+    const delta = sub3$2(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];
@@ -49755,7 +49826,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$1(axisA.direction, axisB.direction);
-    const delta = sub3$1(axisB.origin, axisA.origin);
+    const delta = sub3$2(axisB.origin, axisA.origin);
     const offsetCross = cross3$1(delta, axisA.direction);
     const pickTwo = (v) => {
       const ax = Math.abs(v[0]);
@@ -49779,9 +49850,9 @@ const faceDistanceDef = {
     const distance2 = constraint.value ?? 0;
     const n1 = faceA.normal;
     const n2 = faceB.normal;
-    const delta = sub3$1(faceB.center, faceA.center);
+    const delta = sub3$2(faceB.center, faceA.center);
     const antiParallel = dot3$3(n1, n2) + 1;
-    const crossMag = len3(cross3$1(n1, n2));
+    const crossMag = len3$1(cross3$1(n1, n2));
     const signedDist = dot3$3(delta, n1) - distance2;
     return [antiParallel, crossMag, signedDist];
   }
@@ -49801,7 +49872,7 @@ const flushDef = {
     const faceB = ctx.worldFace(constraint.refB.bodyId, constraint.refB.featureName);
     const n1 = faceA.normal;
     const n2 = faceB.normal;
-    const delta = sub3$1(faceB.center, faceA.center);
+    const delta = sub3$2(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];
@@ -49841,7 +49912,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$1(point2, axis.origin);
+    const delta = sub3$2(point2, axis.origin);
     const c2 = cross3$1(delta, axis.direction);
     const ax = Math.abs(c2[0]);
     const ay = Math.abs(c2[1]);
@@ -49857,7 +49928,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$1(point2, face.center);
+    const delta = sub3$2(point2, face.center);
     return [dot3$3(delta, face.normal)];
   }
 };
@@ -50406,7 +50477,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");
@@ -50441,10 +50512,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`);
@@ -51363,7 +51434,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$1(bodyA.grounded ? posB.position : posA.position, bodyA.grounded ? posA.position : posB.position);
+            const raw = sub3$2(bodyA.grounded ? posB.position : posA.position, bodyA.grounded ? posA.position : posB.position);
             dir = normalize3(raw);
           }
           break;
@@ -51889,8 +51960,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
    */
@@ -60937,7 +61008,7 @@ function beltDrive(options) {
 }
 const GEAR_META_KEY = Symbol.for("forgecad.library.gearMeta");
 const EPSILON$1 = 1e-9;
-function clamp01$1(value) {
+function clamp01$2(value) {
   return Math.max(-1, Math.min(1, value));
 }
 function isFinitePositive(value) {
@@ -60957,7 +61028,7 @@ function addArcPoints(target, radius, startAngle, endAngle, steps, includeStart
   }
 }
 function flankAngleAtRadius(radius, baseRadius, halfThicknessAtPitch, pressureAngleRad) {
-  const alphaAtRadius = Math.acos(clamp01$1(baseRadius / Math.max(radius, baseRadius)));
+  const alphaAtRadius = Math.acos(clamp01$2(baseRadius / Math.max(radius, baseRadius)));
   return halfThicknessAtPitch + involuteFn(pressureAngleRad) - involuteFn(alphaAtRadius);
 }
 function addRootFilletPoints(target, rootRadius, filletRadius, flankAngle, sign2, fromFlank, steps) {
@@ -62077,7 +62148,7 @@ function gearPair(options) {
       message: `Center distance ${centerDistance.toFixed(4)} exceeds addendum reach ${addendumReach.toFixed(4)} (no mesh contact)`
     });
   }
-  const cosWorking = clamp01$1(baseSum / Math.max(centerDistance, EPSILON$1));
+  const cosWorking = clamp01$2(baseSum / Math.max(centerDistance, EPSILON$1));
   const alphaWorking = Math.acos(cosWorking);
   const basePitch = Math.PI * module * Math.cos(alpha);
   const pathLength = Math.sqrt(Math.max(0, pinion.meta.outerRadius ** 2 - pinion.meta.baseRadius ** 2)) + Math.sqrt(Math.max(0, gear.meta.outerRadius ** 2 - gear.meta.baseRadius ** 2)) - centerDistance * Math.sin(alphaWorking);
@@ -62987,7 +63058,8 @@ class FrozenShape extends Shape {
 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);
@@ -63019,7 +63091,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];
@@ -63062,7 +63136,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,
@@ -63249,7 +63323,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));
@@ -63279,26 +63354,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++) {
@@ -63337,7 +63412,7 @@ function highlight(target, opts) {
     });
     return;
   }
-  if (isVec3(target)) {
+  if (isVec3$1(target)) {
     requireFiniteVec3(target, "point");
     collectedDebugHighlights3D.push({
       kind: "point",
@@ -64381,7 +64456,7 @@ const PRESETS = {
   }
 };
 new Set(Object.keys(PRESETS));
-function clamp01(value) {
+function clamp01$1(value) {
   return Math.max(0, Math.min(1, value));
 }
 function applyMaterial(shape, preset) {
@@ -64403,7 +64478,7 @@ const materials = {
   clearPolycarbonate(options = {}) {
     return {
       color: options.tint ?? "#bdefff",
-      material: { opacity: clamp01(options.opacity ?? 0.34), roughness: 0.08, metalness: 0, clearcoat: 1, clearcoatRoughness: 0.03 }
+      material: { opacity: clamp01$1(options.opacity ?? 0.34), roughness: 0.08, metalness: 0, clearcoat: 1, clearcoatRoughness: 0.03 }
     };
   },
   /** Brushed steel-like material for trim, soleplates, and hardware. */
@@ -64880,31 +64955,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) {
@@ -64986,7 +65036,6 @@ function scene(options) {
     lights: null,
     environment: null,
     fog: null,
-    postProcessing: null,
     ground: null,
     capture: null
   };
@@ -65026,12 +65075,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") {
@@ -65191,8 +65237,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;
   }
@@ -65434,8 +65479,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;
   }
@@ -65952,8 +65997,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. */
@@ -66021,9 +66066,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);
@@ -66146,7 +66191,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") {
@@ -66165,7 +66210,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;
@@ -66182,13 +66227,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,
@@ -66345,16 +66390,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) {
@@ -66823,9 +66868,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;
@@ -69759,8 +69804,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) {
@@ -70017,7 +70062,7 @@ function norm(v) {
   if (len2 < 1e-12) return [0, 0, 1];
   return [v[0] / len2, v[1] / len2, v[2] / len2];
 }
-function sub3(a2, b) {
+function sub3$1(a2, b) {
   return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
 }
 function mul3(a2, s) {
@@ -70253,7 +70298,7 @@ function collectShapeTriangles(shape) {
       mesh.vertProperties[i2 * numProp + 1],
       mesh.vertProperties[i2 * numProp + 2]
     ];
-    const n = norm(cross3(sub3(b, a2), sub3(c2, a2)));
+    const n = norm(cross3(sub3$1(b, a2), sub3$1(c2, a2)));
     tris.push({ a: a2, b, c: c2, normal: n });
   }
   return tris;
@@ -70323,7 +70368,7 @@ function summarizeMetricSeries(values) {
   return [signatureNumber(sum2), signatureNumber(sumSquares), signatureNumber(min2), signatureNumber(max2)].join(":");
 }
 function triangleArea(triangle) {
-  const c2 = cross3(sub3(triangle.b, triangle.a), sub3(triangle.c, triangle.a));
+  const c2 = cross3(sub3$1(triangle.b, triangle.a), sub3$1(triangle.c, triangle.a));
   return Math.hypot(c2[0], c2[1], c2[2]) * 0.5;
 }
 function makeComponentPageSignature(object) {
@@ -70411,7 +70456,7 @@ function setReportLengthUnit(unit) {
   _reportLengthUnit = unit;
 }
 function projectPoint(point2, center, frame) {
-  const rel = sub3(point2, center);
+  const rel = sub3$1(point2, center);
   return {
     x: dot3$1(rel, frame.right),
     y: dot3$1(rel, frame.up),
@@ -70432,7 +70477,7 @@ function makeViewFrame(view) {
   return { id: view, label: c2.label, right, up, forward };
 }
 function isDimensionVisibleInView(dim2, frame, toleranceDeg) {
-  const dir = sub3(dim2.to, dim2.from);
+  const dir = sub3$1(dim2.to, dim2.from);
   const len2 = Math.hypot(dir[0], dir[1], dir[2]);
   if (len2 < 1e-9) return false;
   const d2 = [dir[0] / len2, dir[1] / len2, dir[2] / len2];
@@ -70468,7 +70513,7 @@ function pickDimensionOffsetBasis(dirModel, frame) {
     candidates.push({ dir3, proj, projDir, projLen });
   };
   worldAxes.forEach((axis) => {
-    const axisPerp = sub3(axis, mul3(dirModel, dot3$1(axis, dirModel)));
+    const axisPerp = sub3$1(axis, mul3(dirModel, dot3$1(axis, dirModel)));
     pushCandidate(axisPerp);
   });
   if (candidates.length === 0) {
@@ -71008,7 +71053,7 @@ function drawDimension(dim2, frame, mapPoint, mapScale, color, cell, fromProject
   const dy = toProjected[1] - fromProjected[1];
   const len2 = Math.hypot(dx, dy);
   if (len2 < 1e-8) return { graphicsCmd: "", labelPlan: null, lineSegments: [] };
-  const modelDirRaw = sub3(dim2.to, dim2.from);
+  const modelDirRaw = sub3$1(dim2.to, dim2.from);
   const modelLen = Math.hypot(modelDirRaw[0], modelDirRaw[1], modelDirRaw[2]);
   if (modelLen < 1e-9) return { graphicsCmd: "", labelPlan: null, lineSegments: [] };
   const modelDir = [modelDirRaw[0] / modelLen, modelDirRaw[1] / modelLen, modelDirRaw[2] / modelLen];
@@ -71642,206 +71687,6 @@ function generateReportPdf(result, options = {}) {
     bomItemCount: collectBomRows(bomEntries).length
   };
 }
-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, _g, _h, _i;
-  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((_g = options.plugins) == null ? void 0 : _g.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((_h = world == null ? void 0 : world.keyboardTeleop) == null ? void 0 : _h.linearStep, "simulation model world keyboardTeleop.linearStep");
-  assertFinite((_i = world == null ? void 0 : world.keyboardTeleop) == null ? void 0 : _i.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;
@@ -94115,6 +93960,847 @@ function sketchOnFace(sketch, parentOrFace, faceOrOpts, maybeOpts = {}) {
 Sketch.prototype.onFace = function(parentOrFace, faceOrOpts, maybeOpts = {}) {
   return sketchOnFace(this, parentOrFace, faceOrOpts, maybeOpts);
 };
+const KNOT_EPS = 1e-10;
+const KNOT_MERGE_EPS = 1e-7;
+function sameKnot(a2, b) {
+  return Math.abs(a2 - b) <= KNOT_EPS;
+}
+function knotMultiplicity(knots, u2) {
+  let count = 0;
+  for (const k2 of knots) if (sameKnot(k2, u2)) count++;
+  return count;
+}
+function computeParamsCentripetal(points, alpha = 0.5) {
+  const n = points.length;
+  const params = new Array(n).fill(0);
+  const seg = new Array(n).fill(0);
+  let total = 0;
+  for (let k2 = 1; k2 < n; k2++) {
+    const dx = points[k2][0] - points[k2 - 1][0];
+    const dy = points[k2][1] - points[k2 - 1][1];
+    const dz = points[k2][2] - points[k2 - 1][2];
+    seg[k2] = Math.hypot(dx, dy, dz) ** alpha;
+    total += seg[k2];
+  }
+  if (total === 0) {
+    for (let k2 = 0; k2 < n; k2++) params[k2] = n > 1 ? k2 / (n - 1) : 0;
+    return params;
+  }
+  let acc = 0;
+  for (let k2 = 1; k2 < n - 1; k2++) {
+    acc += seg[k2];
+    params[k2] = acc / total;
+  }
+  params[n - 1] = 1;
+  return params;
+}
+function knotsFromParamsAveraging(params, degree) {
+  const n = params.length - 1;
+  const m2 = n + degree + 1;
+  const knots = new Array(m2 + 1).fill(0);
+  for (let i = m2 - degree; i <= m2; i++) knots[i] = 1;
+  for (let j = 1; j <= n - degree; j++) {
+    let s = 0;
+    for (let i = j; i <= j + degree - 1; i++) s += params[i];
+    knots[j + degree] = s / degree;
+  }
+  return knots;
+}
+function solveLinear(A, B2) {
+  const n = A.length;
+  const k2 = B2[0].length;
+  const M = A.map((row, i) => [...row, ...B2[i]]);
+  for (let col = 0; col < n; col++) {
+    let piv = col;
+    for (let r = col + 1; r < n; r++) if (Math.abs(M[r][col]) > Math.abs(M[piv][col])) piv = r;
+    if (Math.abs(M[piv][col]) < 1e-14) throw new Error(`Singular interpolation matrix at column ${col}.`);
+    [M[col], M[piv]] = [M[piv], M[col]];
+    const inv = 1 / M[col][col];
+    for (let j = col; j < n + k2; j++) M[col][j] *= inv;
+    for (let r = 0; r < n; r++) {
+      if (r === col) continue;
+      const f3 = M[r][col];
+      if (f3 === 0) continue;
+      for (let j = col; j < n + k2; j++) M[r][j] -= f3 * M[col][j];
+    }
+  }
+  return Array.from({ length: n }, (_2, i) => M[i].slice(n));
+}
+function globalCurveInterp(points, degree, paramsIn) {
+  const last = points.length - 1;
+  if (last < degree) throw new Error(`Curve interpolation needs at least ${degree + 1} points, got ${points.length}.`);
+  const params = paramsIn ? paramsIn.slice() : computeParamsCentripetal(points, 0.5);
+  const knots = knotsFromParamsAveraging(params, degree);
+  const count = last + 1;
+  const N = Array.from({ length: count }, () => new Array(count).fill(0));
+  for (let i = 0; i <= last; i++) {
+    const span = findSpan(count, degree, params[i], knots);
+    const basis = basisFuns(span, params[i], degree, knots);
+    for (let j = 0; j <= degree; j++) N[i][span - degree + j] = basis[j];
+  }
+  const Q = points.map((p2) => [p2[0], p2[1], p2[2]]);
+  const cps = solveLinear(N, Q);
+  return { cps, knots, degree };
+}
+function insertKnotCurve(cps, knots, degree, u2) {
+  const n = cps.length;
+  const span = findSpan(n, degree, u2, knots);
+  const mult = knotMultiplicity(knots, u2);
+  if (mult >= degree) return { cps: cps.slice(), knots: knots.slice() };
+  const newCps = new Array(n + 1);
+  const newKnots = new Array(knots.length + 1);
+  for (let i = 0; i <= span; i++) newKnots[i] = knots[i];
+  newKnots[span + 1] = u2;
+  for (let i = span + 1; i < knots.length; i++) newKnots[i + 1] = knots[i];
+  for (let i = 0; i <= span - degree; i++) newCps[i] = [...cps[i]];
+  for (let i = span - mult; i < n; i++) newCps[i + 1] = [...cps[i]];
+  for (let i = span - degree + 1; i <= span - mult; i++) {
+    const denom = knots[i + degree] - knots[i];
+    const alpha = denom === 0 ? 0 : (u2 - knots[i]) / denom;
+    const a2 = cps[i - 1];
+    const b = cps[i];
+    newCps[i] = [(1 - alpha) * a2[0] + alpha * b[0], (1 - alpha) * a2[1] + alpha * b[1], (1 - alpha) * a2[2] + alpha * b[2]];
+  }
+  return { cps: newCps, knots: newKnots };
+}
+function interiorKnotBuckets(kv, mergeEps = KNOT_MERGE_EPS) {
+  const buckets = [];
+  for (const k2 of kv) {
+    if (k2 <= KNOT_EPS || k2 >= 1 - KNOT_EPS) continue;
+    const b = buckets.find((x2) => Math.abs(x2.value - k2) <= mergeEps);
+    if (b) b.mult++;
+    else buckets.push({ value: k2, mult: 1 });
+  }
+  return buckets;
+}
+function mergeKnotVectors(knotVectors, degree, mergeEps = KNOT_MERGE_EPS) {
+  const merged = [];
+  for (const kv of knotVectors) {
+    for (const { value, mult } of interiorKnotBuckets(kv, mergeEps)) {
+      const b = merged.find((x2) => Math.abs(x2.value - value) <= mergeEps);
+      if (b) b.mult = Math.max(b.mult, mult);
+      else merged.push({ value, mult });
+    }
+  }
+  merged.sort((a2, b) => a2.value - b.value);
+  const out = [];
+  for (let i = 0; i <= degree; i++) out.push(0);
+  for (const { value, mult } of merged) for (let i = 0; i < mult; i++) out.push(value);
+  for (let i = 0; i <= degree; i++) out.push(1);
+  return out;
+}
+function refineKnotsToTarget(cps, knots, degree, targetKnots, mergeEps = KNOT_MERGE_EPS) {
+  let curCps = cps.map((p2) => [...p2]);
+  let curKnots = knots.slice();
+  for (const { value, mult } of interiorKnotBuckets(targetKnots, mergeEps)) {
+    const curMult = () => curKnots.reduce((c2, k2) => c2 + (Math.abs(k2 - value) <= mergeEps ? 1 : 0), 0);
+    let guard = 0;
+    while (curMult() < mult) {
+      const r = insertKnotCurve(curCps, curKnots, degree, value);
+      if (r.cps.length === curCps.length) break;
+      curCps = r.cps;
+      curKnots = r.knots;
+      if (++guard > degree + 2) break;
+    }
+  }
+  return { cps: curCps, knots: curKnots };
+}
+function binomial(a2, b) {
+  if (b < 0 || b > a2) return 0;
+  let r = 1;
+  for (let i = 0; i < b; i++) r = r * (a2 - i) / (i + 1);
+  return r;
+}
+function bezierElevate(bez, p2, t) {
+  const m2 = p2 + t;
+  const out = [];
+  for (let i = 0; i <= m2; i++) {
+    const acc = [0, 0, 0];
+    const lo = Math.max(0, i - t);
+    const hi = Math.min(p2, i);
+    for (let j = lo; j <= hi; j++) {
+      const w2 = binomial(p2, j) * binomial(t, i - j) / binomial(m2, i);
+      acc[0] += w2 * bez[j][0];
+      acc[1] += w2 * bez[j][1];
+      acc[2] += w2 * bez[j][2];
+    }
+    out.push(acc);
+  }
+  return out;
+}
+function elevateCurveDegree(cps, knots, degree, targetDegree) {
+  if (targetDegree === degree) return { cps: cps.map((p2) => [...p2]), knots: knots.slice(), degree };
+  if (targetDegree < degree) throw new Error("Degree reduction is not supported.");
+  const t = targetDegree - degree;
+  let curCps = cps.map((p2) => [...p2]);
+  let curKnots = knots.slice();
+  const breaks = interiorKnotBuckets(curKnots).map((b) => b.value);
+  for (const v of breaks) {
+    let guard = 0;
+    while (knotMultiplicity(curKnots, v) < degree) {
+      const r = insertKnotCurve(curCps, curKnots, degree, v);
+      curCps = r.cps;
+      curKnots = r.knots;
+      if (++guard > degree + 2) break;
+    }
+  }
+  const segVals = [0, ...breaks.slice().sort((a2, b) => a2 - b), 1];
+  const nSeg = segVals.length - 1;
+  const newCps = [];
+  for (let s = 0; s < nSeg; s++) {
+    const bez = curCps.slice(s * degree, s * degree + degree + 1);
+    const elevated = bezierElevate(bez, degree, t);
+    if (s === 0) newCps.push(...elevated);
+    else newCps.push(...elevated.slice(1));
+  }
+  const newKnots = [];
+  for (let i = 0; i <= targetDegree; i++) newKnots.push(0);
+  for (let s = 1; s < nSeg; s++) for (let i = 0; i < targetDegree; i++) newKnots.push(segVals[s]);
+  for (let i = 0; i <= targetDegree; i++) newKnots.push(1);
+  if (newKnots.length !== newCps.length + targetDegree + 1) {
+    throw new Error(
+      `Degree elevation produced inconsistent knots (${newKnots.length}) for ${newCps.length} control points at degree ${targetDegree}.`
+    );
+  }
+  return { cps: newCps, knots: newKnots, degree: targetDegree };
+}
+function unifyCurves(curves) {
+  const targetDeg = Math.max(...curves.map((c2) => c2.degree));
+  const elevated = curves.map((c2) => elevateCurveDegree(c2.cps, c2.knots, c2.degree, targetDeg));
+  const common = mergeKnotVectors(
+    elevated.map((c2) => c2.knots),
+    targetDeg
+  );
+  const refined = elevated.map((c2) => refineKnotsToTarget(c2.cps, c2.knots, targetDeg, common));
+  const ncp = common.length - targetDeg - 1;
+  for (const r of refined) {
+    if (r.cps.length !== ncp) throw new Error(`Curve unification produced ${r.cps.length} control points, expected ${ncp}.`);
+  }
+  return { degree: targetDeg, knots: common, curves: refined.map((r) => r.cps) };
+}
+function transpose(g2) {
+  const out = [];
+  for (let j = 0; j < g2[0].length; j++) {
+    const row = [];
+    for (let i = 0; i < g2.length; i++) row.push(g2[i][j]);
+    out.push(row);
+  }
+  return out;
+}
+function skin(curveCps, spanParams, spanDegree) {
+  const ncp = curveCps[0].length;
+  const cols = [];
+  for (let j = 0; j < ncp; j++) {
+    const pts = curveCps.map((row) => row[j]);
+    cols.push(globalCurveInterp(pts, spanDegree, spanParams).cps);
+  }
+  const spanCp = cols[0].length;
+  const grid = [];
+  for (let s = 0; s < spanCp; s++) {
+    const row = [];
+    for (let j = 0; j < ncp; j++) row.push(cols[j][s]);
+    grid.push(row);
+  }
+  const spanKnots = knotsFromParamsAveraging(spanParams, spanDegree);
+  return { grid, spanKnots };
+}
+function tensorInterp(gridPts, uParams, vParams, degreeU, degreeV) {
+  const rowInterp = gridPts.map((rowPts) => globalCurveInterp(rowPts, degreeV, vParams));
+  const knotsV = rowInterp[0].knots;
+  const ncpV = rowInterp[0].cps.length;
+  const cols = [];
+  for (let j = 0; j < ncpV; j++) {
+    const pts = rowInterp.map((ri) => ri.cps[j]);
+    cols.push(globalCurveInterp(pts, degreeU, uParams));
+  }
+  const knotsU = cols[0].knots;
+  const cpU = cols[0].cps.length;
+  const grid = [];
+  for (let i = 0; i < cpU; i++) {
+    const row = [];
+    for (let j = 0; j < ncpV; j++) row.push(cols[j].cps[i]);
+    grid.push(row);
+  }
+  return { grid, knotsU, knotsV };
+}
+function refineSurface(surf, targetKnotsU, targetKnotsV) {
+  const { grid, knotsU, knotsV, degreeU, degreeV } = surf;
+  const rows = grid.map((row) => refineKnotsToTarget(row, knotsV, degreeV, targetKnotsV).cps);
+  const ncpV = rows[0].length;
+  const cols = [];
+  for (let j = 0; j < ncpV; j++) {
+    const colPts = rows.map((r) => r[j]);
+    cols.push(refineKnotsToTarget(colPts, knotsU, degreeU, targetKnotsU).cps);
+  }
+  const cpU = cols[0].length;
+  const out = [];
+  for (let i = 0; i < cpU; i++) {
+    const row = [];
+    for (let j = 0; j < ncpV; j++) row.push(cols[j][i]);
+    out.push(row);
+  }
+  return { grid: out, knotsU: targetKnotsU, knotsV: targetKnotsV, degreeU, degreeV };
+}
+function averageParams(polylines, alpha = 0.5) {
+  const count = polylines[0].length;
+  const acc = new Array(count).fill(0);
+  for (const pl of polylines) {
+    const p2 = computeParamsCentripetal(pl, alpha);
+    for (let i = 0; i < count; i++) acc[i] += p2[i];
+  }
+  return acc.map((s) => s / polylines.length);
+}
+function gordonGridParams(gridPts) {
+  const rows = gridPts;
+  const cols = gridPts[0].map((_2, l) => gridPts.map((r) => r[l]));
+  return { vParams: averageParams(rows, 0.5), uParams: averageParams(cols, 0.5) };
+}
+function buildGordonFromGrid(gridPts, degreeU = 3, degreeV = 3) {
+  const m2 = gridPts.length - 1;
+  const n = gridPts[0].length - 1;
+  if (m2 < 1 || n < 1) throw new Error("A Gordon surface needs at least a 2x2 curve network.");
+  if (m2 < degreeU) degreeU = m2;
+  if (n < degreeV) degreeV = n;
+  const rows = gridPts;
+  const cols = gridPts[0].map((_2, l) => gridPts.map((r) => r[l]));
+  const { uParams, vParams } = gordonGridParams(gridPts);
+  const uCurves = rows.map((rowPts) => globalCurveInterp(rowPts, degreeV, vParams));
+  const vCurves = cols.map((colPts) => globalCurveInterp(colPts, degreeU, uParams));
+  const uFam = unifyCurves(uCurves);
+  const vFam = unifyCurves(vCurves);
+  const Lu = skin(uFam.curves, uParams, degreeU);
+  const LvRaw = skin(vFam.curves, vParams, degreeV);
+  const Lv = { grid: transpose(LvRaw.grid), knotsU: vFam.knots, knotsV: LvRaw.spanKnots };
+  const T = tensorInterp(gridPts, uParams, vParams, degreeU, degreeV);
+  const knotsU = mergeKnotVectors([Lu.spanKnots, Lv.knotsU, T.knotsU], degreeU);
+  const knotsV = mergeKnotVectors([uFam.knots, Lv.knotsV, T.knotsV], degreeV);
+  const LuS = refineSurface({ grid: Lu.grid, knotsU: Lu.spanKnots, knotsV: uFam.knots, degreeU, degreeV }, knotsU, knotsV);
+  const LvS = refineSurface({ grid: Lv.grid, knotsU: Lv.knotsU, knotsV: Lv.knotsV, degreeU, degreeV }, knotsU, knotsV);
+  const TS = refineSurface({ grid: T.grid, knotsU: T.knotsU, knotsV: T.knotsV, degreeU, degreeV }, knotsU, knotsV);
+  const nuc = LuS.grid.length;
+  const nvc = LuS.grid[0].length;
+  if (LvS.grid.length !== nuc || TS.grid.length !== nuc || LvS.grid[0].length !== nvc || TS.grid[0].length !== nvc) {
+    throw new Error(
+      `Gordon blend grid mismatch: Lu ${nuc}x${nvc}, Lv ${LvS.grid.length}x${LvS.grid[0].length}, T ${TS.grid.length}x${TS.grid[0].length}.`
+    );
+  }
+  const grid = [];
+  for (let i = 0; i < nuc; i++) {
+    const row = [];
+    for (let j = 0; j < nvc; j++) {
+      const a2 = LuS.grid[i][j];
+      const b = LvS.grid[i][j];
+      const c2 = TS.grid[i][j];
+      row.push([a2[0] + b[0] - c2[0], a2[1] + b[1] - c2[1], a2[2] + b[2] - c2[2]]);
+    }
+    grid.push(row);
+  }
+  return { grid, knotsU, knotsV, degreeU, degreeV };
+}
+function evalSurface(surf, u2, v) {
+  const { grid, knotsU, knotsV, degreeU, degreeV } = surf;
+  const nu = grid.length;
+  const nv = grid[0].length;
+  const su = findSpan(nu, degreeU, u2, knotsU);
+  const sv = findSpan(nv, degreeV, v, knotsV);
+  const Nu = basisFuns(su, u2, degreeU, knotsU);
+  const Nv = basisFuns(sv, v, degreeV, knotsV);
+  const out = [0, 0, 0];
+  for (let i = 0; i <= degreeU; i++) {
+    const ui = su - degreeU + i;
+    for (let j = 0; j <= degreeV; j++) {
+      const vj = sv - degreeV + j;
+      const w2 = Nu[i] * Nv[j];
+      const p2 = grid[ui][vj];
+      out[0] += w2 * p2[0];
+      out[1] += w2 * p2[1];
+      out[2] += w2 * p2[2];
+    }
+  }
+  return out;
+}
+function evalSurfaceJet(surf, u2, v) {
+  const { grid, knotsU, knotsV, degreeU, degreeV } = surf;
+  const nu = grid.length;
+  const nv = grid[0].length;
+  const su = findSpan(nu, degreeU, u2, knotsU);
+  const sv = findSpan(nv, degreeV, v, knotsV);
+  const dU = basisFunsDeriv(su, u2, degreeU, knotsU, 2);
+  const dV = basisFunsDeriv(sv, v, degreeV, knotsV, 2);
+  const S = [0, 0, 0];
+  const Su = [0, 0, 0];
+  const Sv = [0, 0, 0];
+  const Suu = [0, 0, 0];
+  const Suv = [0, 0, 0];
+  const Svv = [0, 0, 0];
+  for (let i = 0; i <= degreeU; i++) {
+    const ui = su - degreeU + i;
+    for (let j = 0; j <= degreeV; j++) {
+      const vj = sv - degreeV + j;
+      const p2 = grid[ui][vj];
+      const w00 = dU[0][i] * dV[0][j];
+      const w10 = dU[1][i] * dV[0][j];
+      const w01 = dU[0][i] * dV[1][j];
+      const w20 = dU[2][i] * dV[0][j];
+      const w11 = dU[1][i] * dV[1][j];
+      const w02 = dU[0][i] * dV[2][j];
+      for (let c2 = 0; c2 < 3; c2++) {
+        S[c2] += w00 * p2[c2];
+        Su[c2] += w10 * p2[c2];
+        Sv[c2] += w01 * p2[c2];
+        Suu[c2] += w20 * p2[c2];
+        Suv[c2] += w11 * p2[c2];
+        Svv[c2] += w02 * p2[c2];
+      }
+    }
+  }
+  let nx = Su[1] * Sv[2] - Su[2] * Sv[1];
+  let ny = Su[2] * Sv[0] - Su[0] * Sv[2];
+  let nz = Su[0] * Sv[1] - Su[1] * Sv[0];
+  const len2 = Math.hypot(nx, ny, nz) || 1;
+  nx /= len2;
+  ny /= len2;
+  nz /= len2;
+  return { S, Su, Sv, Suu, Suv, Svv, normal: [nx, ny, nz] };
+}
+function surfaceCurvature(jet) {
+  const { Su, Sv, Suu, Suv, Svv, normal } = 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] * normal[0] + Suu[1] * normal[1] + Suu[2] * normal[2];
+  const f3 = Suv[0] * normal[0] + Suv[1] * normal[1] + Suv[2] * normal[2];
+  const g2 = Svv[0] * normal[0] + Svv[1] * normal[1] + Svv[2] * normal[2];
+  const denom = E * G - F * F;
+  if (Math.abs(denom) < 1e-20) return { k1: 0, k2: 0, K: 0, H: 0 };
+  const K = (e * g2 - f3 * f3) / denom;
+  const H = (e * G - 2 * f3 * F + g2 * E) / (2 * denom);
+  const disc = Math.max(0, H * H - K);
+  const root = Math.sqrt(disc);
+  return { k1: H + root, k2: H - root, K, H };
+}
+function isVec3(v) {
+  return Array.isArray(v) && v.length === 3 && typeof v[0] === "number" && typeof v[1] === "number" && typeof v[2] === "number";
+}
+function requireFiniteVec(p2, label) {
+  for (let i = 0; i < 3; i++)
+    if (!Number.isFinite(p2[i])) throw new Error(`Surface.Net: ${label} component ${i} must be finite, got ${p2[i]}`);
+  return [p2[0], p2[1], p2[2]];
+}
+function toSampler(input, label) {
+  if (input instanceof NurbsCurve3D) {
+    return (t) => input.pointAt(t);
+  }
+  if (Array.isArray(input) && input.length > 0 && isVec3(input[0])) {
+    const pts = input.map((p2, i) => requireFiniteVec(p2, `${label}[${i}]`));
+    if (pts.length < 2) throw new Error(`Surface.Net: ${label} needs at least 2 points.`);
+    if (pts.length === 2) {
+      const [a2, b] = pts;
+      return (t) => [a2[0] + (b[0] - a2[0]) * t, a2[1] + (b[1] - a2[1]) * t, a2[2] + (b[2] - a2[2]) * t];
+    }
+    const curve = globalCurveInterp(pts, Math.min(3, pts.length - 1));
+    const nc = new NurbsCurve3D(curve.cps, { degree: curve.degree, knots: curve.knots });
+    return (t) => nc.pointAt(t);
+  }
+  throw new Error(`Surface.Net: ${label} must be a Curve.Fit/Curve.Nurbs value or an array of [x,y,z] points.`);
+}
+function sampleCurve(sampler, count) {
+  const out = [];
+  for (let i = 0; i < count; i++) out.push(sampler(i / (count - 1)));
+  return out;
+}
+const DEFAULT_THICKEN_RESOLUTION = 48;
+class Sheet {
+  constructor(surface) {
+    this.surface = surface;
+  }
+  /** Edge naming follows parameter direction (documented): front=v0, rear=v1, left=u0, right=u1. */
+  get frontEdge() {
+    return { sheet: this, fixed: "v", value: 0 };
+  }
+  get rearEdge() {
+    return { sheet: this, fixed: "v", value: 1 };
+  }
+  get leftEdge() {
+    return { sheet: this, fixed: "u", value: 0 };
+  }
+  get rightEdge() {
+    return { sheet: this, fixed: "u", value: 1 };
+  }
+  pointAt(u2, v) {
+    return evalSurface(this.surface, clamp01(u2), clamp01(v));
+  }
+  normalAt(u2, v) {
+    return evalSurfaceJet(this.surface, clamp01(u2), clamp01(v)).normal;
+  }
+  curvatureAt(u2, v) {
+    return surfaceCurvature(evalSurfaceJet(this.surface, clamp01(u2), clamp01(v)));
+  }
+  /** Largest principal curvature magnitude over a sampling grid (for offset safety). */
+  maxAbsPrincipalCurvature(samples = 9) {
+    let maxK = 0;
+    for (let i = 0; i <= samples; i++) {
+      for (let j = 0; j <= samples; j++) {
+        const c2 = this.curvatureAt(i / samples, j / samples);
+        maxK = Math.max(maxK, Math.abs(c2.k1), Math.abs(c2.k2));
+      }
+    }
+    return maxK;
+  }
+  /**
+   * Offset the sheet along its analytic normals into a watertight solid shell of
+   * the given wall thickness. Throws if the wall would self-intersect on a
+   * concave region (no silent degenerate solid).
+   */
+  thicken(wall, options = {}) {
+    if (!Number.isFinite(wall) || wall <= 0) throw new Error(`Sheet.thicken: wall must be a positive finite number, got ${wall}`);
+    const maxK = this.maxAbsPrincipalCurvature();
+    if (wall * maxK >= 1) {
+      throw new Error(
+        `Sheet.thicken: wall ${wall} exceeds the minimum radius of curvature (1/${maxK.toFixed(4)} = ${(1 / maxK).toFixed(3)}). The offset surface would self-intersect. Reduce the wall thickness or relax the curvature.`
+      );
+    }
+    const resolution = options.resolution ?? DEFAULT_THICKEN_RESOLUTION;
+    return nurbsSurface(this.surface.grid, {
+      degreeU: this.surface.degreeU,
+      degreeV: this.surface.degreeV,
+      knotsU: this.surface.knotsU,
+      knotsV: this.surface.knotsV,
+      thickness: wall,
+      resolution
+    });
+  }
+  /** Per-edge continuity match against a neighbor (returns a NEW Sheet). */
+  matchEdge(edge) {
+    if (edge.sheet !== this) throw new Error("Sheet.matchEdge: the edge must belong to this sheet.");
+    return new MatchEdgeBuilder(this, edge);
+  }
+}
+function clamp01(t) {
+  return t < 0 ? 0 : t > 1 ? 1 : t;
+}
+class CurveNetBuilder {
+  constructor() {
+    __publicField(this, "lengthwiseCurves", []);
+    __publicField(this, "crosswiseCurves", []);
+    __publicField(this, "railCurves", []);
+    __publicField(this, "cageGrid", null);
+    __publicField(this, "degU");
+    __publicField(this, "degV");
+    __publicField(this, "built", null);
+  }
+  lengthwise(...curves) {
+    this.lengthwiseCurves = curves;
+    this.built = null;
+    return this;
+  }
+  crosswise(...curves) {
+    this.crosswiseCurves = curves;
+    this.built = null;
+    return this;
+  }
+  alongRails(railA, railB) {
+    this.railCurves = [railA, railB];
+    this.built = null;
+    return this;
+  }
+  sections(...curves) {
+    this.crosswiseCurves = curves;
+    this.built = null;
+    return this;
+  }
+  cage(grid) {
+    if (!Array.isArray(grid) || grid.length < 2 || !Array.isArray(grid[0]) || grid[0].length < 2) {
+      throw new Error("Surface.Net().cage: grid must be at least a 2x2 array of [x,y,z] points.");
+    }
+    const cols = grid[0].length;
+    this.cageGrid = grid.map((row, k2) => {
+      if (row.length !== cols) throw new Error(`Surface.Net().cage: row ${k2} has ${row.length} points, expected ${cols}.`);
+      return row.map((p2, l) => requireFiniteVec(p2, `cage[${k2}][${l}]`));
+    });
+    this.built = null;
+    return this;
+  }
+  degree(u2, v) {
+    if (!Number.isInteger(u2) || u2 < 1) throw new Error(`Surface.Net().degree: degree must be a positive integer, got ${u2}`);
+    this.degU = u2;
+    this.degV = v === void 0 ? u2 : v;
+    if (v !== void 0 && (!Number.isInteger(v) || v < 1))
+      throw new Error(`Surface.Net().degree: degree must be a positive integer, got ${v}`);
+    this.built = null;
+    return this;
+  }
+  /** Build (once) and return the Sheet. */
+  toSheet() {
+    if (this.built) return this.built;
+    const grid = this.buildGrid();
+    const m2 = grid.length - 1;
+    const n = grid[0].length - 1;
+    const degreeU = Math.max(1, Math.min(this.degU ?? 3, m2));
+    const degreeV = Math.max(1, Math.min(this.degV ?? 3, n));
+    const surface = buildGordonFromGrid(grid, degreeU, degreeV);
+    this.built = new Sheet(surface);
+    return this.built;
+  }
+  buildGrid() {
+    if (this.cageGrid) return this.cageGrid;
+    const lengthwise = this.railCurves.length > 0 ? this.railCurves : this.lengthwiseCurves;
+    const crosswise = this.crosswiseCurves;
+    const SAMPLES = 17;
+    if (lengthwise.length >= 2) {
+      const samplers = lengthwise.map((c2, l) => toSampler(c2, `lengthwise[${l}]`));
+      const grid = [];
+      for (let i = 0; i < SAMPLES; i++) {
+        const u2 = i / (SAMPLES - 1);
+        grid.push(samplers.map((s) => s(u2)));
+      }
+      return grid;
+    }
+    if (crosswise.length >= 2) {
+      const samplers = crosswise.map((c2, k2) => toSampler(c2, `crosswise[${k2}]`));
+      const grid = [];
+      for (const s of samplers) grid.push(sampleCurve(s, SAMPLES));
+      return grid;
+    }
+    throw new Error(
+      "Surface.Net: provide a .cage(grid), or a family of at least 2 curves via .lengthwise(...) / .crosswise(...) / .alongRails(a,b).sections(...). Intersecting two independent hand-drawn families is not available yet — supply the denser family or a cage."
+    );
+  }
+  // ── Sheet delegation (build on first access) ──────────────────────────────
+  get frontEdge() {
+    return this.toSheet().frontEdge;
+  }
+  get rearEdge() {
+    return this.toSheet().rearEdge;
+  }
+  get leftEdge() {
+    return this.toSheet().leftEdge;
+  }
+  get rightEdge() {
+    return this.toSheet().rightEdge;
+  }
+  get surface() {
+    return this.toSheet().surface;
+  }
+  pointAt(u2, v) {
+    return this.toSheet().pointAt(u2, v);
+  }
+  normalAt(u2, v) {
+    return this.toSheet().normalAt(u2, v);
+  }
+  curvatureAt(u2, v) {
+    return this.toSheet().curvatureAt(u2, v);
+  }
+  thicken(wall, options) {
+    return this.toSheet().thicken(wall, options);
+  }
+  matchEdge(edge) {
+    return this.toSheet().matchEdge(edge);
+  }
+}
+function createCurveNet() {
+  return new CurveNetBuilder();
+}
+class MatchEdgeBuilder {
+  constructor(sheet, edge) {
+    this.sheet = sheet;
+    this.edge = edge;
+  }
+  toG0(neighbor) {
+    return applyEdgeMatch(this.sheet, this.edge, neighbor, 0);
+  }
+  toG1(neighbor) {
+    return applyEdgeMatch(this.sheet, this.edge, neighbor, 1);
+  }
+  toG2(neighbor) {
+    return applyEdgeMatch(this.sheet, this.edge, neighbor, 2);
+  }
+}
+function boundaryRows(surf, fixed, value, depth) {
+  const rows = [];
+  if (fixed === "u") {
+    const nU = surf.grid.length;
+    for (let d2 = 0; d2 <= depth; d2++) {
+      const i = value === 0 ? d2 : nU - 1 - d2;
+      rows.push(surf.grid[i].map((p2) => [p2[0], p2[1], p2[2]]));
+    }
+  } else {
+    const nV = surf.grid[0].length;
+    for (let d2 = 0; d2 <= depth; d2++) {
+      const j = value === 0 ? d2 : nV - 1 - d2;
+      rows.push(surf.grid.map((p2) => [p2[j][0], p2[j][1], p2[j][2]]));
+    }
+  }
+  return rows;
+}
+function setBoundaryRow(surf, fixed, value, depth, row) {
+  if (fixed === "u") {
+    const nU = surf.grid.length;
+    const i = value === 0 ? depth : nU - 1 - depth;
+    for (let l = 0; l < surf.grid[i].length; l++) surf.grid[i][l] = [row[l][0], row[l][1], row[l][2]];
+  } else {
+    const nV = surf.grid[0].length;
+    const j = value === 0 ? depth : nV - 1 - depth;
+    for (let k2 = 0; k2 < surf.grid.length; k2++) surf.grid[k2][j] = [row[k2][0], row[k2][1], row[k2][2]];
+  }
+}
+function cloneSurface(surf) {
+  return {
+    grid: surf.grid.map((row) => row.map((p2) => [p2[0], p2[1], p2[2]])),
+    knotsU: [...surf.knotsU],
+    knotsV: [...surf.knotsV],
+    degreeU: surf.degreeU,
+    degreeV: surf.degreeV
+  };
+}
+function applyEdgeMatch(sheet, edge, neighbor, order) {
+  const result = cloneSurface(sheet.surface);
+  const my = boundaryRows(result, edge.fixed, edge.value, order);
+  const their = boundaryRows(neighbor.sheet.surface, neighbor.fixed, neighbor.value, order);
+  if (my[0].length !== their[0].length) {
+    throw new Error(
+      `Sheet.matchEdge: edge control-point counts differ (${my[0].length} vs ${their[0].length}). Both sheets must share section sampling along the matched edge for continuity.`
+    );
+  }
+  const len2 = my[0].length;
+  const b0 = their[0].map((p2) => [p2[0], p2[1], p2[2]]);
+  setBoundaryRow(result, edge.fixed, edge.value, 0, b0);
+  if (order === 0) return new Sheet(result);
+  const b1 = [];
+  for (let i = 0; i < len2; i++) {
+    const p0 = their[0][i];
+    const p1 = their[1][i];
+    b1.push([2 * p0[0] - p1[0], 2 * p0[1] - p1[1], 2 * p0[2] - p1[2]]);
+  }
+  setBoundaryRow(result, edge.fixed, edge.value, 1, b1);
+  if (order === 1) return new Sheet(result);
+  const b22 = [];
+  for (let i = 0; i < len2; i++) {
+    const p0 = their[0][i];
+    const p1 = their[1][i];
+    const p2 = their[2][i];
+    b22.push([3 * p0[0] - 3 * p1[0] + p2[0], 3 * p0[1] - 3 * p1[1] + p2[1], 3 * p0[2] - 3 * p1[2] + p2[2]]);
+  }
+  setBoundaryRow(result, edge.fixed, edge.value, 2, b22);
+  return new Sheet(result);
+}
+function edgeJet(edge, t) {
+  const surf = edge.sheet.surface;
+  if (edge.fixed === "u") {
+    const j2 = evalSurfaceJet(surf, edge.value, clamp01(t));
+    return { point: j2.S, cross: j2.Su, cross2: j2.Suu };
+  }
+  const j = evalSurfaceJet(surf, clamp01(t), edge.value);
+  return { point: j.S, cross: j.Sv, cross2: j.Svv };
+}
+function sub3(a2, b) {
+  return [a2[0] - b[0], a2[1] - b[1], a2[2] - b[2]];
+}
+function len3(a2) {
+  return Math.hypot(a2[0], a2[1], a2[2]);
+}
+function unit3(a2) {
+  const l = len3(a2) || 1;
+  return [a2[0] / l, a2[1] / l, a2[2] / l];
+}
+function edgeMatchReport(edgeA, edgeB, samples = 24) {
+  let maxPositionGap = 0;
+  let maxTangentAngleDeg = 0;
+  let maxCurvatureRelErr = 0;
+  for (let i = 0; i <= samples; i++) {
+    const t = i / samples;
+    const a2 = edgeJet(edgeA, t);
+    const b = edgeJet(edgeB, t);
+    maxPositionGap = Math.max(maxPositionGap, len3(sub3(a2.point, b.point)));
+    const ua = unit3(a2.cross);
+    const ub = unit3(b.cross);
+    const dot2 = Math.max(-1, Math.min(1, ua[0] * ub[0] + ua[1] * ub[1] + ua[2] * ub[2]));
+    const angle = Math.acos(Math.abs(dot2)) * 180 / Math.PI;
+    maxTangentAngleDeg = Math.max(maxTangentAngleDeg, angle);
+    const la = len3(a2.cross) ** 2 || 1;
+    const lb = len3(b.cross) ** 2 || 1;
+    const ka = (a2.cross2[0] * ua[0] + a2.cross2[1] * ua[1] + a2.cross2[2] * ua[2]) / la;
+    const kb = (b.cross2[0] * ub[0] + b.cross2[1] * ub[1] + b.cross2[2] * ub[2]) / lb;
+    maxCurvatureRelErr = Math.max(maxCurvatureRelErr, Math.abs(ka - kb) / (Math.abs(ka) + Math.abs(kb) + 1e-9));
+  }
+  return { maxPositionGap, maxTangentAngleDeg, maxCurvatureRelErr };
+}
+function bridgeBetween(edgeA, edgeB) {
+  return new BridgeBuilder(edgeA, edgeB);
+}
+class BridgeBuilder {
+  constructor(edgeA, edgeB) {
+    __publicField(this, "bulgeA", 0.5);
+    __publicField(this, "bulgeB", 0.5);
+    this.edgeA = edgeA;
+    this.edgeB = edgeB;
+  }
+  /** Tune the influence of each side (Rhino-style bulge). */
+  bulge(a2, b) {
+    if (!Number.isFinite(a2) || !Number.isFinite(b)) throw new Error("Surfaces.bridge.bulge: both factors must be finite.");
+    this.bulgeA = a2;
+    this.bulgeB = b;
+    return this;
+  }
+  g0() {
+    return this.build(0);
+  }
+  g1() {
+    return this.build(1);
+  }
+  g2() {
+    return this.build(2);
+  }
+  build(order) {
+    const SAMPLES = 21;
+    const CROSS = 11;
+    const cage = [];
+    for (let i = 0; i < SAMPLES; i++) {
+      const t = i / (SAMPLES - 1);
+      const a2 = edgeJet(this.edgeA, t);
+      const b = edgeJet(this.edgeB, t);
+      const chord = len3(sub3(b.point, a2.point));
+      const toward = unit3(sub3(b.point, a2.point));
+      const tA = orientToward(unit3(a2.cross), toward);
+      const tB = orientToward(unit3(b.cross), [-toward[0], -toward[1], -toward[2]]);
+      const poles = bridgePoles(a2.point, b.point, tA, tB, chord, this.bulgeA, this.bulgeB, order);
+      const row = [];
+      for (let c2 = 0; c2 < CROSS; c2++) row.push(deCasteljau(poles, c2 / (CROSS - 1)));
+      cage.push(row);
+    }
+    return new CurveNetBuilder().cage(cage).degree(Math.min(3, SAMPLES - 1), Math.min(2 * order + 1 || 1, CROSS - 1)).toSheet();
+  }
+}
+function orientToward(v, toward) {
+  const dot2 = v[0] * toward[0] + v[1] * toward[1] + v[2] * toward[2];
+  return dot2 < 0 ? [-v[0], -v[1], -v[2]] : v;
+}
+function bridgePoles(a2, b, tA, tB, chord, bulgeA, bulgeB, order) {
+  if (order === 0) return [a2, b];
+  const dA = chord * bulgeA / (order === 1 ? 3 : 5);
+  const dB = chord * bulgeB / (order === 1 ? 3 : 5);
+  const a1 = [a2[0] + tA[0] * dA, a2[1] + tA[1] * dA, a2[2] + tA[2] * dA];
+  const b1 = [b[0] + tB[0] * dB, b[1] + tB[1] * dB, b[2] + tB[2] * dB];
+  if (order === 1) return [a2, a1, b1, b];
+  const a22 = [a1[0] + tA[0] * dA, a1[1] + tA[1] * dA, a1[2] + tA[2] * dA];
+  const b22 = [b1[0] + tB[0] * dB, b1[1] + tB[1] * dB, b1[2] + tB[2] * dB];
+  return [a2, a1, a22, b22, b1, b];
+}
+function deCasteljau(poles, s) {
+  let pts = poles.map((p2) => [p2[0], p2[1], p2[2]]);
+  while (pts.length > 1) {
+    const next = [];
+    for (let i = 0; i < pts.length - 1; i++) {
+      next.push([
+        pts[i][0] + (pts[i + 1][0] - pts[i][0]) * s,
+        pts[i][1] + (pts[i + 1][1] - pts[i][1]) * s,
+        pts[i][2] + (pts[i + 1][2] - pts[i][2]) * s
+      ]);
+    }
+    pts = next;
+  }
+  return pts[0];
+}
 const CORNER_Y_ALPHA_ISSUE_URL = "https://github.com/KoStard/forgecad-private/issues/162";
 function isVec3Array(value) {
   return Array.isArray(value) && (value.length === 0 || Array.isArray(value[0]));
@@ -95503,7 +96189,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) {
@@ -95523,6 +96218,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.
@@ -95557,6 +96260,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);
@@ -99001,22 +99712,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();
@@ -100189,7 +100888,6 @@ function resetExecutionSession(logs) {
   resetHighlights();
   resetBom();
   resetSheetStock();
-  resetRobotExport();
   resetCutPlanes();
   resetRenderLabels();
   resetCameraTrajectory();
@@ -100272,7 +100970,6 @@ function collectSuccessfulExecutionSnapshot(args) {
     jointsView: getCollectedJointsView(),
     viewConfig: getCollectedViewConfig(),
     sceneConfig: getCollectedScene(),
-    robotExport: getCollectedRobotExport(),
     quality: args.quality,
     logs: args.logs.slice(),
     verifications: getCollectedVerifications(),
@@ -100297,7 +100994,6 @@ function collectFailedExecutionSnapshot(args) {
     jointsView: getCollectedJointsView(),
     viewConfig: getCollectedViewConfig(),
     sceneConfig: getCollectedScene(),
-    robotExport: getCollectedRobotExport(),
     quality: args.quality,
     logs: args.logs.slice(),
     verifications: getCollectedVerifications(),
@@ -312858,7 +313554,6 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       sketchToDxf,
       bom,
       sheetStock,
-      robotExport,
       Sim,
       group,
       ShapeGroup,