brepkit-wasm 0.5.1 → 0.5.3

package/brepkit_wasm.d.ts

@@ -99,6 +99,14 @@ export class BrepKernel {
      * Returns an error if distance is non-positive or edges are invalid.
      */
     chamfer(solid: number, edge_handles: Uint32Array, distance: number): number;
+    /**
+     * Cut corners of a 2D polygon with flat bevels.
+     *
+     * `coords` is a flat array `[x,y, x,y, ...]`.
+     * `distance` is the chamfer distance from each corner.
+     * Returns a flat array of the chamfered polygon coordinates.
+     */
+    chamfer2d(coords: Float64Array, distance: number): Float64Array;
     /**
      * Create a circular pattern of a solid around an axis.
      *
@@ -127,6 +135,25 @@ export class BrepKernel {
      * Returns "inside", "outside", or "boundary".
      */
     classifyPointWinding(solid: number, x: number, y: number, z: number, tolerance: number): string;
+    /**
+     * Find common (shared) edges between two adjacent 2D polygons.
+     *
+     * Both polygons are flat arrays `[x,y, x,y, ...]`.
+     * Returns a flat array of common segment endpoints `[x1,y1, x2,y2, ...]`,
+     * or an empty array if no common segments exist.
+     */
+    commonSegment2d(coords_a: Float64Array, coords_b: Float64Array): Float64Array;
+    /**
+     * Compose (multiply) two 4x4 transformation matrices.
+     *
+     * Returns the composed matrix as a flat 16-element array (row-major).
+     * This computes `a * b`, meaning `b` is applied first, then `a`.
+     *
+     * # Errors
+     *
+     * Returns an error if either matrix doesn't have 16 elements.
+     */
+    composeTransforms(matrix_a: Float64Array, matrix_b: Float64Array): Float64Array;
     /**
      * Build a convex hull solid from a point cloud.
      *
@@ -424,6 +451,14 @@ export class BrepKernel {
      * Returns an error if radius is non-positive or edges are invalid.
      */
     fillet(solid: number, edge_handles: Uint32Array, radius: number): number;
+    /**
+     * Round corners of a 2D polygon by inserting arc-approximation vertices.
+     *
+     * `coords` is a flat array `[x,y, x,y, ...]`.
+     * `radius` is the fillet radius.
+     * Returns a flat array of the filleted polygon coordinates.
+     */
+    fillet2d(coords: Float64Array, radius: number): Float64Array;
     /**
      * Apply variable-radius fillets to edges.
      *
@@ -487,6 +522,10 @@ export class BrepKernel {
      * Get the curve type of an edge.
      *
      * Returns `"LINE"`, `"BSPLINE_CURVE"`, `"CIRCLE"`, or `"ELLIPSE"`.
+     *
+     * For NURBS curves that exactly represent analytic curves, this
+     * returns the underlying analytic type (e.g. `"CIRCLE"` for a
+     * rational NURBS circle).
      */
     getEdgeCurveType(edge: number): string;
     /**
@@ -552,6 +591,13 @@ export class BrepKernel {
      * Returns an array of vertex handles (`u32[]`).
      */
     getFaceVertices(face: number): Uint32Array;
+    /**
+     * Get all wires of a face (outer wire first, then inner/hole wires).
+     *
+     * # Errors
+     * Returns an error if the face handle is invalid.
+     */
+    getFaceWires(face: number): Uint32Array;
     /**
      * Get the orientation of a shape.
      *
@@ -610,6 +656,10 @@ export class BrepKernel {
      *
      * Returns one of: `"plane"`, `"cylinder"`, `"cone"`, `"sphere"`,
      * `"torus"`, `"bspline"`.
+     *
+     * For NURBS surfaces that exactly represent analytic shapes, this
+     * returns the underlying analytic type (e.g. `"sphere"` for a NURBS
+     * sphere patch).
      */
     getSurfaceType(face: number): string;
     /**
@@ -681,6 +731,18 @@ export class BrepKernel {
      * Returns an error if the IGES data is malformed.
      */
     importIges(data: Uint8Array): Uint32Array;
+    /**
+     * Import a triangle mesh from flat vertex/index arrays.
+     *
+     * `positions` is a flat `[x0,y0,z0, x1,y1,z1, ...]` array.
+     * `indices` is a flat `[i0,i1,i2, i3,i4,i5, ...]` array of triangle
+     * vertex indices. Returns a solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the arrays are malformed or mesh import fails.
+     */
+    importIndexedMesh(positions: Float64Array, indices: Uint32Array): number;
     /**
      * Import an OBJ file and return a solid handle.
      *
@@ -735,6 +797,16 @@ export class BrepKernel {
      * produces an empty result.
      */
     intersect(a: number, b: number): number;
+    /**
+     * Compute the boolean intersection of two 2D polygons.
+     *
+     * Both polygons are flat arrays `[x,y, x,y, ...]`.
+     * Returns a flat array of the intersection polygon coordinates,
+     * or an empty array if they don't intersect.
+     *
+     * Uses the Sutherland-Hodgman algorithm (convex clipper).
+     */
+    intersectPolygons2d(coords_a: Float64Array, coords_b: Float64Array): Float64Array;
     /**
      * Intersect two solids and return evolution tracking data.
      *
@@ -752,6 +824,10 @@ export class BrepKernel {
      * Returns `true` if the edge is forward in the wire, `false` if reversed.
      */
     isEdgeForwardInWire(edge: number, wire: number): boolean;
+    /**
+     * Check whether a wire is closed (last edge connects back to first).
+     */
+    isWireClosed(wire: number): boolean;
     /**
      * Create a linear pattern of a solid.
      *
@@ -788,6 +864,15 @@ export class BrepKernel {
      * different vertex counts, or surface fitting fails.
      */
     loftSmooth(faces: Uint32Array): number;
+    /**
+     * Loft profiles with options for start/end points and ruled mode.
+     *
+     * `options` is a JSON string with optional fields:
+     * - `startPoint: [x, y, z]` — apex point before first profile
+     * - `endPoint: [x, y, z]` — apex point after last profile
+     * - `ruled: bool` — true for ruled (linear) surfaces (default), false for smooth
+     */
+    loftWithOptions(faces: Uint32Array, options: string): number;
     /**
      * Create a box solid with the given dimensions, centered at the origin.
      *
@@ -842,6 +927,16 @@ export class BrepKernel {
      * Returns an error if radius or height is non-positive.
      */
     makeCylinder(radius: number, height: number): number;
+    /**
+     * Create an ellipsoid solid centered at the origin.
+     *
+     * Built by creating a unit sphere and scaling it by `(rx, ry, rz)`.
+     *
+     * # Errors
+     *
+     * Returns an error if any radius is non-positive.
+     */
+    makeEllipsoid(rx: number, ry: number, rz: number): number;
     /**
      * Create a planar face from a wire (computes normal from first 3 vertices).
      *
@@ -895,6 +990,13 @@ export class BrepKernel {
      * Returns a wire handle.
      */
     makeRegularPolygonWire(radius: number, n_sides: number): number;
+    /**
+     * Create a solid from a set of faces by sewing them together.
+     *
+     * Alias for `sewFaces` with a default tolerance. This is the equivalent
+     * of OCCT's `BRepBuilderAPI_MakeSolid`.
+     */
+    makeSolid(face_handles: Uint32Array): number;
     /**
      * Create a sphere solid centered at the origin.
      *
@@ -927,6 +1029,20 @@ export class BrepKernel {
      * Returns a wire handle (`u32`).
      */
     makeWire(edge_handles: Uint32Array, closed: boolean): number;
+    /**
+     * Measure curvature of an edge curve at parameter `t`.
+     *
+     * Returns `[curvature, tangent_x, tangent_y, tangent_z, normal_x, normal_y, normal_z]`.
+     * Curvature is 1/radius. For lines, curvature is 0.
+     */
+    measureCurvatureAtEdge(edge: number, t: number): Float64Array;
+    /**
+     * Measure principal curvatures at (u, v) on a face surface.
+     *
+     * Returns `[k1, k2, d1x, d1y, d1z, d2x, d2y, d2z]` where k1/k2 are
+     * principal curvatures and d1/d2 are the corresponding direction vectors.
+     */
+    measureCurvatureAtSurface(face: number, u: number, v: number): Float64Array;
     /**
      * Merge coincident vertices in a solid.
      *
@@ -1003,6 +1119,33 @@ export class BrepKernel {
      * Returns an error if the face or path is invalid.
      */
     pipe(face: number, path_degree: number, path_knots: Float64Array, path_control_points: Float64Array, path_weights: Float64Array): number;
+    /**
+     * Test if a 2D point is inside a closed polygon.
+     *
+     * `polygon_coords` is a flat array `[x,y, x,y, ...]`.
+     * Returns `true` if the point is inside the polygon (winding number test).
+     */
+    pointInPolygon2d(polygon_coords: Float64Array, px: number, py: number): boolean;
+    /**
+     * Compute minimum distance from a point to an edge.
+     *
+     * Returns `[distance, closest_x, closest_y, closest_z]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the edge handle is invalid.
+     */
+    pointToEdgeDistance(px: number, py: number, pz: number, edge: number): Float64Array;
+    /**
+     * Compute minimum distance from a point to a face.
+     *
+     * Returns `[distance, closest_x, closest_y, closest_z]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid.
+     */
+    pointToFaceDistance(px: number, py: number, pz: number, face: number): Float64Array;
     /**
      * Compute minimum distance from a point to a solid.
      *
@@ -1013,6 +1156,14 @@ export class BrepKernel {
      * Returns an error if the solid handle is invalid.
      */
     pointToSolidDistance(px: number, py: number, pz: number, solid: number): Float64Array;
+    /**
+     * Test if two 2D polygons intersect (overlap).
+     *
+     * Both polygons are flat arrays `[x,y, x,y, ...]`.
+     * Returns `true` if any vertex of one polygon is inside the other
+     * or if any edges cross.
+     */
+    polygonsIntersect2d(coords_a: Float64Array, coords_b: Float64Array): boolean;
     /**
      * Project a 3D point onto a face surface using Newton iteration.
      *
@@ -1031,6 +1182,10 @@ export class BrepKernel {
      * Returns the number of edges removed.
      */
     removeDegenerateEdges(solid: number, tolerance: number): number;
+    /**
+     * Remove all holes from a face, returning a new face with only the outer wire.
+     */
+    removeHolesFromFace(face: number): number;
     /**
      * Validate, heal, and re-validate a solid in one pass.
      *
@@ -1241,6 +1396,50 @@ export class BrepKernel {
      * Returns an error if the solid handle is invalid or tessellation fails.
      */
     tessellateSolid(solid: number, deflection: number): JsMesh;
+    /**
+     * Tessellate a solid with per-face triangle grouping.
+     *
+     * Returns a JSON string containing `{ positions, normals, indices, faceOffsets }`.
+     * `faceOffsets` is an array where `faceOffsets[i]` is the start index into
+     * `indices` for face `i`, and the last element is `indices.length`.
+     */
+    tessellateSolidGrouped(solid: number, deflection: number): any;
+    /**
+     * Tessellate a solid and include per-vertex UV coordinates.
+     *
+     * 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
+     *
+     * Returns an error if the solid handle is invalid or tessellation fails.
+     */
+    tessellateSolidUV(solid: number, deflection: number): any;
+    /**
+     * Thicken a face into a solid by offsetting it by the given distance.
+     *
+     * Creates a solid from a face by extruding it along its normal by
+     * `thickness`. Positive values offset outward, negative inward.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid or thickness is zero.
+     */
+    thicken(face: number, thickness: number): number;
+    /**
+     * Serialize a solid's B-Rep topology to JSON.
+     *
+     * Returns a JSON string containing the solid's complete topology:
+     * vertices, edges (with curve types), faces (with surface types), and
+     * connectivity information.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    toBREP(solid: number): any;
     /**
      * Apply a 4×4 affine transform to a solid (in place).
      *
@@ -1287,6 +1486,17 @@ export class BrepKernel {
      * Returns an error if the solid handle is invalid or tessellation fails.
      */
     volume(solid: number, deflection: number): number;
+    /**
+     * Weld shells and faces into a single solid by sewing.
+     *
+     * Accepts an array of face handles from potentially different shells.
+     * Sews all faces together into a single solid.
+     */
+    weldShellsAndFaces(face_handles: Uint32Array, tolerance: number): number;
+    /**
+     * Compute the total arc-length of a wire.
+     */
+    wireLength(wire: number): number;
 }
 
 /**

package/brepkit_wasm_bg.js

@@ -279,6 +279,27 @@ export class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Cut corners of a 2D polygon with flat bevels.
+     *
+     * `coords` is a flat array `[x,y, x,y, ...]`.
+     * `distance` is the chamfer distance from each corner.
+     * Returns a flat array of the chamfered polygon coordinates.
+     * @param {Float64Array} coords
+     * @param {number} distance
+     * @returns {Float64Array}
+     */
+    chamfer2d(coords, distance) {
+        const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_chamfer2d(this.__wbg_ptr, ptr0, len0, distance);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
     /**
      * Create a circular pattern of a solid around an axis.
      *
@@ -388,6 +409,55 @@ export class BrepKernel {
             wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
+    /**
+     * Find common (shared) edges between two adjacent 2D polygons.
+     *
+     * Both polygons are flat arrays `[x,y, x,y, ...]`.
+     * Returns a flat array of common segment endpoints `[x1,y1, x2,y2, ...]`,
+     * or an empty array if no common segments exist.
+     * @param {Float64Array} coords_a
+     * @param {Float64Array} coords_b
+     * @returns {Float64Array}
+     */
+    commonSegment2d(coords_a, coords_b) {
+        const ptr0 = passArrayF64ToWasm0(coords_a, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(coords_b, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_commonSegment2d(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v3;
+    }
+    /**
+     * Compose (multiply) two 4x4 transformation matrices.
+     *
+     * Returns the composed matrix as a flat 16-element array (row-major).
+     * This computes `a * b`, meaning `b` is applied first, then `a`.
+     *
+     * # Errors
+     *
+     * Returns an error if either matrix doesn't have 16 elements.
+     * @param {Float64Array} matrix_a
+     * @param {Float64Array} matrix_b
+     * @returns {Float64Array}
+     */
+    composeTransforms(matrix_a, matrix_b) {
+        const ptr0 = passArrayF64ToWasm0(matrix_a, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(matrix_b, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_composeTransforms(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v3;
+    }
     /**
      * Build a convex hull solid from a point cloud.
      *
@@ -1059,6 +1129,27 @@ export class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Round corners of a 2D polygon by inserting arc-approximation vertices.
+     *
+     * `coords` is a flat array `[x,y, x,y, ...]`.
+     * `radius` is the fillet radius.
+     * Returns a flat array of the filleted polygon coordinates.
+     * @param {Float64Array} coords
+     * @param {number} radius
+     * @returns {Float64Array}
+     */
+    fillet2d(coords, radius) {
+        const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_fillet2d(this.__wbg_ptr, ptr0, len0, radius);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
     /**
      * Apply variable-radius fillets to edges.
      *
@@ -1198,6 +1289,10 @@ export class BrepKernel {
      * Get the curve type of an edge.
      *
      * Returns `"LINE"`, `"BSPLINE_CURVE"`, `"CIRCLE"`, or `"ELLIPSE"`.
+     *
+     * For NURBS curves that exactly represent analytic curves, this
+     * returns the underlying analytic type (e.g. `"CIRCLE"` for a
+     * rational NURBS circle).
      * @param {number} edge
      * @returns {string}
      */
@@ -1358,6 +1453,23 @@ export class BrepKernel {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * Get all wires of a face (outer wire first, then inner/hole wires).
+     *
+     * # Errors
+     * Returns an error if the face handle is invalid.
+     * @param {number} face
+     * @returns {Uint32Array}
+     */
+    getFaceWires(face) {
+        const ret = wasm.brepkernel_getFaceWires(this.__wbg_ptr, face);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * Get the orientation of a shape.
      *
@@ -1479,6 +1591,10 @@ export class BrepKernel {
      *
      * Returns one of: `"plane"`, `"cylinder"`, `"cone"`, `"sphere"`,
      * `"torus"`, `"bspline"`.
+     *
+     * For NURBS surfaces that exactly represent analytic shapes, this
+     * returns the underlying analytic type (e.g. `"sphere"` for a NURBS
+     * sphere patch).
      * @param {number} face
      * @returns {string}
      */
@@ -1666,6 +1782,31 @@ export class BrepKernel {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v2;
     }
+    /**
+     * Import a triangle mesh from flat vertex/index arrays.
+     *
+     * `positions` is a flat `[x0,y0,z0, x1,y1,z1, ...]` array.
+     * `indices` is a flat `[i0,i1,i2, i3,i4,i5, ...]` array of triangle
+     * vertex indices. Returns a solid handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the arrays are malformed or mesh import fails.
+     * @param {Float64Array} positions
+     * @param {Uint32Array} indices
+     * @returns {number}
+     */
+    importIndexedMesh(positions, indices) {
+        const ptr0 = passArrayF64ToWasm0(positions, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(indices, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_importIndexedMesh(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Import an OBJ file and return a solid handle.
      *
@@ -1786,6 +1927,31 @@ export class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Compute the boolean intersection of two 2D polygons.
+     *
+     * Both polygons are flat arrays `[x,y, x,y, ...]`.
+     * Returns a flat array of the intersection polygon coordinates,
+     * or an empty array if they don't intersect.
+     *
+     * Uses the Sutherland-Hodgman algorithm (convex clipper).
+     * @param {Float64Array} coords_a
+     * @param {Float64Array} coords_b
+     * @returns {Float64Array}
+     */
+    intersectPolygons2d(coords_a, coords_b) {
+        const ptr0 = passArrayF64ToWasm0(coords_a, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(coords_b, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_intersectPolygons2d(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v3;
+    }
     /**
      * Intersect two solids and return evolution tracking data.
      *
@@ -1821,6 +1987,18 @@ export class BrepKernel {
         }
         return ret[0] !== 0;
     }
+    /**
+     * Check whether a wire is closed (last edge connects back to first).
+     * @param {number} wire
+     * @returns {boolean}
+     */
+    isWireClosed(wire) {
+        const ret = wasm.brepkernel_isWireClosed(this.__wbg_ptr, wire);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
     /**
      * Create a linear pattern of a solid.
      *
@@ -1890,6 +2068,28 @@ export class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Loft profiles with options for start/end points and ruled mode.
+     *
+     * `options` is a JSON string with optional fields:
+     * - `startPoint: [x, y, z]` — apex point before first profile
+     * - `endPoint: [x, y, z]` — apex point after last profile
+     * - `ruled: bool` — true for ruled (linear) surfaces (default), false for smooth
+     * @param {Uint32Array} faces
+     * @param {string} options
+     * @returns {number}
+     */
+    loftWithOptions(faces, options) {
+        const ptr0 = passArray32ToWasm0(faces, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_loftWithOptions(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Create a box solid with the given dimensions, centered at the origin.
      *
@@ -2001,6 +2201,26 @@ export class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Create an ellipsoid solid centered at the origin.
+     *
+     * Built by creating a unit sphere and scaling it by `(rx, ry, rz)`.
+     *
+     * # Errors
+     *
+     * Returns an error if any radius is non-positive.
+     * @param {number} rx
+     * @param {number} ry
+     * @param {number} rz
+     * @returns {number}
+     */
+    makeEllipsoid(rx, ry, rz) {
+        const ret = wasm.brepkernel_makeEllipsoid(this.__wbg_ptr, rx, ry, rz);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Create a planar face from a wire (computes normal from first 3 vertices).
      *
@@ -2136,6 +2356,23 @@ export class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Create a solid from a set of faces by sewing them together.
+     *
+     * Alias for `sewFaces` with a default tolerance. This is the equivalent
+     * of OCCT's `BRepBuilderAPI_MakeSolid`.
+     * @param {Uint32Array} face_handles
+     * @returns {number}
+     */
+    makeSolid(face_handles) {
+        const ptr0 = passArray32ToWasm0(face_handles, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_makeSolid(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Create a sphere solid centered at the origin.
      *
@@ -2208,6 +2445,43 @@ export class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Measure curvature of an edge curve at parameter `t`.
+     *
+     * Returns `[curvature, tangent_x, tangent_y, tangent_z, normal_x, normal_y, normal_z]`.
+     * Curvature is 1/radius. For lines, curvature is 0.
+     * @param {number} edge
+     * @param {number} t
+     * @returns {Float64Array}
+     */
+    measureCurvatureAtEdge(edge, t) {
+        const ret = wasm.brepkernel_measureCurvatureAtEdge(this.__wbg_ptr, edge, t);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Measure principal curvatures at (u, v) on a face surface.
+     *
+     * Returns `[k1, k2, d1x, d1y, d1z, d2x, d2y, d2z]` where k1/k2 are
+     * principal curvatures and d1/d2 are the corresponding direction vectors.
+     * @param {number} face
+     * @param {number} u
+     * @param {number} v
+     * @returns {Float64Array}
+     */
+    measureCurvatureAtSurface(face, u, v) {
+        const ret = wasm.brepkernel_measureCurvatureAtSurface(this.__wbg_ptr, face, u, v);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
     /**
      * Merge coincident vertices in a solid.
      *
@@ -2404,6 +2678,71 @@ export class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Test if a 2D point is inside a closed polygon.
+     *
+     * `polygon_coords` is a flat array `[x,y, x,y, ...]`.
+     * Returns `true` if the point is inside the polygon (winding number test).
+     * @param {Float64Array} polygon_coords
+     * @param {number} px
+     * @param {number} py
+     * @returns {boolean}
+     */
+    pointInPolygon2d(polygon_coords, px, py) {
+        const ptr0 = passArrayF64ToWasm0(polygon_coords, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_pointInPolygon2d(this.__wbg_ptr, ptr0, len0, px, py);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Compute minimum distance from a point to an edge.
+     *
+     * Returns `[distance, closest_x, closest_y, closest_z]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the edge handle is invalid.
+     * @param {number} px
+     * @param {number} py
+     * @param {number} pz
+     * @param {number} edge
+     * @returns {Float64Array}
+     */
+    pointToEdgeDistance(px, py, pz, edge) {
+        const ret = wasm.brepkernel_pointToEdgeDistance(this.__wbg_ptr, px, py, pz, edge);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * Compute minimum distance from a point to a face.
+     *
+     * Returns `[distance, closest_x, closest_y, closest_z]`.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid.
+     * @param {number} px
+     * @param {number} py
+     * @param {number} pz
+     * @param {number} face
+     * @returns {Float64Array}
+     */
+    pointToFaceDistance(px, py, pz, face) {
+        const ret = wasm.brepkernel_pointToFaceDistance(this.__wbg_ptr, px, py, pz, face);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
     /**
      * Compute minimum distance from a point to a solid.
      *
@@ -2427,6 +2766,27 @@ export class BrepKernel {
         wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
         return v1;
     }
+    /**
+     * Test if two 2D polygons intersect (overlap).
+     *
+     * Both polygons are flat arrays `[x,y, x,y, ...]`.
+     * Returns `true` if any vertex of one polygon is inside the other
+     * or if any edges cross.
+     * @param {Float64Array} coords_a
+     * @param {Float64Array} coords_b
+     * @returns {boolean}
+     */
+    polygonsIntersect2d(coords_a, coords_b) {
+        const ptr0 = passArrayF64ToWasm0(coords_a, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(coords_b, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_polygonsIntersect2d(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
     /**
      * Project a 3D point onto a face surface using Newton iteration.
      *
@@ -2487,6 +2847,18 @@ export class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Remove all holes from a face, returning a new face with only the outer wire.
+     * @param {number} face
+     * @returns {number}
+     */
+    removeHolesFromFace(face) {
+        const ret = wasm.brepkernel_removeHolesFromFace(this.__wbg_ptr, face);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Validate, heal, and re-validate a solid in one pass.
      *
@@ -2957,6 +3329,85 @@ export class BrepKernel {
         }
         return JsMesh.__wrap(ret[0]);
     }
+    /**
+     * Tessellate a solid with per-face triangle grouping.
+     *
+     * Returns a JSON string containing `{ positions, normals, indices, faceOffsets }`.
+     * `faceOffsets` is an array where `faceOffsets[i]` is the start index into
+     * `indices` for face `i`, and the last element is `indices.length`.
+     * @param {number} solid
+     * @param {number} deflection
+     * @returns {any}
+     */
+    tessellateSolidGrouped(solid, deflection) {
+        const ret = wasm.brepkernel_tessellateSolidGrouped(this.__wbg_ptr, solid, deflection);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Tessellate a solid and include per-vertex UV coordinates.
+     *
+     * 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
+     *
+     * Returns an error if the solid handle is invalid or tessellation fails.
+     * @param {number} solid
+     * @param {number} deflection
+     * @returns {any}
+     */
+    tessellateSolidUV(solid, deflection) {
+        const ret = wasm.brepkernel_tessellateSolidUV(this.__wbg_ptr, solid, deflection);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Thicken a face into a solid by offsetting it by the given distance.
+     *
+     * Creates a solid from a face by extruding it along its normal by
+     * `thickness`. Positive values offset outward, negative inward.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid or thickness is zero.
+     * @param {number} face
+     * @param {number} thickness
+     * @returns {number}
+     */
+    thicken(face, thickness) {
+        const ret = wasm.brepkernel_thicken(this.__wbg_ptr, face, thickness);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Serialize a solid's B-Rep topology to JSON.
+     *
+     * Returns a JSON string containing the solid's complete topology:
+     * vertices, edges (with curve types), faces (with surface types), and
+     * connectivity information.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     * @param {number} solid
+     * @returns {any}
+     */
+    toBREP(solid) {
+        const ret = wasm.brepkernel_toBREP(this.__wbg_ptr, solid);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Apply a 4×4 affine transform to a solid (in place).
      *
@@ -3048,6 +3499,36 @@ export class BrepKernel {
         }
         return ret[0];
     }
+    /**
+     * Weld shells and faces into a single solid by sewing.
+     *
+     * Accepts an array of face handles from potentially different shells.
+     * Sews all faces together into a single solid.
+     * @param {Uint32Array} face_handles
+     * @param {number} tolerance
+     * @returns {number}
+     */
+    weldShellsAndFaces(face_handles, tolerance) {
+        const ptr0 = passArray32ToWasm0(face_handles, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_weldShellsAndFaces(this.__wbg_ptr, ptr0, len0, tolerance);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
+    /**
+     * Compute the total arc-length of a wire.
+     * @param {number} wire
+     * @returns {number}
+     */
+    wireLength(wire) {
+        const ret = wasm.brepkernel_wireLength(this.__wbg_ptr, wire);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
 }
 if (Symbol.dispose) BrepKernel.prototype[Symbol.dispose] = BrepKernel.prototype.free;
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "brepkit-wasm",
   "type": "module",
   "description": "WebAssembly bindings for brepkit — browser-native B-Rep solid modeling",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",