forgecad 0.10.2 → 0.10.3

package/dist-cli/{chunk-RQQ42YCP.js → chunk-WLUKAW3H.js}

@@ -10475,7 +10475,7 @@ async function initTruckGeometryWasm() {
   if (_initPromise) return _initPromise;
   _initPromise = (async () => {
     try {
-      const geometryModule = await import("./forgecad_geometry-7TVSNVUB.js");
+      const geometryModule = await import("./forgecad_geometry-2IMYCUWW.js");
       const isNode = isNodeRuntime();
       if (isNode) {
         const { readFileSync: readFileSync3, existsSync: existsSync3 } = await import("fs");
@@ -11427,23 +11427,62 @@ var NurbsSurface = class {
     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(u, v) {
-    const eps = 1e-5;
-    const u0 = Math.max(0, u - eps), u1 = Math.min(1, u + eps);
-    const v0 = Math.max(0, v - eps), v1 = Math.min(1, v + eps);
-    const pu = this.pointAt(u1, v), pmu = this.pointAt(u0, v);
-    const pv = this.pointAt(u, v1), pmv = this.pointAt(u, v0);
-    const du = [pu[0] - pmu[0], pu[1] - pmu[1], pu[2] - pmu[2]];
-    const dv = [pv[0] - pmv[0], pv[1] - pmv[1], pv[2] - pmv[2]];
-    const nx = du[1] * dv[2] - du[2] * dv[1];
-    const ny = du[2] * dv[0] - du[0] * dv[2];
-    const nz = du[0] * dv[1] - du[1] * dv[0];
+    const { Su, Sv } = this.derivativesAt(u, 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(u, v) {
+    const uu = this.remapU(Math.max(0, Math.min(1, u)));
+    const vv = this.remapV(Math.max(0, Math.min(1, v)));
+    const spanU = findSpan(this.nU, this.degreeU, uu, this.knotsU);
+    const spanV = findSpan(this.nV, this.degreeV, vv, this.knotsV);
+    const 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 w = 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;
+        w += n00;
+        wu += n10;
+        wv += n01;
+        for (let c = 0; c < 3; c++) {
+          A[c] += n00 * pt[c];
+          Au[c] += n10 * pt[c];
+          Av[c] += n01 * pt[c];
+        }
+      }
+    }
+    if (w === 0) return { S: [0, 0, 0], Su: [0, 0, 0], Sv: [0, 0, 0] };
+    const invW = 1 / w;
+    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.
@@ -13889,6 +13928,20 @@ function fromSlicesSingleSliceHalfExtentForManifold(plan) {
   }
   return Math.max(1, radius + maxOffsetMagnitude + plan.boundsPadding + plan.edgeLength * 3);
 }
+var 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) {
@@ -13897,16 +13950,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);
   }
 }
@@ -15258,12 +15313,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 [x, y, z] of positions) allPositions.push(x, y, z);
+  const vertProps = [];
   for (let i = 0; i < numVerts; i++) {
     const [x, y, z] = positions[i];
     const [nx, ny, nz] = normals[i];
-    allPositions.push(x - nx * thickness, y - ny * thickness, z - nz * thickness);
+    vertProps.push(x, y, z, nx, ny, nz);
+  }
+  for (let i = 0; i < numVerts; i++) {
+    const [x, y, z] = positions[i];
+    const [nx, ny, nz] = normals[i];
+    vertProps.push(x - nx * thickness, y - ny * thickness, z - nz * thickness, -nx, -ny, -nz);
   }
   const allIndices = [];
   for (const idx of indices) allIndices.push(idx);
@@ -15288,11 +15347,12 @@ function lowerNurbsSurfaceToManifold(plan, wasm) {
     allIndices.push(c, c + numVerts, d, d, c + numVerts, d + 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);
@@ -37311,6 +37371,7 @@ var 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,
@@ -37324,7 +37385,8 @@ var 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;
   }
@@ -38540,6 +38602,16 @@ function boundsInteriorOverlap2(a, b) {
   const tolerance = 1e-8;
   return Math.min(a.max[0], b.max[0]) - Math.max(a.min[0], b.min[0]) > tolerance && Math.min(a.max[1], b.max[1]) - Math.max(a.min[1], b.min[1]) > tolerance && Math.min(a.max[2], b.max[2]) - Math.max(a.min[2], b.min[2]) > tolerance;
 }
+function boundsFaceOrInteriorOverlap(a, b) {
+  const tolerance = 1e-8;
+  const overlaps = [
+    Math.min(a.max[0], b.max[0]) - Math.max(a.min[0], b.min[0]),
+    Math.min(a.max[1], b.max[1]) - Math.max(a.min[1], b.min[1]),
+    Math.min(a.max[2], b.max[2]) - Math.max(a.min[2], b.min[2])
+  ];
+  if (overlaps.some((overlap) => overlap < -tolerance)) return false;
+  return overlaps.filter((overlap) => overlap <= tolerance).length <= 1;
+}
 function boundsFromPoints3(points) {
   const first = points[0];
   if (!first) return null;
@@ -38622,16 +38694,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 (boundsInteriorOverlap2(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 = [];
@@ -38645,7 +38717,7 @@ function interiorOverlapComponents(shapes) {
       component.push(current);
       for (let next = 0; next < shapes.length; next++) {
         if (visited.has(next)) continue;
-        if (boundsInteriorOverlap2(bounds[current], bounds[next])) {
+        if (boundsFaceOrInteriorOverlap(bounds[current], bounds[next])) {
           visited.add(next);
           queue.push(next);
         }
@@ -38690,10 +38762,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;
@@ -39219,9 +39291,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) {
@@ -41105,7 +41181,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 {
@@ -52512,8 +52588,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 {
@@ -52524,8 +52599,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 {
@@ -52537,8 +52611,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 {
@@ -52549,8 +52622,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 {
@@ -52561,8 +52633,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 } }
+        ]
       };
   }
 }
@@ -54395,7 +54466,7 @@ var Shape2 = 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**
    *
@@ -59063,8 +59134,8 @@ var Assembly = 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
    */
@@ -70553,7 +70624,8 @@ var FrozenShape = class extends Shape2 {
 var EDGE_THRESHOLD_DOT2 = Math.cos(Math.PI / 180);
 var 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);
@@ -70585,7 +70657,9 @@ function computeGeometryArrays(mesh, options = {}) {
     positions[o + 6] = cx;
     positions[o + 7] = cy;
     positions[o + 8] = cz;
-    if (vertNormals) {
+    if (useCornerNormals) {
+      for (let k = 0; k < 9; k++) normals[o + k] = cornerNormals[o + k];
+    } else if (vertNormals) {
       normals[o] = vertNormals[i0 * 3];
       normals[o + 1] = vertNormals[i0 * 3 + 1];
       normals[o + 2] = vertNormals[i0 * 3 + 2];
@@ -70628,7 +70702,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,
@@ -70817,7 +70891,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));
@@ -72464,31 +72539,6 @@ function validateFog(fog, label) {
   if (fog.density !== void 0) out.density = requireFinite7(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 = requireFinite7(pp.bloom.intensity, `${label}.bloom.intensity`);
-    if (pp.bloom.threshold !== void 0) out.bloom.threshold = requireFinite7(pp.bloom.threshold, `${label}.bloom.threshold`);
-    if (pp.bloom.radius !== void 0) out.bloom.radius = requireFinite7(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 = requireFinite7(pp.vignette.darkness, `${label}.vignette.darkness`);
-    if (pp.vignette.offset !== void 0) out.vignette.offset = requireFinite7(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 = requireFinite7(pp.grain.intensity, `${label}.grain.intensity`);
-  }
-  if (pp.toneMappingExposure !== void 0) {
-    out.toneMappingExposure = requireFinite7(pp.toneMappingExposure, `${label}.toneMappingExposure`);
-  }
-  return out;
-}
 function validateGround(ground, label) {
   const out = {};
   if (ground.visible !== void 0) {
@@ -72570,7 +72620,6 @@ function scene(options) {
     lights: null,
     environment: null,
     fog: null,
-    postProcessing: null,
     ground: null,
     capture: null
   };
@@ -72610,12 +72659,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") {
@@ -73518,8 +73564,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;
   }
@@ -73765,8 +73810,8 @@ function shapeBoundsCenter(shape) {
   ];
 }
 var ProductSurfaceRef = class _ProductSurfaceRef {
-  constructor(skin, query, name) {
-    this.skin = skin;
+  constructor(skin2, query, name) {
+    this.skin = skin2;
     this.query = query;
     this.name = name;
   }
@@ -74283,8 +74328,8 @@ var ProductHandleBuilder = class {
   }
 };
 var ProductSurfaceBuilder = class {
-  constructor(skin, side) {
-    this.skin = skin;
+  constructor(skin2, side) {
+    this.skin = skin2;
     this.side = side;
   }
   /** Create a ref on this skin side. */
@@ -74352,9 +74397,9 @@ var ProductRibbonBuilder = class {
    * 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);
@@ -74477,7 +74522,7 @@ var ProductRibbonBuilder = class {
     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") {
@@ -74496,7 +74541,7 @@ var ProductRibbonBuilder = class {
     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;
@@ -74513,13 +74558,13 @@ var ProductRibbonBuilder = class {
           u,
           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,
@@ -74676,16 +74721,16 @@ var 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) {
@@ -75166,8 +75211,8 @@ function coordinateOnSide(coordinate, side, label) {
   return { ...coordinate, kind: "productSkin", side };
 }
 var ProductSkinCarrier = class _ProductSkinCarrier {
-  constructor(skin, name = skin.name, sideValue2, offsetValue = 0) {
-    this.skin = skin;
+  constructor(skin2, name = skin2.name, sideValue2, offsetValue = 0) {
+    this.skin = skin2;
     this.name = name;
     this.sideValue = sideValue2;
     this.offsetValue = offsetValue;
@@ -78108,8 +78153,8 @@ var 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) {
@@ -78829,9 +78874,9 @@ function pickDimensionOffsetBasis(dirModel, frame) {
   ];
   const candidates = [];
   const pushCandidate = (candidate) => {
-    const len34 = Math.hypot(candidate[0], candidate[1], candidate[2]);
-    if (len34 < 1e-8) return;
-    const dir3 = [candidate[0] / len34, candidate[1] / len34, candidate[2] / len34];
+    const len35 = Math.hypot(candidate[0], candidate[1], candidate[2]);
+    if (len35 < 1e-8) return;
+    const dir3 = [candidate[0] / len35, candidate[1] / len35, candidate[2] / len35];
     const proj = projectVectorToView(dir3, frame);
     const projLen = Math.hypot(proj[0], proj[1]);
     if (projLen < 1e-6) return;
@@ -80010,8 +80055,7 @@ function generateReportPdf(result, options = {}) {
   };
 }
 
-// src/forge/export/robotExport.ts
-var _collectedRobotExport = null;
+// src/forge/export/simulationModel.ts
 function cloneLinkOptions(input) {
   if (!input) return {};
   return Object.fromEntries(Object.entries(input).map(([name, opts]) => [name, { ...opts }]));
@@ -80098,12 +80142,6 @@ function diffDriveFromControllers(controllers) {
     angularAcceleration: diffDrive2.angularAcceleration
   } : void 0;
 }
-function resetRobotExport() {
-  _collectedRobotExport = null;
-}
-function getCollectedRobotExport() {
-  return _collectedRobotExport;
-}
 function collectSimulationModel(assemblyInput, options = {}) {
   const assembly2 = typeof assemblyInput.describe === "function" ? assemblyInput.describe() : assemblyInput;
   const partNames = new Set(assembly2.parts.map((part) => part.name));
@@ -80186,7 +80224,6 @@ function collectSimulationModel(assemblyInput, options = {}) {
     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,
@@ -80200,24 +80237,11 @@ function collectSimulationModel(assemblyInput, options = {}) {
     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;
-}
 
 // src/forge/export/simreadyValidation.ts
 function error(findings, code, message, path2) {
   findings.push({ level: "error", code, message, path: path2 });
 }
-function warn(findings, code, message, path2) {
-  findings.push({ level: "warning", code, message, path: path2 });
-}
 function isFiniteNumber3(value) {
   return value === void 0 || Number.isFinite(value);
 }
@@ -80242,13 +80266,13 @@ function profileRequiresExplicitCollider(model) {
 }
 function validatePart(findings, model, part) {
   const link = model.links[part.name];
-  const hasLegacyPhysicalData = link?.massKg !== void 0 || link?.densityKgM3 !== void 0;
+  const hasPhysicalData = link?.massKg !== void 0 || link?.densityKgM3 !== void 0;
   const path2 = `parts.${part.name}`;
-  if (!part.sim && !hasLegacyPhysicalData) {
+  if (!part.sim && !hasPhysicalData) {
     error(
       findings,
       "SIM.BODY.MISSING",
-      `Part "${part.name}" needs Sim.body(...) metadata or legacy massKg/densityKgM3 export metadata.`,
+      `Part "${part.name}" needs Sim.body(...) metadata with massKg or densityKgM3.`,
       path2
     );
     return;
@@ -80383,17 +80407,9 @@ function validateWorld(findings, model) {
 function validateSimulationModel(model) {
   const findings = [];
   const simulation = model.simulation;
-  if (!simulation && model.source !== "robotExport") {
+  if (!simulation) {
     error(findings, "SIM.SIMULATION.MISSING", "Model must return assembly(...).withSimulation(...).", "sim");
   }
-  if (!simulation && model.source === "robotExport") {
-    warn(
-      findings,
-      "SIM.SIMULATION.LEGACY_ROBOT_EXPORT",
-      "Legacy robotExport(...) metadata is accepted for compatibility; prefer assembly.withSimulation(...).",
-      "sim"
-    );
-  }
   if (simulation && !simulation.profile) {
     error(findings, "SIM.PROFILE.MISSING", "Simulation contract needs a Sim.profile.*() value.", "sim.profile");
   }
@@ -80438,7 +80454,7 @@ function materialManifest(material2) {
 }
 function bodyPhysicalSource(sim, link) {
   if (sim) return "sim";
-  if (link?.massKg !== void 0 || link?.densityKgM3 !== void 0 || link?.collision !== void 0) return "legacy-export";
+  if (link?.massKg !== void 0 || link?.densityKgM3 !== void 0 || link?.collision !== void 0) return "metadata";
   return "missing";
 }
 function bodyManifest(model) {
@@ -80508,7 +80524,7 @@ function buildSimReadyManifest(model) {
     version: 1,
     modelName: model.modelName,
     sourceModelName: model.assembly.name,
-    source: model.source,
+    source: "assembly",
     profile: profile2?.name ?? null,
     profileVersion: "1.0.0",
     units: {
@@ -90816,6 +90832,849 @@ Sketch.prototype.onFace = function(parentOrFace, faceOrOpts, maybeOpts = {}) {
   return sketchOnFace(this, parentOrFace, faceOrOpts, maybeOpts);
 };
 
+// src/forge/sketch/nurbsSurfaceFit.ts
+var KNOT_EPS = 1e-10;
+var KNOT_MERGE_EPS = 1e-7;
+function sameKnot2(a, b) {
+  return Math.abs(a - b) <= KNOT_EPS;
+}
+function knotMultiplicity2(knots, u) {
+  let count = 0;
+  for (const k of knots) if (sameKnot2(k, u)) 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 k = 1; k < n; k++) {
+    const dx = points[k][0] - points[k - 1][0];
+    const dy = points[k][1] - points[k - 1][1];
+    const dz = points[k][2] - points[k - 1][2];
+    seg[k] = Math.hypot(dx, dy, dz) ** alpha;
+    total += seg[k];
+  }
+  if (total === 0) {
+    for (let k = 0; k < n; k++) params[k] = n > 1 ? k / (n - 1) : 0;
+    return params;
+  }
+  let acc = 0;
+  for (let k = 1; k < n - 1; k++) {
+    acc += seg[k];
+    params[k] = acc / total;
+  }
+  params[n - 1] = 1;
+  return params;
+}
+function knotsFromParamsAveraging(params, degree) {
+  const n = params.length - 1;
+  const m = n + degree + 1;
+  const knots = new Array(m + 1).fill(0);
+  for (let i = m - degree; i <= m; 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, B) {
+  const n = A.length;
+  const k = B[0].length;
+  const M = A.map((row, i) => [...row, ...B[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 + k; j++) M[col][j] *= inv;
+    for (let r = 0; r < n; r++) {
+      if (r === col) continue;
+      const f4 = M[r][col];
+      if (f4 === 0) continue;
+      for (let j = col; j < n + k; j++) M[r][j] -= f4 * M[col][j];
+    }
+  }
+  return Array.from({ length: n }, (_, 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, u) {
+  const n = cps.length;
+  const span = findSpan(n, degree, u, knots);
+  const mult = knotMultiplicity2(knots, u);
+  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] = u;
+  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 : (u - knots[i]) / denom;
+    const a = cps[i - 1];
+    const b = cps[i];
+    newCps[i] = [(1 - alpha) * a[0] + alpha * b[0], (1 - alpha) * a[1] + alpha * b[1], (1 - alpha) * a[2] + alpha * b[2]];
+  }
+  return { cps: newCps, knots: newKnots };
+}
+function interiorKnotBuckets(kv, mergeEps = KNOT_MERGE_EPS) {
+  const buckets = [];
+  for (const k of kv) {
+    if (k <= KNOT_EPS || k >= 1 - KNOT_EPS) continue;
+    const b = buckets.find((x) => Math.abs(x.value - k) <= mergeEps);
+    if (b) b.mult++;
+    else buckets.push({ value: k, 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((x) => Math.abs(x.value - value) <= mergeEps);
+      if (b) b.mult = Math.max(b.mult, mult);
+      else merged.push({ value, mult });
+    }
+  }
+  merged.sort((a, b) => a.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((c, k) => c + (Math.abs(k - 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(a, b) {
+  if (b < 0 || b > a) return 0;
+  let r = 1;
+  for (let i = 0; i < b; i++) r = r * (a - i) / (i + 1);
+  return r;
+}
+function bezierElevate(bez, p2, t) {
+  const m = p2 + t;
+  const out = [];
+  for (let i = 0; i <= m; 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 w = binomial(p2, j) * binomial(t, i - j) / binomial(m, i);
+      acc[0] += w * bez[j][0];
+      acc[1] += w * bez[j][1];
+      acc[2] += w * 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 (knotMultiplicity2(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((a, b) => a - 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((c) => c.degree));
+  const elevated = curves.map((c) => elevateCurveDegree(c.cps, c.knots, c.degree, targetDeg));
+  const common2 = mergeKnotVectors(
+    elevated.map((c) => c.knots),
+    targetDeg
+  );
+  const refined = elevated.map((c) => refineKnotsToTarget(c.cps, c.knots, targetDeg, common2));
+  const ncp = common2.length - targetDeg - 1;
+  for (const r of refined) {
+    if (r.cps.length !== ncp) throw new Error(`Curve unification produced ${r.cps.length} control points, expected ${ncp}.`);
+  }
+  return { degree: targetDeg, knots: common2, curves: refined.map((r) => r.cps) };
+}
+function transpose(g) {
+  const out = [];
+  for (let j = 0; j < g[0].length; j++) {
+    const row = [];
+    for (let i = 0; i < g.length; i++) row.push(g[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((_, 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 m = gridPts.length - 1;
+  const n = gridPts[0].length - 1;
+  if (m < 1 || n < 1) throw new Error("A Gordon surface needs at least a 2x2 curve network.");
+  if (m < degreeU) degreeU = m;
+  if (n < degreeV) degreeV = n;
+  const rows = gridPts;
+  const cols = gridPts[0].map((_, 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 a = LuS.grid[i][j];
+      const b = LvS.grid[i][j];
+      const c = TS.grid[i][j];
+      row.push([a[0] + b[0] - c[0], a[1] + b[1] - c[1], a[2] + b[2] - c[2]]);
+    }
+    grid.push(row);
+  }
+  return { grid, knotsU, knotsV, degreeU, degreeV };
+}
+function evalSurface(surf, u, v) {
+  const { grid, knotsU, knotsV, degreeU, degreeV } = surf;
+  const nu = grid.length;
+  const nv = grid[0].length;
+  const su = findSpan(nu, degreeU, u, knotsU);
+  const sv = findSpan(nv, degreeV, v, knotsV);
+  const Nu = basisFuns(su, u, 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 w = Nu[i] * Nv[j];
+      const p2 = grid[ui][vj];
+      out[0] += w * p2[0];
+      out[1] += w * p2[1];
+      out[2] += w * p2[2];
+    }
+  }
+  return out;
+}
+function evalSurfaceJet(surf, u, v) {
+  const { grid, knotsU, knotsV, degreeU, degreeV } = surf;
+  const nu = grid.length;
+  const nv = grid[0].length;
+  const su = findSpan(nu, degreeU, u, knotsU);
+  const sv = findSpan(nv, degreeV, v, knotsV);
+  const dU = basisFunsDeriv(su, u, 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 c = 0; c < 3; c++) {
+        S[c] += w00 * p2[c];
+        Su[c] += w10 * p2[c];
+        Sv[c] += w01 * p2[c];
+        Suu[c] += w20 * p2[c];
+        Suv[c] += w11 * p2[c];
+        Svv[c] += w02 * p2[c];
+      }
+    }
+  }
+  let nx = Su[1] * Sv[2] - Su[2] * Sv[1];
+  let ny = Su[2] * Sv[0] - Su[0] * Sv[2];
+  let nz = Su[0] * Sv[1] - Su[1] * Sv[0];
+  const len2 = Math.hypot(nx, ny, nz) || 1;
+  nx /= len2;
+  ny /= len2;
+  nz /= len2;
+  return { S, Su, Sv, Suu, Suv, Svv, normal: [nx, ny, nz] };
+}
+function surfaceCurvature(jet) {
+  const { Su, Sv, Suu, Suv, Svv, normal: normal2 } = jet;
+  const E = Su[0] * Su[0] + Su[1] * Su[1] + Su[2] * Su[2];
+  const F = Su[0] * Sv[0] + Su[1] * Sv[1] + Su[2] * Sv[2];
+  const G = Sv[0] * Sv[0] + Sv[1] * Sv[1] + Sv[2] * Sv[2];
+  const e = Suu[0] * normal2[0] + Suu[1] * normal2[1] + Suu[2] * normal2[2];
+  const f4 = Suv[0] * normal2[0] + Suv[1] * normal2[1] + Suv[2] * normal2[2];
+  const g = Svv[0] * normal2[0] + Svv[1] * normal2[1] + Svv[2] * normal2[2];
+  const denom = E * G - F * F;
+  if (Math.abs(denom) < 1e-20) return { k1: 0, k2: 0, K: 0, H: 0 };
+  const K = (e * g - f4 * f4) / denom;
+  const H = (e * G - 2 * f4 * F + g * 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 };
+}
+
+// src/forge/surfacing/curveNet.ts
+function isVec34(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 && isVec34(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 [a, b] = pts;
+      return (t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[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(count > 1 ? i / (count - 1) : 0));
+  return out;
+}
+var DEFAULT_THICKEN_RESOLUTION = 48;
+var Sheet = class {
+  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(u, v) {
+    return evalSurface(this.surface, clamp013(u), clamp013(v));
+  }
+  normalAt(u, v) {
+    return evalSurfaceJet(this.surface, clamp013(u), clamp013(v)).normal;
+  }
+  curvatureAt(u, v) {
+    return surfaceCurvature(evalSurfaceJet(this.surface, clamp013(u), clamp013(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 c = this.curvatureAt(i / samples, j / samples);
+        maxK = Math.max(maxK, Math.abs(c.k1), Math.abs(c.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 clamp013(t) {
+  return t < 0 ? 0 : t > 1 ? 1 : t;
+}
+var CurveNetBuilder = class {
+  lengthwiseCurves = [];
+  crosswiseCurves = [];
+  railCurves = [];
+  cageGrid = null;
+  degU;
+  degV;
+  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, k) => {
+      if (row.length !== cols) throw new Error(`Surface.Net().cage: row ${k} has ${row.length} points, expected ${cols}.`);
+      return row.map((p2, l) => requireFiniteVec(p2, `cage[${k}][${l}]`));
+    });
+    this.built = null;
+    return this;
+  }
+  degree(u, v) {
+    if (!Number.isInteger(u) || u < 1) throw new Error(`Surface.Net().degree: degree must be a positive integer, got ${u}`);
+    this.degU = u;
+    this.degV = v === void 0 ? u : 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 m = grid.length - 1;
+    const n = grid[0].length - 1;
+    const degreeU = Math.max(1, Math.min(this.degU ?? 3, m));
+    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((c, l) => toSampler(c, `lengthwise[${l}]`));
+      const grid = [];
+      for (let i = 0; i < SAMPLES; i++) {
+        const u = i / (SAMPLES - 1);
+        grid.push(samplers.map((s) => s(u)));
+      }
+      return grid;
+    }
+    if (crosswise.length >= 2) {
+      const samplers = crosswise.map((c, k) => toSampler(c, `crosswise[${k}]`));
+      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 \u2014 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(u, v) {
+    return this.toSheet().pointAt(u, v);
+  }
+  normalAt(u, v) {
+    return this.toSheet().normalAt(u, v);
+  }
+  curvatureAt(u, v) {
+    return this.toSheet().curvatureAt(u, v);
+  }
+  thicken(wall, options) {
+    return this.toSheet().thicken(wall, options);
+  }
+  matchEdge(edge) {
+    return this.toSheet().matchEdge(edge);
+  }
+};
+function createCurveNet() {
+  return new CurveNetBuilder();
+}
+var MatchEdgeBuilder = class {
+  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 d = 0; d <= depth; d++) {
+      const i = value === 0 ? d : nU - 1 - d;
+      rows.push(surf.grid[i].map((p2) => [p2[0], p2[1], p2[2]]));
+    }
+  } else {
+    const nV = surf.grid[0].length;
+    for (let d = 0; d <= depth; d++) {
+      const j = value === 0 ? d : nV - 1 - d;
+      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 k = 0; k < surf.grid.length; k++) surf.grid[k][j] = [row[k][0], row[k][1], row[k][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, clamp013(t));
+    return { point: j2.S, cross: j2.Su, cross2: j2.Suu };
+  }
+  const j = evalSurfaceJet(surf, clamp013(t), edge.value);
+  return { point: j.S, cross: j.Sv, cross2: j.Svv };
+}
+function sub39(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function len34(a) {
+  return Math.hypot(a[0], a[1], a[2]);
+}
+function unit3(a) {
+  const l = len34(a) || 1;
+  return [a[0] / l, a[1] / l, a[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 a = edgeJet(edgeA, t);
+    const b = edgeJet(edgeB, t);
+    maxPositionGap = Math.max(maxPositionGap, len34(sub39(a.point, b.point)));
+    const ua = unit3(a.cross);
+    const ub = unit3(b.cross);
+    const dot12 = Math.max(-1, Math.min(1, ua[0] * ub[0] + ua[1] * ub[1] + ua[2] * ub[2]));
+    const angle = Math.acos(Math.abs(dot12)) * 180 / Math.PI;
+    maxTangentAngleDeg = Math.max(maxTangentAngleDeg, angle);
+    const la = len34(a.cross) ** 2 || 1;
+    const lb = len34(b.cross) ** 2 || 1;
+    const ka = (a.cross2[0] * ua[0] + a.cross2[1] * ua[1] + a.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);
+}
+var BridgeBuilder = class {
+  constructor(edgeA, edgeB) {
+    this.edgeA = edgeA;
+    this.edgeB = edgeB;
+  }
+  bulgeA = 0.5;
+  bulgeB = 0.5;
+  /** Tune the influence of each side (Rhino-style bulge). */
+  bulge(a, b) {
+    if (!Number.isFinite(a) || !Number.isFinite(b)) throw new Error("Surfaces.bridge.bulge: both factors must be finite.");
+    this.bulgeA = a;
+    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 a = edgeJet(this.edgeA, t);
+      const b = edgeJet(this.edgeB, t);
+      const chord = len34(sub39(b.point, a.point));
+      const toward = unit3(sub39(b.point, a.point));
+      const tA = orientToward(unit3(a.cross), toward);
+      const tB = orientToward(unit3(b.cross), [-toward[0], -toward[1], -toward[2]]);
+      const poles = bridgePoles(a.point, b.point, tA, tB, chord, this.bulgeA, this.bulgeB, order);
+      const row = [];
+      for (let c = 0; c < CROSS; c++) row.push(deCasteljau(poles, c / (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 dot12 = v[0] * toward[0] + v[1] * toward[1] + v[2] * toward[2];
+  return dot12 < 0 ? [-v[0], -v[1], -v[2]] : v;
+}
+function bridgePoles(a, b, tA, tB, chord, bulgeA, bulgeB, order) {
+  if (order === 0) return [a, b];
+  const dA = chord * bulgeA / (order === 1 ? 3 : 5);
+  const dB = chord * bulgeB / (order === 1 ? 3 : 5);
+  const a1 = [a[0] + tA[0] * dA, a[1] + tA[1] * dA, a[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 [a, a1, b1, b];
+  const a2 = [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 [a, a1, a2, 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];
+}
+
 // src/forge/surfacing.ts
 var CORNER_Y_ALPHA_ISSUE_URL = "https://github.com/KoStard/forgecad-private/issues/162";
 function isVec3Array(value) {
@@ -92204,7 +93063,16 @@ var 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();
+  }
 };
 var Blend = {
   Edge(options) {
@@ -92224,6 +93092,14 @@ var 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.
@@ -92258,6 +93134,14 @@ var 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);
@@ -96222,22 +97106,10 @@ function roundNum(n, digits = 4) {
   return Number.isFinite(n) ? n.toFixed(digits).replace(/\.?0+$/, "") : String(n);
 }
 var 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();
@@ -97528,7 +98400,6 @@ function resetExecutionSession(logs) {
   resetHighlights();
   resetBom();
   resetSheetStock();
-  resetRobotExport();
   resetCutPlanes();
   resetRenderLabels();
   resetCameraTrajectory();
@@ -97611,7 +98482,6 @@ function collectSuccessfulExecutionSnapshot(args) {
     jointsView: getCollectedJointsView(),
     viewConfig: getCollectedViewConfig(),
     sceneConfig: getCollectedScene(),
-    robotExport: getCollectedRobotExport(),
     quality: args.quality,
     logs: args.logs.slice(),
     verifications: getCollectedVerifications(),
@@ -97636,7 +98506,6 @@ function collectFailedExecutionSnapshot(args) {
     jointsView: getCollectedJointsView(),
     viewConfig: getCollectedViewConfig(),
     sceneConfig: getCollectedScene(),
-    robotExport: getCollectedRobotExport(),
     quality: args.quality,
     logs: args.logs.slice(),
     verifications: getCollectedVerifications(),
@@ -99609,7 +100478,6 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       sketchToDxf,
       bom,
       sheetStock,
-      robotExport,
       Sim,
       group,
       ShapeGroup,
@@ -100849,7 +101717,6 @@ export {
   buildCompiledSceneReport,
   mapDimensionsToOwnerIds,
   generateReportPdf,
-  getCollectedRobotExport,
   collectSimulationModel,
   validateSimulationModel,
   buildSimReadyManifest,