brepkit-wasm 3.3.9 → 3.4.1

package/brepkit_wasm_node.cjs

@@ -53,38 +53,38 @@ class BrepKernel {
         return v1;
     }
     /**
-     * Approximate a curve through points (least-squares).
+     * Approximate a curve through points using LSPIA (progressive iteration).
      *
      * Returns an edge handle.
      * @param {Float64Array} coords
      * @param {number} degree
      * @param {number} num_control_points
+     * @param {number} tolerance
+     * @param {number} max_iterations
      * @returns {number}
      */
-    approximateCurve(coords, degree, num_control_points) {
+    approximateCurveLspia(coords, degree, num_control_points, tolerance, max_iterations) {
         const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.brepkernel_approximateCurve(this.__wbg_ptr, ptr0, len0, degree, num_control_points);
+        const ret = wasm.brepkernel_approximateCurveLspia(this.__wbg_ptr, ptr0, len0, degree, num_control_points, tolerance, max_iterations);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return ret[0] >>> 0;
     }
     /**
-     * Approximate a curve through points using LSPIA (progressive iteration).
+     * Approximate a curve through points (least-squares).
      *
      * Returns an edge handle.
      * @param {Float64Array} coords
      * @param {number} degree
      * @param {number} num_control_points
-     * @param {number} tolerance
-     * @param {number} max_iterations
      * @returns {number}
      */
-    approximateCurveLspia(coords, degree, num_control_points, tolerance, max_iterations) {
+    approximateCurve(coords, degree, num_control_points) {
         const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.brepkernel_approximateCurveLspia(this.__wbg_ptr, ptr0, len0, degree, num_control_points, tolerance, max_iterations);
+        const ret = wasm.brepkernel_approximateCurve(this.__wbg_ptr, ptr0, len0, degree, num_control_points);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -259,28 +259,6 @@ class BrepKernel {
         wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
         return v1;
     }
-    /**
-     * Chamfer edges of a solid.
-     *
-     * `edge_handles` is an array of edge handles. Returns a solid handle.
-     *
-     * # Errors
-     *
-     * Returns an error if distance is non-positive or edges are invalid.
-     * @param {number} solid
-     * @param {Uint32Array} edge_handles
-     * @param {number} distance
-     * @returns {number}
-     */
-    chamfer(solid, edge_handles, distance) {
-        const ptr0 = passArray32ToWasm0(edge_handles, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.brepkernel_chamfer(this.__wbg_ptr, solid, ptr0, len0, distance);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] >>> 0;
-    }
     /**
      * Cut corners of a 2D polygon with flat bevels.
      *
@@ -351,18 +329,26 @@ class BrepKernel {
         return ret[0] >>> 0;
     }
     /**
-     * Save a snapshot of the current kernel state.
+     * Chamfer edges of a solid.
      *
-     * Returns a checkpoint ID (zero-based index) that can be passed to
-     * `restore` or `discardCheckpoint`.
+     * `edge_handles` is an array of edge handles. Returns a solid handle.
      *
-     * The snapshot is a clone of all topology, assembly, and sketch state.
-     * Existing entity handles remain valid after restore.
+     * # Errors
+     *
+     * Returns an error if distance is non-positive or edges are invalid.
+     * @param {number} solid
+     * @param {Uint32Array} edge_handles
+     * @param {number} distance
      * @returns {number}
      */
-    checkpoint() {
-        const ret = wasm.brepkernel_checkpoint(this.__wbg_ptr);
-        return ret >>> 0;
+    chamfer(solid, edge_handles, distance) {
+        const ptr0 = passArray32ToWasm0(edge_handles, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_chamfer(this.__wbg_ptr, solid, ptr0, len0, distance);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
     }
     /**
      * Returns the number of saved checkpoints.
@@ -372,6 +358,20 @@ class BrepKernel {
         const ret = wasm.brepkernel_checkpointCount(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Save a snapshot of the current kernel state.
+     *
+     * Returns a checkpoint ID (zero-based index) that can be passed to
+     * `restore` or `discardCheckpoint`.
+     *
+     * The snapshot is a clone of all topology, assembly, and sketch state.
+     * Existing entity handles remain valid after restore.
+     * @returns {number}
+     */
+    checkpoint() {
+        const ret = wasm.brepkernel_checkpoint(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Create a circular pattern of a solid around an axis.
      *
@@ -391,13 +391,9 @@ class BrepKernel {
         return ret[0] >>> 0;
     }
     /**
-     * Classify a point relative to a solid: inside, outside, or on boundary.
-     *
-     * Returns `"inside"`, `"outside"`, or `"boundary"`.
-     *
-     * # Errors
+     * Classify a point using robust dual-method (winding + ray casting).
      *
-     * Returns an error if the solid handle is invalid.
+     * Returns "inside", "outside", or "boundary".
      * @param {number} solid
      * @param {number} x
      * @param {number} y
@@ -405,11 +401,11 @@ class BrepKernel {
      * @param {number} tolerance
      * @returns {string}
      */
-    classifyPoint(solid, x, y, z, tolerance) {
+    classifyPointRobust(solid, x, y, z, tolerance) {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.brepkernel_classifyPoint(this.__wbg_ptr, solid, x, y, z, tolerance);
+            const ret = wasm.brepkernel_classifyPointRobust(this.__wbg_ptr, solid, x, y, z, tolerance);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -424,7 +420,7 @@ class BrepKernel {
         }
     }
     /**
-     * Classify a point using robust dual-method (winding + ray casting).
+     * Classify a point relative to a solid using generalized winding numbers.
      *
      * Returns "inside", "outside", or "boundary".
      * @param {number} solid
@@ -434,11 +430,11 @@ class BrepKernel {
      * @param {number} tolerance
      * @returns {string}
      */
-    classifyPointRobust(solid, x, y, z, tolerance) {
+    classifyPointWinding(solid, x, y, z, tolerance) {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.brepkernel_classifyPointRobust(this.__wbg_ptr, solid, x, y, z, tolerance);
+            const ret = wasm.brepkernel_classifyPointWinding(this.__wbg_ptr, solid, x, y, z, tolerance);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -453,9 +449,13 @@ class BrepKernel {
         }
     }
     /**
-     * Classify a point relative to a solid using generalized winding numbers.
+     * Classify a point relative to a solid: inside, outside, or on boundary.
      *
-     * Returns "inside", "outside", or "boundary".
+     * Returns `"inside"`, `"outside"`, or `"boundary"`.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
      * @param {number} solid
      * @param {number} x
      * @param {number} y
@@ -463,11 +463,11 @@ class BrepKernel {
      * @param {number} tolerance
      * @returns {string}
      */
-    classifyPointWinding(solid, x, y, z, tolerance) {
+    classifyPoint(solid, x, y, z, tolerance) {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.brepkernel_classifyPointWinding(this.__wbg_ptr, solid, x, y, z, tolerance);
+            const ret = wasm.brepkernel_classifyPoint(this.__wbg_ptr, solid, x, y, z, tolerance);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -763,9 +763,9 @@ class BrepKernel {
         return v1;
     }
     /**
-     * Cut (subtract) solid `b` from solid `a`.
+     * Cut (subtract) solid `b` from solid `a` and return evolution tracking data.
      *
-     * Returns a new solid handle (`u32`).
+     * Returns a JSON string: `{"solid": <u32>, "evolution": {...}}`.
      *
      * # Errors
      *
@@ -773,19 +773,17 @@ class BrepKernel {
      * produces an empty or non-manifold result.
      * @param {number} a
      * @param {number} b
-     * @returns {number}
+     * @returns {any}
      */
-    cut(a, b) {
-        const ret = wasm.brepkernel_cut(this.__wbg_ptr, a, b);
+    cutWithEvolution(a, b) {
+        const ret = wasm.brepkernel_cutWithEvolution(this.__wbg_ptr, a, b);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ret[0] >>> 0;
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Cut (subtract) solid `b` from solid `a` and return evolution tracking data.
-     *
-     * Returns a JSON string: `{"solid": <u32>, "evolution": {...}}`.
+     * Cut (subtract) solid `b` from solid `a` with post-processing options.
      *
      * # Errors
      *
@@ -793,17 +791,20 @@ class BrepKernel {
      * produces an empty or non-manifold result.
      * @param {number} a
      * @param {number} b
-     * @returns {any}
+     * @param {boolean} simplify
+     * @returns {number}
      */
-    cutWithEvolution(a, b) {
-        const ret = wasm.brepkernel_cutWithEvolution(this.__wbg_ptr, a, b);
+    cutWithOptions(a, b, simplify) {
+        const ret = wasm.brepkernel_cutWithOptions(this.__wbg_ptr, a, b, simplify);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return takeFromExternrefTable0(ret[0]);
+        return ret[0] >>> 0;
     }
     /**
-     * Cut (subtract) solid `b` from solid `a` with post-processing options.
+     * Cut (subtract) solid `b` from solid `a`.
+     *
+     * Returns a new solid handle (`u32`).
      *
      * # Errors
      *
@@ -811,11 +812,10 @@ class BrepKernel {
      * produces an empty or non-manifold result.
      * @param {number} a
      * @param {number} b
-     * @param {boolean} simplify
      * @returns {number}
      */
-    cutWithOptions(a, b, simplify) {
-        const ret = wasm.brepkernel_cutWithOptions(this.__wbg_ptr, a, b, simplify);
+    cut(a, b) {
+        const ret = wasm.brepkernel_cut(this.__wbg_ptr, a, b);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -1000,15 +1000,15 @@ class BrepKernel {
         }
     }
     /**
-     * Evaluate a point on an edge curve at parameter `t`.
+     * Evaluate a point and tangent on an edge curve at parameter `t`.
      *
-     * Returns `[x, y, z]`.
+     * Returns `[px, py, pz, tx, ty, tz]`.
      * @param {number} edge
      * @param {number} t
      * @returns {Float64Array}
      */
-    evaluateEdgeCurve(edge, t) {
-        const ret = wasm.brepkernel_evaluateEdgeCurve(this.__wbg_ptr, edge, t);
+    evaluateEdgeCurveD1(edge, t) {
+        const ret = wasm.brepkernel_evaluateEdgeCurveD1(this.__wbg_ptr, edge, t);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
@@ -1017,15 +1017,15 @@ class BrepKernel {
         return v1;
     }
     /**
-     * Evaluate a point and tangent on an edge curve at parameter `t`.
+     * Evaluate a point on an edge curve at parameter `t`.
      *
-     * Returns `[px, py, pz, tx, ty, tz]`.
+     * Returns `[x, y, z]`.
      * @param {number} edge
      * @param {number} t
      * @returns {Float64Array}
      */
-    evaluateEdgeCurveD1(edge, t) {
-        const ret = wasm.brepkernel_evaluateEdgeCurveD1(this.__wbg_ptr, edge, t);
+    evaluateEdgeCurve(edge, t) {
+        const ret = wasm.brepkernel_evaluateEdgeCurve(this.__wbg_ptr, edge, t);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
@@ -1034,16 +1034,16 @@ class BrepKernel {
         return v1;
     }
     /**
-     * Evaluate a point on a face surface at (u, v).
+     * Evaluate a surface normal at (u, v) on a face.
      *
-     * Returns `[x, y, z]`.
+     * Returns `[nx, ny, nz]`.
      * @param {number} face
      * @param {number} u
      * @param {number} v
      * @returns {Float64Array}
      */
-    evaluateSurface(face, u, v) {
-        const ret = wasm.brepkernel_evaluateSurface(this.__wbg_ptr, face, u, v);
+    evaluateSurfaceNormal(face, u, v) {
+        const ret = wasm.brepkernel_evaluateSurfaceNormal(this.__wbg_ptr, face, u, v);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
@@ -1052,16 +1052,16 @@ class BrepKernel {
         return v1;
     }
     /**
-     * Evaluate a surface normal at (u, v) on a face.
+     * Evaluate a point on a face surface at (u, v).
      *
-     * Returns `[nx, ny, nz]`.
+     * Returns `[x, y, z]`.
      * @param {number} face
      * @param {number} u
      * @param {number} v
      * @returns {Float64Array}
      */
-    evaluateSurfaceNormal(face, u, v) {
-        const ret = wasm.brepkernel_evaluateSurfaceNormal(this.__wbg_ptr, face, u, v);
+    evaluateSurface(face, u, v) {
+        const ret = wasm.brepkernel_evaluateSurface(this.__wbg_ptr, face, u, v);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
@@ -1228,9 +1228,9 @@ class BrepKernel {
         return v1;
     }
     /**
-     * Export a solid to binary STL format.
+     * Export a solid to STL ASCII format.
      *
-     * Returns a `Uint8Array` containing the `.stl` file.
+     * Returns the ASCII STL as UTF-8 bytes.
      *
      * # Errors
      *
@@ -1239,8 +1239,8 @@ class BrepKernel {
      * @param {number} deflection
      * @returns {Uint8Array}
      */
-    exportStl(solid, deflection) {
-        const ret = wasm.brepkernel_exportStl(this.__wbg_ptr, solid, deflection);
+    exportStlAscii(solid, deflection) {
+        const ret = wasm.brepkernel_exportStlAscii(this.__wbg_ptr, solid, deflection);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
@@ -1249,9 +1249,9 @@ class BrepKernel {
         return v1;
     }
     /**
-     * Export a solid to STL ASCII format.
+     * Export a solid to binary STL format.
      *
-     * Returns the ASCII STL as UTF-8 bytes.
+     * Returns a `Uint8Array` containing the `.stl` file.
      *
      * # Errors
      *
@@ -1260,8 +1260,8 @@ class BrepKernel {
      * @param {number} deflection
      * @returns {Uint8Array}
      */
-    exportStlAscii(solid, deflection) {
-        const ret = wasm.brepkernel_exportStlAscii(this.__wbg_ptr, solid, deflection);
+    exportStl(solid, deflection) {
+        const ret = wasm.brepkernel_exportStl(this.__wbg_ptr, solid, deflection);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
@@ -1361,28 +1361,6 @@ class BrepKernel {
         }
         return ret[0] >>> 0;
     }
-    /**
-     * Fillet (round) edges of a solid.
-     *
-     * `edge_handles` is an array of edge handles. Returns a solid handle.
-     *
-     * # Errors
-     *
-     * Returns an error if radius is non-positive or edges are invalid.
-     * @param {number} solid
-     * @param {Uint32Array} edge_handles
-     * @param {number} radius
-     * @returns {number}
-     */
-    fillet(solid, edge_handles, radius) {
-        const ptr0 = passArray32ToWasm0(edge_handles, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.brepkernel_fillet(this.__wbg_ptr, solid, ptr0, len0, radius);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] >>> 0;
-    }
     /**
      * Round corners of a 2D polygon by inserting arc-approximation vertices.
      *
@@ -1476,6 +1454,29 @@ class BrepKernel {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Fillet (round) edges of a solid.
+     *
+     * `edge_handles` is an array of edge handles. Returns a solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if radius is non-positive, edges are invalid, or no
+     * fillet engine can produce a valid changed solid.
+     * @param {number} solid
+     * @param {Uint32Array} edge_handles
+     * @param {number} radius
+     * @returns {number}
+     */
+    fillet(solid, edge_handles, radius) {
+        const ptr0 = passArray32ToWasm0(edge_handles, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_fillet(this.__wbg_ptr, solid, ptr0, len0, radius);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Fix face orientations to ensure consistent outward normals.
      *
@@ -1515,26 +1516,6 @@ class BrepKernel {
         }
         return ret[0] >>> 0;
     }
-    /**
-     * Fuse (union) two solids into one.
-     *
-     * Returns a new solid handle (`u32`).
-     *
-     * # Errors
-     *
-     * Returns an error if either solid handle is invalid or the operation
-     * produces an empty or non-manifold result.
-     * @param {number} a
-     * @param {number} b
-     * @returns {number}
-     */
-    fuse(a, b) {
-        const ret = wasm.brepkernel_fuse(this.__wbg_ptr, a, b);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] >>> 0;
-    }
     /**
      * Fuse (union) many solids into one in a single call.
      *
@@ -1603,12 +1584,32 @@ class BrepKernel {
         return ret[0] >>> 0;
     }
     /**
-     * Get the analytic surface parameters of a face.
+     * Fuse (union) two solids into one.
      *
-     * Returns a JSON string with surface-type-specific parameters.
-     * @param {number} face
-     * @returns {string}
-     */
+     * Returns a new solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if either solid handle is invalid or the operation
+     * produces an empty or non-manifold result.
+     * @param {number} a
+     * @param {number} b
+     * @returns {number}
+     */
+    fuse(a, b) {
+        const ret = wasm.brepkernel_fuse(this.__wbg_ptr, a, b);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Get the analytic surface parameters of a face.
+     *
+     * Returns a JSON string with surface-type-specific parameters.
+     * @param {number} face
+     * @returns {string}
+     */
     getAnalyticSurfaceParams(face) {
         let deferred2_0;
         let deferred2_1;
@@ -1879,22 +1880,23 @@ class BrepKernel {
         }
     }
     /**
-     * Read-only canonical NURBS data for the surface underlying a face.
+     * Type-gated read-only B-Spline/NURBS surface data for a face.
      *
-     * Analytic surfaces are converted to NURBS (planes/cylinders exact;
-     * cones/spheres/tori via the exact rational forms). Returns a JSON
-     * string with `degreeU`/`degreeV`, the row-major `controlPoints` grid,
-     * the matching `weights` grid, flat `knotsU`/`knotsV`, compressed
-     * distinct-knots/multiplicities per direction, `rational`,
-     * `periodicU`/`periodicV`, and `domainU`/`domainV`.
+     * Unlike `getNurbsSurfaceData`, this never converts analytic surfaces:
+     * faces backed by a plane, cylinder, cone, sphere, or torus return the
+     * JSON literal `null`. Only intrinsically free-form (B-Spline/NURBS) faces
+     * yield a record with `degreeU`/`degreeV`, `nbPolesU`/`nbPolesV`, the
+     * row-major `poles` grid (u-major, v-minor) with the matching `weights`
+     * grid, distinct `knotsU`/`knotsV` paired with `multiplicitiesU`/
+     * `multiplicitiesV`, `isPeriodicU`/`isPeriodicV`, and `isRational`.
      * @param {number} face
      * @returns {string}
      */
-    getNurbsSurfaceData(face) {
+    getNurbsSurfaceDataParity(face) {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.brepkernel_getNurbsSurfaceData(this.__wbg_ptr, face);
+            const ret = wasm.brepkernel_getNurbsSurfaceDataParity(this.__wbg_ptr, face);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -1909,23 +1911,22 @@ class BrepKernel {
         }
     }
     /**
-     * Type-gated read-only B-Spline/NURBS surface data for a face.
+     * Read-only canonical NURBS data for the surface underlying a face.
      *
-     * Unlike `getNurbsSurfaceData`, this never converts analytic surfaces:
-     * faces backed by a plane, cylinder, cone, sphere, or torus return the
-     * JSON literal `null`. Only intrinsically free-form (B-Spline/NURBS) faces
-     * yield a record with `degreeU`/`degreeV`, `nbPolesU`/`nbPolesV`, the
-     * row-major `poles` grid (u-major, v-minor) with the matching `weights`
-     * grid, distinct `knotsU`/`knotsV` paired with `multiplicitiesU`/
-     * `multiplicitiesV`, `isPeriodicU`/`isPeriodicV`, and `isRational`.
+     * Analytic surfaces are converted to NURBS (planes/cylinders exact;
+     * cones/spheres/tori via the exact rational forms). Returns a JSON
+     * string with `degreeU`/`degreeV`, the row-major `controlPoints` grid,
+     * the matching `weights` grid, flat `knotsU`/`knotsV`, compressed
+     * distinct-knots/multiplicities per direction, `rational`,
+     * `periodicU`/`periodicV`, and `domainU`/`domainV`.
      * @param {number} face
      * @returns {string}
      */
-    getNurbsSurfaceDataParity(face) {
+    getNurbsSurfaceData(face) {
         let deferred2_0;
         let deferred2_1;
         try {
-            const ret = wasm.brepkernel_getNurbsSurfaceDataParity(this.__wbg_ptr, face);
+            const ret = wasm.brepkernel_getNurbsSurfaceData(this.__wbg_ptr, face);
             var ptr1 = ret[0];
             var len1 = ret[1];
             if (ret[3]) {
@@ -2440,26 +2441,6 @@ class BrepKernel {
         }
         return ret[0] >>> 0;
     }
-    /**
-     * Intersect two solids, keeping only their common volume.
-     *
-     * Returns a new solid handle (`u32`).
-     *
-     * # Errors
-     *
-     * Returns an error if either solid handle is invalid or the operation
-     * produces an empty result.
-     * @param {number} a
-     * @param {number} b
-     * @returns {number}
-     */
-    intersect(a, b) {
-        const ret = wasm.brepkernel_intersect(this.__wbg_ptr, a, b);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] >>> 0;
-    }
     /**
      * Compute the boolean intersection of two 2D polygons.
      *
@@ -2524,6 +2505,26 @@ class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Intersect two solids, keeping only their common volume.
+     *
+     * Returns a new solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if either solid handle is invalid or the operation
+     * produces an empty result.
+     * @param {number} a
+     * @param {number} b
+     * @returns {number}
+     */
+    intersect(a, b) {
+        const ret = wasm.brepkernel_intersect(this.__wbg_ptr, a, b);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Check if an edge is forward-oriented in a given wire.
      *
@@ -2607,27 +2608,6 @@ class BrepKernel {
         }
         return ret[0] >>> 0;
     }
-    /**
-     * Loft two or more profile faces into a solid.
-     *
-     * Takes an array of face handles. Returns a solid handle (`u32`).
-     *
-     * # Errors
-     *
-     * Returns an error if fewer than 2 faces or profiles have
-     * different vertex counts.
-     * @param {Uint32Array} faces
-     * @returns {number}
-     */
-    loft(faces) {
-        const ptr0 = passArray32ToWasm0(faces, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.brepkernel_loft(this.__wbg_ptr, ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] >>> 0;
-    }
     /**
      * Loft profiles with smooth NURBS interpolation.
      *
@@ -2676,41 +2656,41 @@ class BrepKernel {
         return ret[0] >>> 0;
     }
     /**
-     * Create a box solid with the given dimensions, centered at the origin.
+     * Loft two or more profile faces into a solid.
      *
-     * Returns a solid handle (`u32`).
+     * Takes an array of face handles. Returns a solid handle (`u32`).
      *
      * # Errors
      *
-     * Returns an error if any dimension is non-positive or non-finite.
-     * @param {number} dx
-     * @param {number} dy
-     * @param {number} dz
+     * Returns an error if fewer than 2 faces or profiles have
+     * different vertex counts.
+     * @param {Uint32Array} faces
      * @returns {number}
      */
-    makeBox(dx, dy, dz) {
-        const ret = wasm.brepkernel_makeBox(this.__wbg_ptr, dx, dy, dz);
+    loft(faces) {
+        const ptr0 = passArray32ToWasm0(faces, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_loft(this.__wbg_ptr, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return ret[0] >>> 0;
     }
     /**
-     * Create a circular polygon approximation on the XY plane.
+     * Create a box solid with the given dimensions, centered at the origin.
      *
-     * The circle is centered at the origin with the given `radius`,
-     * approximated by `segments` straight edges.
-     * Returns a face handle (`u32`).
+     * Returns a solid handle (`u32`).
      *
      * # Errors
      *
-     * Returns an error if fewer than 3 segments are specified.
-     * @param {number} radius
-     * @param {number} segments
+     * Returns an error if any dimension is non-positive or non-finite.
+     * @param {number} dx
+     * @param {number} dy
+     * @param {number} dz
      * @returns {number}
      */
-    makeCircle(radius, segments) {
-        const ret = wasm.brepkernel_makeCircle(this.__wbg_ptr, radius, segments);
+    makeBox(dx, dy, dz) {
+        const ret = wasm.brepkernel_makeBox(this.__wbg_ptr, dx, dy, dz);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -2746,19 +2726,25 @@ class BrepKernel {
         return ret[0] >>> 0;
     }
     /**
-     * Create a closed circular edge with true `Circle` curve geometry.
+     * Create a closed circular edge with a caller-supplied reference x-direction.
      *
-     * Unlike `makeCircle` (which returns a polygon face approximation),
-     * this creates a single closed edge with an [`EdgeCurve::Circle`]
-     * backing curve and parameter domain `[0, 2π]`. The start and end
-     * vertex are shared at the seam point `circle.evaluate(0.0)`.
+     * Like [`makeCircleEdge`](Self::make_circle_edge), but `ref_dir = (rx, ry, rz)`
+     * is projected onto the plane perpendicular to the normal to fix the
+     * circle's `u_axis` — which controls the seam vertex position at
+     * `circle.evaluate(0.0)`. Use when downstream code (PCurve computation,
+     * extrusion frame) depends on a specific seam placement.
+     *
+     * `ref_dir` must be non-zero (rejected at this boundary) and ideally
+     * not parallel to the normal — `Frame3::from_normal_and_ref` falls
+     * back to an arbitrary perpendicular when the projection of `ref_dir`
+     * onto the plane is degenerate, defeating the purpose of this call.
      *
      * Returns an edge handle (`u32`).
      *
      * # Errors
      *
      * Returns an error if any coordinate is NaN/infinite, `radius` is
-     * non-positive, or the normal vector is zero.
+     * non-positive, or the normal vector or `ref_dir` is zero.
      * @param {number} cx
      * @param {number} cy
      * @param {number} cz
@@ -2766,35 +2752,32 @@ class BrepKernel {
      * @param {number} ny
      * @param {number} nz
      * @param {number} radius
+     * @param {number} rx
+     * @param {number} ry
+     * @param {number} rz
      * @returns {number}
      */
-    makeCircleEdge(cx, cy, cz, nx, ny, nz, radius) {
-        const ret = wasm.brepkernel_makeCircleEdge(this.__wbg_ptr, cx, cy, cz, nx, ny, nz, radius);
+    makeCircleEdgeWithRef(cx, cy, cz, nx, ny, nz, radius, rx, ry, rz) {
+        const ret = wasm.brepkernel_makeCircleEdgeWithRef(this.__wbg_ptr, cx, cy, cz, nx, ny, nz, radius, rx, ry, rz);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return ret[0] >>> 0;
     }
     /**
-     * Create a closed circular edge with a caller-supplied reference x-direction.
-     *
-     * Like [`makeCircleEdge`](Self::make_circle_edge), but `ref_dir = (rx, ry, rz)`
-     * is projected onto the plane perpendicular to the normal to fix the
-     * circle's `u_axis` — which controls the seam vertex position at
-     * `circle.evaluate(0.0)`. Use when downstream code (PCurve computation,
-     * extrusion frame) depends on a specific seam placement.
+     * Create a closed circular edge with true `Circle` curve geometry.
      *
-     * `ref_dir` must be non-zero (rejected at this boundary) and ideally
-     * not parallel to the normal — `Frame3::from_normal_and_ref` falls
-     * back to an arbitrary perpendicular when the projection of `ref_dir`
-     * onto the plane is degenerate, defeating the purpose of this call.
+     * Unlike `makeCircle` (which returns a polygon face approximation),
+     * this creates a single closed edge with an [`EdgeCurve::Circle`]
+     * backing curve and parameter domain `[0, 2π]`. The start and end
+     * vertex are shared at the seam point `circle.evaluate(0.0)`.
      *
      * Returns an edge handle (`u32`).
      *
      * # Errors
      *
      * Returns an error if any coordinate is NaN/infinite, `radius` is
-     * non-positive, or the normal vector or `ref_dir` is zero.
+     * non-positive, or the normal vector is zero.
      * @param {number} cx
      * @param {number} cy
      * @param {number} cz
@@ -2802,13 +2785,10 @@ class BrepKernel {
      * @param {number} ny
      * @param {number} nz
      * @param {number} radius
-     * @param {number} rx
-     * @param {number} ry
-     * @param {number} rz
      * @returns {number}
      */
-    makeCircleEdgeWithRef(cx, cy, cz, nx, ny, nz, radius, rx, ry, rz) {
-        const ret = wasm.brepkernel_makeCircleEdgeWithRef(this.__wbg_ptr, cx, cy, cz, nx, ny, nz, radius, rx, ry, rz);
+    makeCircleEdge(cx, cy, cz, nx, ny, nz, radius) {
+        const ret = wasm.brepkernel_makeCircleEdge(this.__wbg_ptr, cx, cy, cz, nx, ny, nz, radius);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -2829,6 +2809,27 @@ class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Create a circular polygon approximation on the XY plane.
+     *
+     * The circle is centered at the origin with the given `radius`,
+     * approximated by `segments` straight edges.
+     * Returns a face handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if fewer than 3 segments are specified.
+     * @param {number} radius
+     * @param {number} segments
+     * @returns {number}
+     */
+    makeCircle(radius, segments) {
+        const ret = wasm.brepkernel_makeCircle(this.__wbg_ptr, radius, segments);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Create a compound from multiple solid handles.
      *
@@ -2927,11 +2928,20 @@ class BrepKernel {
         return ret[0] >>> 0;
     }
     /**
-     * Create a closed elliptical edge with true `Ellipse` curve geometry.
+     * Create a closed elliptical edge with a caller-supplied reference major-axis.
      *
-     * Creates a single closed edge with an [`EdgeCurve::Ellipse`] backing
-     * curve and parameter domain `[0, 2π]`. The start and end vertex are
-     * shared at the seam point `ellipse.evaluate(0.0)`.
+     * Like [`makeEllipseEdge`](Self::make_ellipse_edge), but `ref_dir = (rx, ry, rz)`
+     * is projected onto the plane perpendicular to the normal to fix the
+     * ellipse's major-axis direction (`u_axis`, carrying `semi_major`).
+     * Use this when the caller has an intended major-axis orientation —
+     * otherwise the default-frame variant chooses an arbitrary
+     * perpendicular, which can cause adapters to fall back to NURBS
+     * approximations to preserve their requested orientation.
+     *
+     * `ref_dir` must be non-zero (rejected at this boundary) and ideally
+     * not parallel to the normal — `Frame3::from_normal_and_ref` falls
+     * back to an arbitrary perpendicular when the projection of `ref_dir`
+     * onto the plane is degenerate, defeating the purpose of this call.
      *
      * Returns an edge handle (`u32`).
      *
@@ -2939,7 +2949,7 @@ class BrepKernel {
      *
      * Returns an error if any coordinate is NaN/infinite, either
      * semi-axis is non-positive, `semi_minor` exceeds `semi_major`, or
-     * the normal vector is zero.
+     * the normal vector or `ref_dir` is zero.
      * @param {number} cx
      * @param {number} cy
      * @param {number} cz
@@ -2948,30 +2958,24 @@ class BrepKernel {
      * @param {number} nz
      * @param {number} semi_major
      * @param {number} semi_minor
+     * @param {number} rx
+     * @param {number} ry
+     * @param {number} rz
      * @returns {number}
      */
-    makeEllipseEdge(cx, cy, cz, nx, ny, nz, semi_major, semi_minor) {
-        const ret = wasm.brepkernel_makeEllipseEdge(this.__wbg_ptr, cx, cy, cz, nx, ny, nz, semi_major, semi_minor);
+    makeEllipseEdgeWithRef(cx, cy, cz, nx, ny, nz, semi_major, semi_minor, rx, ry, rz) {
+        const ret = wasm.brepkernel_makeEllipseEdgeWithRef(this.__wbg_ptr, cx, cy, cz, nx, ny, nz, semi_major, semi_minor, rx, ry, rz);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return ret[0] >>> 0;
     }
     /**
-     * Create a closed elliptical edge with a caller-supplied reference major-axis.
-     *
-     * Like [`makeEllipseEdge`](Self::make_ellipse_edge), but `ref_dir = (rx, ry, rz)`
-     * is projected onto the plane perpendicular to the normal to fix the
-     * ellipse's major-axis direction (`u_axis`, carrying `semi_major`).
-     * Use this when the caller has an intended major-axis orientation —
-     * otherwise the default-frame variant chooses an arbitrary
-     * perpendicular, which can cause adapters to fall back to NURBS
-     * approximations to preserve their requested orientation.
+     * Create a closed elliptical edge with true `Ellipse` curve geometry.
      *
-     * `ref_dir` must be non-zero (rejected at this boundary) and ideally
-     * not parallel to the normal — `Frame3::from_normal_and_ref` falls
-     * back to an arbitrary perpendicular when the projection of `ref_dir`
-     * onto the plane is degenerate, defeating the purpose of this call.
+     * Creates a single closed edge with an [`EdgeCurve::Ellipse`] backing
+     * curve and parameter domain `[0, 2π]`. The start and end vertex are
+     * shared at the seam point `ellipse.evaluate(0.0)`.
      *
      * Returns an edge handle (`u32`).
      *
@@ -2979,7 +2983,7 @@ class BrepKernel {
      *
      * Returns an error if any coordinate is NaN/infinite, either
      * semi-axis is non-positive, `semi_minor` exceeds `semi_major`, or
-     * the normal vector or `ref_dir` is zero.
+     * the normal vector is zero.
      * @param {number} cx
      * @param {number} cy
      * @param {number} cz
@@ -2988,13 +2992,10 @@ class BrepKernel {
      * @param {number} nz
      * @param {number} semi_major
      * @param {number} semi_minor
-     * @param {number} rx
-     * @param {number} ry
-     * @param {number} rz
      * @returns {number}
      */
-    makeEllipseEdgeWithRef(cx, cy, cz, nx, ny, nz, semi_major, semi_minor, rx, ry, rz) {
-        const ret = wasm.brepkernel_makeEllipseEdgeWithRef(this.__wbg_ptr, cx, cy, cz, nx, ny, nz, semi_major, semi_minor, rx, ry, rz);
+    makeEllipseEdge(cx, cy, cz, nx, ny, nz, semi_major, semi_minor) {
+        const ret = wasm.brepkernel_makeEllipseEdge(this.__wbg_ptr, cx, cy, cz, nx, ny, nz, semi_major, semi_minor);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -3098,8 +3099,24 @@ class BrepKernel {
      * @param {number} wire
      * @returns {number}
      */
-    makePlanarFaceFromWire(wire) {
-        const ret = wasm.brepkernel_makePlanarFaceFromWire(this.__wbg_ptr, wire);
+    makePlanarFaceFromWire(wire) {
+        const ret = wasm.brepkernel_makePlanarFaceFromWire(this.__wbg_ptr, wire);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Create a closed polygon wire from flat coordinates.
+     *
+     * Returns a wire handle.
+     * @param {Float64Array} coords
+     * @returns {number}
+     */
+    makePolygonWire(coords) {
+        const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_makePolygonWire(this.__wbg_ptr, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -3127,22 +3144,6 @@ class BrepKernel {
         }
         return ret[0] >>> 0;
     }
-    /**
-     * Create a closed polygon wire from flat coordinates.
-     *
-     * Returns a wire handle.
-     * @param {Float64Array} coords
-     * @returns {number}
-     */
-    makePolygonWire(coords) {
-        const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.brepkernel_makePolygonWire(this.__wbg_ptr, ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] >>> 0;
-    }
     /**
      * Create a rectangular face on the XY plane centered at the origin.
      *
@@ -3375,38 +3376,38 @@ class BrepKernel {
         return JsMesh.__wrap(ret[0]);
     }
     /**
-     * Sample edges of a solid into polylines for wireframe rendering.
-     *
-     * Returns a `JsEdgeLines` containing flattened positions and per-edge
-     * offset indices. The `deflection` parameter controls sampling density.
+     * Sample ALL edges of a solid (no smooth-edge filtering).
      *
-     * Smooth edges (between faces on the same underlying surface) are
-     * automatically filtered out to reduce wireframe clutter. These edges
-     * arise from boolean face-splitting and don't represent visible creases.
+     * Same as `meshEdges` but includes edges between co-surface faces.
+     * Useful for debugging topology.
      * @param {number} solid
      * @param {number} deflection
      * @param {number | null} [angular_tolerance]
      * @returns {JsEdgeLines}
      */
-    meshEdges(solid, deflection, angular_tolerance) {
-        const ret = wasm.brepkernel_meshEdges(this.__wbg_ptr, solid, deflection, !isLikeNone(angular_tolerance), isLikeNone(angular_tolerance) ? 0 : angular_tolerance);
+    meshEdgesAll(solid, deflection, angular_tolerance) {
+        const ret = wasm.brepkernel_meshEdgesAll(this.__wbg_ptr, solid, deflection, !isLikeNone(angular_tolerance), isLikeNone(angular_tolerance) ? 0 : angular_tolerance);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return JsEdgeLines.__wrap(ret[0]);
     }
     /**
-     * Sample ALL edges of a solid (no smooth-edge filtering).
+     * Sample edges of a solid into polylines for wireframe rendering.
      *
-     * Same as `meshEdges` but includes edges between co-surface faces.
-     * Useful for debugging topology.
+     * Returns a `JsEdgeLines` containing flattened positions and per-edge
+     * offset indices. The `deflection` parameter controls sampling density.
+     *
+     * Smooth edges (between faces on the same underlying surface) are
+     * automatically filtered out to reduce wireframe clutter. These edges
+     * arise from boolean face-splitting and don't represent visible creases.
      * @param {number} solid
      * @param {number} deflection
      * @param {number | null} [angular_tolerance]
      * @returns {JsEdgeLines}
      */
-    meshEdgesAll(solid, deflection, angular_tolerance) {
-        const ret = wasm.brepkernel_meshEdgesAll(this.__wbg_ptr, solid, deflection, !isLikeNone(angular_tolerance), isLikeNone(angular_tolerance) ? 0 : angular_tolerance);
+    meshEdges(solid, deflection, angular_tolerance) {
+        const ret = wasm.brepkernel_meshEdges(this.__wbg_ptr, solid, deflection, !isLikeNone(angular_tolerance), isLikeNone(angular_tolerance) ? 0 : angular_tolerance);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -3565,25 +3566,6 @@ class BrepKernel {
         wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
         return v2;
     }
-    /**
-     * Offset (shell) a solid by a distance.
-     *
-     * Returns a new solid handle.
-     *
-     * # Errors
-     *
-     * Returns an error if the distance is zero or the solid is invalid.
-     * @param {number} solid
-     * @param {number} distance
-     * @returns {number}
-     */
-    offsetSolid(solid, distance) {
-        const ret = wasm.brepkernel_offsetSolid(this.__wbg_ptr, solid, distance);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] >>> 0;
-    }
     /**
      * Offset all faces of a solid outward or inward (V2 pipeline).
      *
@@ -3604,15 +3586,19 @@ class BrepKernel {
         return ret[0] >>> 0;
     }
     /**
-     * Offset a wire on a planar face.
+     * Offset (shell) a solid by a distance.
      *
-     * Returns a new wire handle.
-     * @param {number} face
+     * Returns a new solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the distance is zero or the solid is invalid.
+     * @param {number} solid
      * @param {number} distance
      * @returns {number}
      */
-    offsetWire(face, distance) {
-        const ret = wasm.brepkernel_offsetWire(this.__wbg_ptr, face, distance);
+    offsetSolid(solid, distance) {
+        const ret = wasm.brepkernel_offsetSolid(this.__wbg_ptr, solid, distance);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -3674,6 +3660,21 @@ class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Offset a wire on a planar face.
+     *
+     * Returns a new wire handle.
+     * @param {number} face
+     * @param {number} distance
+     * @returns {number}
+     */
+    offsetWire(face, distance) {
+        const ret = wasm.brepkernel_offsetWire(this.__wbg_ptr, face, distance);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Pipe sweep: sweep a profile along a NURBS path (no guide).
      *
@@ -4321,41 +4322,6 @@ class BrepKernel {
         }
         return ret[0];
     }
-    /**
-     * Sweep a planar face along a NURBS curve path to create a solid.
-     *
-     * The path is specified as flat arrays for JS interop:
-     * - `path_degree` — polynomial degree of the path curve
-     * - `path_knots` — knot vector
-     * - `path_control_points` — flat `[x,y,z, ...]` control point coordinates
-     * - `path_weights` — per-control-point weights
-     *
-     * Returns a solid handle (`u32`).
-     *
-     * # Errors
-     *
-     * Returns an error if the face handle is invalid, the NURBS arrays have
-     * inconsistent lengths, or the sweep operation fails.
-     * @param {number} face
-     * @param {number} path_degree
-     * @param {Float64Array} path_knots
-     * @param {Float64Array} path_control_points
-     * @param {Float64Array} path_weights
-     * @returns {number}
-     */
-    sweep(face, path_degree, path_knots, path_control_points, path_weights) {
-        const ptr0 = passArrayF64ToWasm0(path_knots, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayF64ToWasm0(path_control_points, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passArrayF64ToWasm0(path_weights, wasm.__wbindgen_malloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.brepkernel_sweep(this.__wbg_ptr, face, path_degree, ptr0, len0, ptr1, len1, ptr2, len2);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] >>> 0;
-    }
     /**
      * Sweep a face along a path defined by a chain of edges.
      *
@@ -4442,6 +4408,41 @@ class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Sweep a planar face along a NURBS curve path to create a solid.
+     *
+     * The path is specified as flat arrays for JS interop:
+     * - `path_degree` — polynomial degree of the path curve
+     * - `path_knots` — knot vector
+     * - `path_control_points` — flat `[x,y,z, ...]` control point coordinates
+     * - `path_weights` — per-control-point weights
+     *
+     * Returns a solid handle (`u32`).
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid, the NURBS arrays have
+     * inconsistent lengths, or the sweep operation fails.
+     * @param {number} face
+     * @param {number} path_degree
+     * @param {Float64Array} path_knots
+     * @param {Float64Array} path_control_points
+     * @param {Float64Array} path_weights
+     * @returns {number}
+     */
+    sweep(face, path_degree, path_knots, path_control_points, path_weights) {
+        const ptr0 = passArrayF64ToWasm0(path_knots, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(path_control_points, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayF64ToWasm0(path_weights, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_sweep(this.__wbg_ptr, face, path_degree, ptr0, len0, ptr1, len1, ptr2, len2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Tessellate an edge curve into polyline segments.
      *
@@ -4481,9 +4482,13 @@ class BrepKernel {
         return JsMesh.__wrap(ret[0]);
     }
     /**
-     * Tessellate all faces of a solid into a single merged triangle mesh.
+     * Tessellate a solid with per-face grouping, returned as packed binary
+     * buffers ([`JsGroupedMesh`]) instead of a JSON string.
      *
-     * Includes both the outer shell and any inner shells (voids).
+     * Identical geometry to [`tessellate_solid_grouped`](Self::tessellate_solid_grouped),
+     * but the mesh crosses the WASM boundary as `Float32Array`/`Uint32Array`
+     * bulk copies rather than a (potentially multi-megabyte) JSON string that
+     * the caller must `JSON.parse` and re-pack — far cheaper for large meshes.
      *
      * # Errors
      *
@@ -4491,14 +4496,14 @@ class BrepKernel {
      * @param {number} solid
      * @param {number} deflection
      * @param {number | null} [angular_tolerance]
-     * @returns {JsMesh}
+     * @returns {JsGroupedMesh}
      */
-    tessellateSolid(solid, deflection, angular_tolerance) {
-        const ret = wasm.brepkernel_tessellateSolid(this.__wbg_ptr, solid, deflection, !isLikeNone(angular_tolerance), isLikeNone(angular_tolerance) ? 0 : angular_tolerance);
+    tessellateSolidGroupedBinary(solid, deflection, angular_tolerance) {
+        const ret = wasm.brepkernel_tessellateSolidGroupedBinary(this.__wbg_ptr, solid, deflection, !isLikeNone(angular_tolerance), isLikeNone(angular_tolerance) ? 0 : angular_tolerance);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return JsMesh.__wrap(ret[0]);
+        return JsGroupedMesh.__wrap(ret[0]);
     }
     /**
      * Tessellate a solid with per-face triangle grouping.
@@ -4523,13 +4528,12 @@ class BrepKernel {
         return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Tessellate a solid with per-face grouping, returned as packed binary
-     * buffers ([`JsGroupedMesh`]) instead of a JSON string.
+     * Tessellate a solid and include per-vertex UV coordinates.
      *
-     * Identical geometry to [`tessellate_solid_grouped`](Self::tessellate_solid_grouped),
-     * but the mesh crosses the WASM boundary as `Float32Array`/`Uint32Array`
-     * bulk copies rather than a (potentially multi-megabyte) JSON string that
-     * the caller must `JSON.parse` and re-pack — far cheaper for large meshes.
+     * Returns a JSON string containing `{ positions, normals, indices, uvs }`.
+     * `uvs` is a flat array of `[u0, v0, u1, v1, ...]` values, two per vertex.
+     * For analytic and NURBS surfaces, these are the parametric (u, v) values.
+     * For planar faces, UVs are computed by projection onto the face plane.
      *
      * # Errors
      *
@@ -4537,22 +4541,19 @@ class BrepKernel {
      * @param {number} solid
      * @param {number} deflection
      * @param {number | null} [angular_tolerance]
-     * @returns {JsGroupedMesh}
+     * @returns {any}
      */
-    tessellateSolidGroupedBinary(solid, deflection, angular_tolerance) {
-        const ret = wasm.brepkernel_tessellateSolidGroupedBinary(this.__wbg_ptr, solid, deflection, !isLikeNone(angular_tolerance), isLikeNone(angular_tolerance) ? 0 : angular_tolerance);
+    tessellateSolidUV(solid, deflection, angular_tolerance) {
+        const ret = wasm.brepkernel_tessellateSolidUV(this.__wbg_ptr, solid, deflection, !isLikeNone(angular_tolerance), isLikeNone(angular_tolerance) ? 0 : angular_tolerance);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return JsGroupedMesh.__wrap(ret[0]);
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Tessellate a solid and include per-vertex UV coordinates.
+     * Tessellate all faces of a solid into a single merged triangle mesh.
      *
-     * Returns a JSON string containing `{ positions, normals, indices, uvs }`.
-     * `uvs` is a flat array of `[u0, v0, u1, v1, ...]` values, two per vertex.
-     * For analytic and NURBS surfaces, these are the parametric (u, v) values.
-     * For planar faces, UVs are computed by projection onto the face plane.
+     * Includes both the outer shell and any inner shells (voids).
      *
      * # Errors
      *
@@ -4560,14 +4561,14 @@ class BrepKernel {
      * @param {number} solid
      * @param {number} deflection
      * @param {number | null} [angular_tolerance]
-     * @returns {any}
+     * @returns {JsMesh}
      */
-    tessellateSolidUV(solid, deflection, angular_tolerance) {
-        const ret = wasm.brepkernel_tessellateSolidUV(this.__wbg_ptr, solid, deflection, !isLikeNone(angular_tolerance), isLikeNone(angular_tolerance) ? 0 : angular_tolerance);
+    tessellateSolid(solid, deflection, angular_tolerance) {
+        const ret = wasm.brepkernel_tessellateSolid(this.__wbg_ptr, solid, deflection, !isLikeNone(angular_tolerance), isLikeNone(angular_tolerance) ? 0 : angular_tolerance);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return takeFromExternrefTable0(ret[0]);
+        return JsMesh.__wrap(ret[0]);
     }
     /**
      * Thicken a face into a solid by offsetting it by the given distance.
@@ -4717,24 +4718,6 @@ class BrepKernel {
         }
         return ret[0] >>> 0;
     }
-    /**
-     * Validate a solid, returning the number of errors found.
-     *
-     * Returns 0 if the solid is valid.
-     *
-     * # Errors
-     *
-     * Returns an error if the solid handle is invalid.
-     * @param {number} solid
-     * @returns {number}
-     */
-    validateSolid(solid) {
-        const ret = wasm.brepkernel_validateSolid(this.__wbg_ptr, solid);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] >>> 0;
-    }
     /**
      * Validate a solid with relaxed checks suitable for assembled geometry.
      *
@@ -4782,6 +4765,24 @@ class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Validate a solid, returning the number of errors found.
+     *
+     * Returns 0 if the solid is valid.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     * @param {number} solid
+     * @returns {number}
+     */
+    validateSolid(solid) {
+        const ret = wasm.brepkernel_validateSolid(this.__wbg_ptr, solid);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Compute the volume of a solid.
      *
@@ -5281,30 +5282,30 @@ exports.setLogLevel = setLogLevel;
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_408e67f47ca7b58b: function(arg0, arg1) {
+        __wbg_Error_67e7344beaa85059: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg___wbindgen_debug_string_a57024b9c6e4a48b: function(arg0, arg1) {
+        __wbg___wbindgen_debug_string_0e68cf47c9cbd9b0: function(arg0, arg1) {
             const ret = debugString(arg1);
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_throw_bb96b2010945f0bc: function(arg0, arg1) {
+        __wbg___wbindgen_throw_5d9e815e6fdf150f: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_error_a7d28b2f48027251: function(arg0, arg1) {
+        __wbg_error_9a7c95a53b5089ee: function(arg0, arg1) {
             console.error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_log_dec20bc890a282ec: function(arg0, arg1) {
+        __wbg_log_de93bbd8cd4c6d40: function(arg0, arg1) {
             console.log(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_warn_3a0fa1e78637ae93: function(arg0, arg1) {
+        __wbg_warn_9f576b1eee065769: function(arg0, arg1) {
             console.warn(getStringFromWasm0(arg0, arg1));
         },
-        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+        __wbindgen_generic_0000000000000001: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;