brepkit-wasm 2.4.1 → 2.5.0

package/brepkit_wasm.d.ts

@@ -235,13 +235,13 @@ export class BrepKernel {
     /**
      * Build a convex hull solid from a point cloud.
      *
-     * Uses a simple Quickhull-inspired algorithm for 3D point sets.
+     * Uses the Quickhull algorithm for 3D point sets.
      *
      * Returns a solid handle (`u32`).
      *
      * # Errors
      *
-     * Returns an error if fewer than 4 points are provided.
+     * Returns an error if fewer than 4 non-coplanar points are provided.
      */
     convexHull(coords: Float64Array): number;
     /**
@@ -549,6 +549,10 @@ export class BrepKernel {
      * Apply variable-radius fillets to edges.
      *
      * `json` is a JSON string: `[{"edge": u32, "law": "constant"|"linear"|"scurve", "start": f64, "end": f64}]`
+     *
+     * Also accepts brepjs-style fields: `startRadius`/`endRadius` as aliases for `start`/`end`.
+     * When `law` is omitted and `startRadius` != `endRadius`, the law auto-detects as `"linear"`.
+     *
      * Returns a new solid handle.
      */
     filletVariable(solid: number, json: string): number;
@@ -561,10 +565,11 @@ export class BrepKernel {
     /**
      * Reconstruct a solid from a `toBREP` JSON string.
      *
-     * Currently supports planar faces with line edges. Non-line edges are
-     * approximated as lines (straight segments between start/end vertices).
-     * Non-planar surfaces are approximated as planes computed from the wire
-     * vertex positions.
+     * Supports all edge curve types (line, circle, ellipse, NURBS) and
+     * all surface types (plane, cylinder, cone, sphere, torus, NURBS)
+     * via `curveParams` and `surfaceParams` in the JSON. Unrecognized
+     * edge types fall back to lines; unrecognized surface types fall back
+     * to planes computed from wire vertices.
      *
      * Returns a solid handle.
      *
@@ -1252,6 +1257,18 @@ export class BrepKernel {
      * Returns a new wire handle.
      */
     offsetWire(face: number, distance: number): number;
+    /**
+     * Offset a wire on a planar face with a specific join type.
+     *
+     * `join_type` must be one of `"intersection"`, `"arc"`, or `"chamfer"`.
+     * Returns a new wire handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid, the join type string
+     * is unrecognized, or the offset operation fails.
+     */
+    offsetWireWithJoinType(face: number, distance: number, join_type: string): number;
     /**
      * Pipe sweep: sweep a profile along a NURBS path (no guide).
      *
@@ -1453,13 +1470,13 @@ export class BrepKernel {
     /**
      * Compute minimum distance between two solids.
      *
-     * Returns `[distance]`.
+     * Returns `[distance, point_a_x, point_a_y, point_a_z, point_b_x, point_b_y, point_b_z]`.
      *
      * # Errors
      *
      * Returns an error if either solid handle is invalid.
      */
-    solidToSolidDistance(a: number, b: number): number;
+    solidToSolidDistance(a: number, b: number): Float64Array;
     /**
      * Split a solid into two halves along a plane.
      *
@@ -1527,9 +1544,10 @@ export class BrepKernel {
      *
      * `contact_mode`: "rmf" (default), "fixed", or "constantNormal:x,y,z"
      * `scale_values`: flat `[t0,s0,t1,s1,...]` pairs for piecewise-linear scale law.
+     * `corner_mode`: "smooth" (default), "miter", or "round"
      * Returns a solid handle.
      */
-    sweepWithOptions(profile: number, path_edge: number, contact_mode: string, scale_values: Float64Array, segments: number): number;
+    sweepWithOptions(profile: number, path_edge: number, contact_mode: string, scale_values: Float64Array, segments: number, corner_mode: string): number;
     /**
      * Tessellate an edge curve into polyline segments.
      *
@@ -1663,6 +1681,20 @@ export class BrepKernel {
      * Returns an error if the solid handle is invalid.
      */
     validateSolidRelaxed(solid: number): number;
+    /**
+     * Validate a solid with configurable tolerance scaling.
+     *
+     * `tolerance_scale` multiplies geometric tolerances used for the
+     * face-normal and face-area checks. Use `10.0` to reduce false
+     * positives on NURBS faces from fillet/shell operations.
+     *
+     * Returns 0 if the solid is valid.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     */
+    validateSolidWithOptions(solid: number, tolerance_scale: number): number;
     /**
      * Compute the volume of a solid.
      *

package/brepkit_wasm_bg.js

@@ -508,13 +508,13 @@ export class BrepKernel {
     /**
      * Build a convex hull solid from a point cloud.
      *
-     * Uses a simple Quickhull-inspired algorithm for 3D point sets.
+     * Uses the Quickhull algorithm for 3D point sets.
      *
      * Returns a solid handle (`u32`).
      *
      * # Errors
      *
-     * Returns an error if fewer than 4 points are provided.
+     * Returns an error if fewer than 4 non-coplanar points are provided.
      * @param {Float64Array} coords
      * @returns {number}
      */
@@ -1215,6 +1215,10 @@ export class BrepKernel {
      * Apply variable-radius fillets to edges.
      *
      * `json` is a JSON string: `[{"edge": u32, "law": "constant"|"linear"|"scurve", "start": f64, "end": f64}]`
+     *
+     * Also accepts brepjs-style fields: `startRadius`/`endRadius` as aliases for `start`/`end`.
+     * When `law` is omitted and `startRadius` != `endRadius`, the law auto-detects as `"linear"`.
+     *
      * Returns a new solid handle.
      * @param {number} solid
      * @param {string} json
@@ -1246,10 +1250,11 @@ export class BrepKernel {
     /**
      * Reconstruct a solid from a `toBREP` JSON string.
      *
-     * Currently supports planar faces with line edges. Non-line edges are
-     * approximated as lines (straight segments between start/end vertices).
-     * Non-planar surfaces are approximated as planes computed from the wire
-     * vertex positions.
+     * Supports all edge curve types (line, circle, ellipse, NURBS) and
+     * all surface types (plane, cylinder, cone, sphere, torus, NURBS)
+     * via `curveParams` and `surfaceParams` in the JSON. Unrecognized
+     * edge types fall back to lines; unrecognized surface types fall back
+     * to planes computed from wire vertices.
      *
      * Returns a solid handle.
      *
@@ -2844,6 +2849,30 @@ export class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Offset a wire on a planar face with a specific join type.
+     *
+     * `join_type` must be one of `"intersection"`, `"arc"`, or `"chamfer"`.
+     * Returns a new wire handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid, the join type string
+     * is unrecognized, or the offset operation fails.
+     * @param {number} face
+     * @param {number} distance
+     * @param {string} join_type
+     * @returns {number}
+     */
+    offsetWireWithJoinType(face, distance, join_type) {
+        const ptr0 = passStringToWasm0(join_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_offsetWireWithJoinType(this.__wbg_ptr, face, distance, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Pipe sweep: sweep a profile along a NURBS path (no guide).
      *
@@ -3336,21 +3365,23 @@ export class BrepKernel {
     /**
      * Compute minimum distance between two solids.
      *
-     * Returns `[distance]`.
+     * Returns `[distance, point_a_x, point_a_y, point_a_z, point_b_x, point_b_y, point_b_z]`.
      *
      * # Errors
      *
      * Returns an error if either solid handle is invalid.
      * @param {number} a
      * @param {number} b
-     * @returns {number}
+     * @returns {Float64Array}
      */
     solidToSolidDistance(a, b) {
         const ret = wasm.brepkernel_solidToSolidDistance(this.__wbg_ptr, a, b);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
         }
-        return ret[0];
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
      * Split a solid into two halves along a plane.
@@ -3491,20 +3522,24 @@ export class BrepKernel {
      *
      * `contact_mode`: "rmf" (default), "fixed", or "constantNormal:x,y,z"
      * `scale_values`: flat `[t0,s0,t1,s1,...]` pairs for piecewise-linear scale law.
+     * `corner_mode`: "smooth" (default), "miter", or "round"
      * Returns a solid handle.
      * @param {number} profile
      * @param {number} path_edge
      * @param {string} contact_mode
      * @param {Float64Array} scale_values
      * @param {number} segments
+     * @param {string} corner_mode
      * @returns {number}
      */
-    sweepWithOptions(profile, path_edge, contact_mode, scale_values, segments) {
+    sweepWithOptions(profile, path_edge, contact_mode, scale_values, segments, corner_mode) {
         const ptr0 = passStringToWasm0(contact_mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayF64ToWasm0(scale_values, wasm.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.brepkernel_sweepWithOptions(this.__wbg_ptr, profile, path_edge, ptr0, len0, ptr1, len1, segments);
+        const ptr2 = passStringToWasm0(corner_mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_sweepWithOptions(this.__wbg_ptr, profile, path_edge, ptr0, len0, ptr1, len1, segments, ptr2, len2);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -3759,6 +3794,29 @@ export class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Validate a solid with configurable tolerance scaling.
+     *
+     * `tolerance_scale` multiplies geometric tolerances used for the
+     * face-normal and face-area checks. Use `10.0` to reduce false
+     * positives on NURBS faces from fillet/shell operations.
+     *
+     * Returns 0 if the solid is valid.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     * @param {number} solid
+     * @param {number} tolerance_scale
+     * @returns {number}
+     */
+    validateSolidWithOptions(solid, tolerance_scale) {
+        const ret = wasm.brepkernel_validateSolidWithOptions(this.__wbg_ptr, solid, tolerance_scale);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Compute the volume of a solid.
      *

package/brepkit_wasm_node.cjs

@@ -510,13 +510,13 @@ class BrepKernel {
     /**
      * Build a convex hull solid from a point cloud.
      *
-     * Uses a simple Quickhull-inspired algorithm for 3D point sets.
+     * Uses the Quickhull algorithm for 3D point sets.
      *
      * Returns a solid handle (`u32`).
      *
      * # Errors
      *
-     * Returns an error if fewer than 4 points are provided.
+     * Returns an error if fewer than 4 non-coplanar points are provided.
      * @param {Float64Array} coords
      * @returns {number}
      */
@@ -1217,6 +1217,10 @@ class BrepKernel {
      * Apply variable-radius fillets to edges.
      *
      * `json` is a JSON string: `[{"edge": u32, "law": "constant"|"linear"|"scurve", "start": f64, "end": f64}]`
+     *
+     * Also accepts brepjs-style fields: `startRadius`/`endRadius` as aliases for `start`/`end`.
+     * When `law` is omitted and `startRadius` != `endRadius`, the law auto-detects as `"linear"`.
+     *
      * Returns a new solid handle.
      * @param {number} solid
      * @param {string} json
@@ -1248,10 +1252,11 @@ class BrepKernel {
     /**
      * Reconstruct a solid from a `toBREP` JSON string.
      *
-     * Currently supports planar faces with line edges. Non-line edges are
-     * approximated as lines (straight segments between start/end vertices).
-     * Non-planar surfaces are approximated as planes computed from the wire
-     * vertex positions.
+     * Supports all edge curve types (line, circle, ellipse, NURBS) and
+     * all surface types (plane, cylinder, cone, sphere, torus, NURBS)
+     * via `curveParams` and `surfaceParams` in the JSON. Unrecognized
+     * edge types fall back to lines; unrecognized surface types fall back
+     * to planes computed from wire vertices.
      *
      * Returns a solid handle.
      *
@@ -2846,6 +2851,30 @@ class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Offset a wire on a planar face with a specific join type.
+     *
+     * `join_type` must be one of `"intersection"`, `"arc"`, or `"chamfer"`.
+     * Returns a new wire handle.
+     *
+     * # Errors
+     *
+     * Returns an error if the face handle is invalid, the join type string
+     * is unrecognized, or the offset operation fails.
+     * @param {number} face
+     * @param {number} distance
+     * @param {string} join_type
+     * @returns {number}
+     */
+    offsetWireWithJoinType(face, distance, join_type) {
+        const ptr0 = passStringToWasm0(join_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_offsetWireWithJoinType(this.__wbg_ptr, face, distance, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Pipe sweep: sweep a profile along a NURBS path (no guide).
      *
@@ -3338,21 +3367,23 @@ class BrepKernel {
     /**
      * Compute minimum distance between two solids.
      *
-     * Returns `[distance]`.
+     * Returns `[distance, point_a_x, point_a_y, point_a_z, point_b_x, point_b_y, point_b_z]`.
      *
      * # Errors
      *
      * Returns an error if either solid handle is invalid.
      * @param {number} a
      * @param {number} b
-     * @returns {number}
+     * @returns {Float64Array}
      */
     solidToSolidDistance(a, b) {
         const ret = wasm.brepkernel_solidToSolidDistance(this.__wbg_ptr, a, b);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
         }
-        return ret[0];
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
      * Split a solid into two halves along a plane.
@@ -3493,20 +3524,24 @@ class BrepKernel {
      *
      * `contact_mode`: "rmf" (default), "fixed", or "constantNormal:x,y,z"
      * `scale_values`: flat `[t0,s0,t1,s1,...]` pairs for piecewise-linear scale law.
+     * `corner_mode`: "smooth" (default), "miter", or "round"
      * Returns a solid handle.
      * @param {number} profile
      * @param {number} path_edge
      * @param {string} contact_mode
      * @param {Float64Array} scale_values
      * @param {number} segments
+     * @param {string} corner_mode
      * @returns {number}
      */
-    sweepWithOptions(profile, path_edge, contact_mode, scale_values, segments) {
+    sweepWithOptions(profile, path_edge, contact_mode, scale_values, segments, corner_mode) {
         const ptr0 = passStringToWasm0(contact_mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayF64ToWasm0(scale_values, wasm.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.brepkernel_sweepWithOptions(this.__wbg_ptr, profile, path_edge, ptr0, len0, ptr1, len1, segments);
+        const ptr2 = passStringToWasm0(corner_mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.brepkernel_sweepWithOptions(this.__wbg_ptr, profile, path_edge, ptr0, len0, ptr1, len1, segments, ptr2, len2);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -3761,6 +3796,29 @@ class BrepKernel {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * Validate a solid with configurable tolerance scaling.
+     *
+     * `tolerance_scale` multiplies geometric tolerances used for the
+     * face-normal and face-area checks. Use `10.0` to reduce false
+     * positives on NURBS faces from fillet/shell operations.
+     *
+     * Returns 0 if the solid is valid.
+     *
+     * # Errors
+     *
+     * Returns an error if the solid handle is invalid.
+     * @param {number} solid
+     * @param {number} tolerance_scale
+     * @returns {number}
+     */
+    validateSolidWithOptions(solid, tolerance_scale) {
+        const ret = wasm.brepkernel_validateSolidWithOptions(this.__wbg_ptr, solid, tolerance_scale);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Compute the volume of a solid.
      *

package/package.json

@@ -2,7 +2,7 @@
   "name": "brepkit-wasm",
   "type": "module",
   "description": "WebAssembly bindings for brepkit — browser-native B-Rep solid modeling",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "license": "AGPL-3.0-only",
   "repository": {
     "type": "git",