okgeometry-api 0.5.8 → 1.0.0

package/wasm/README.md

@@ -100,3 +100,5 @@ Available viewers:
 ## License
 
 Copyright Mostafa El Ayoubi / Orkestra Online. All rights reserved.
+
+Boolean-kernel structural ports inspired by Manifold are tracked in [`MANIFOLD_PORT_ATTRIBUTION.md`](./MANIFOLD_PORT_ATTRIBUTION.md).

package/wasm/okgeometrycore.d.ts

@@ -164,36 +164,27 @@ export function mesh_apply_matrix(vertex_count: number, buffer: Float64Array, ma
  */
 export function mesh_boolean_intersection(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array): Float64Array;
 
-/**
- * Perform boolean operation on two meshes
- *
- * # Parameters
- * * `vertex_count_a` - Number of vertices in mesh A
- * * `buffer_a` - Buffer for mesh A [vertices..., indices...]
- * * `vertex_count_b` - Number of vertices in mesh B
- * * `buffer_b` - Buffer for mesh B [vertices..., indices...]
- * * `operation` - Operation type: "union", "intersection", or "subtraction"
- *
- * # Returns
- * Result mesh buffer [vertices..., indices...]
- */
+export function mesh_boolean_last_debug_marker(): number;
+
 export function mesh_boolean_operation(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): Float64Array;
 
 /**
- * Debug helper: perform boolean operation with explicit backend and return a
- * textual status, including kernel error reason on failure.
+ * Debug helper: perform boolean operation and return a textual status,
+ * including kernel error reason on failure.
  */
-export function mesh_boolean_operation_debug(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string, backend: string): string;
+export function mesh_boolean_operation_debug(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): string;
 
 /**
  * Perform boolean operation and return stage-level profiling data followed by
  * the result mesh buffer.
  *
  * Output format:
- * [profile_len(=42), broadphase_ms, segments_ms, split_ms, classify_ms,
- *  classify_seed_ms, classify_strict_ms, classify_open_component_ms,
+ * [profile_len(=95), broadphase_ms, segments_ms, split_ms,
+ *  split_touched_faces_a, split_source_faces_a, split_touched_faces_b, split_source_faces_b,
+ *  classify_ms, classify_seed_ms, classify_strict_ms, classify_open_component_ms,
  *  extract_ms, extract_primary_ms, extract_fallback_ms,
- *  cleanup_ms, finalize_ms, pair_accepted, pair_rejected, pair_degenerate,
+ *  cleanup_ms, finalize_ms, finalize_cap_ms, finalize_recap_ms, finalize_stitch_ms,
+ *  pair_accepted, pair_rejected, pair_degenerate,
  *  core_passes, core_total_ms, conservative_runs, conservative_ms, nudge_runs, nudge_ms,
  *  recompose_runs, recompose_ms, repair_runs, repair_ms,
  *  repair_loops, repair_loops_capped, repair_loop_vertices, repair_loop_max_vertices,
@@ -204,24 +195,63 @@ export function mesh_boolean_operation_debug(vertex_count_a: number, buffer_a: F
  *  arrangement_adj_non_manifold_edges_total, arrangement_adj_non_manifold_limit_total,
  *  arrangement_adj_non_manifold_tolerated_attempts,
  *  arrangement_adj_fallback_non_manifold_excess_total,
+ *  subtraction_ultra_cases, subtraction_ultra_component_fallback_runs,
+ *  subtraction_ultra_open_bounds_total, subtraction_ultra_open_bounds_max,
+ *  subtraction_ultra_best_boundary_total, subtraction_ultra_best_non_manifold_total,
+ *  subtraction_ultra_scoped_faces_total, subtraction_ultra_scoped_faces_max,
+ *  subtraction_ultra_scoped_strict_evals_total, subtraction_ultra_scoped_strict_evals_max,
+ *  finalize_stitch_rebuild_ms, finalize_stitch_recap_ms,
+ *  finalize_stitch_attempts, finalize_stitch_kept,
+ *  finalize_stitch_rebuild_collect_ms, finalize_stitch_rebuild_weld_ms,
+ *  finalize_stitch_rebuild_commit_ms, finalize_stitch_rebuild_faces_in,
+ *  finalize_stitch_rebuild_faces_out,
+ *  whole_partial_attempts, whole_partial_accepts,
+ *  whole_partial_total_ms, whole_partial_split_ms,
+ *  whole_partial_boundary_build_ms,
+ *  whole_partial_split_triangle_fast_faces,
+ *  whole_partial_split_cdt_faces,
+ *  whole_partial_split_cdt_points_total,
+ *  whole_partial_split_cdt_constraints_total,
+ *  whole_partial_split_cdt_segment_constraints_total,
+ *  whole_partial_split_cdt_triangles_total,
+ *  whole_partial_triangle_cdt_single_segment_faces,
+ *  whole_partial_triangle_cdt_two_segment_faces,
+ *  whole_partial_triangle_cdt_three_plus_segment_faces,
+ *  whole_partial_triangle_cdt_all_boundary_segment_faces,
+ *  whole_partial_triangle_cdt_mixed_boundary_segment_faces,
+ *  whole_partial_triangle_cdt_any_interior_segment_faces,
+ *  whole_partial_classify_source_ms, whole_partial_classify_touched_ms,
+ *  whole_partial_extract_ms, whole_partial_extract_untouched_ms,
+ *  whole_partial_extract_interface_ms, whole_partial_extract_touched_ms,
+ *  whole_partial_finalize_ms,
+ *  whole_partial_interface_faces_total,
+ *  whole_partial_interface_faces_emitted,
+ *  whole_partial_interface_boundary_edge_hits,
+ *  whole_partial_interface_raw_edge_fallbacks,
+ *  whole_partial_touched_faces_total,
+ *  whole_partial_touched_faces_emitted,
+ *  whole_partial_touched_patch_attempts,
+ *  whole_partial_touched_patch_direct_regions,
+ *  whole_partial_touched_patch_triangulated_faces,
+ *  whole_partial_touched_fallback_faces,
+ *  whole_partial_touched_lineage_vertices,
+ *  whole_partial_touched_welded_vertices,
+ *  whole_partial_raw_boundary_untouched_edges,
+ *  whole_partial_raw_boundary_interface_edges,
+ *  whole_partial_raw_boundary_touched_edges,
+ *  whole_partial_raw_boundary_mixed_edges,
+ *  whole_partial_raw_non_manifold_untouched_edges,
+ *  whole_partial_raw_non_manifold_interface_edges,
+ *  whole_partial_raw_non_manifold_touched_edges,
+ *  whole_partial_raw_non_manifold_mixed_edges,
+ *  whole_partial_boundary_edges_total,
+ *  whole_partial_non_manifold_edges_total,
+ *  whole_partial_face_ratio_vs_a_total,
+ *  whole_partial_loop_plausible_total,
  *  mesh_buffer...]
  */
 export function mesh_boolean_operation_profiled(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): Float64Array;
 
-/**
- * Perform boolean operation with explicit backend and return stage-level
- * profiling data followed by the result mesh buffer.
- */
-export function mesh_boolean_operation_profiled_with_backend(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string, backend: string): Float64Array;
-
-/**
- * Perform boolean operation on two meshes with explicit backend selection.
- *
- * # Parameters
- * * `backend` - "nextgen".
- */
-export function mesh_boolean_operation_with_backend(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string, backend: string): Float64Array;
-
 /**
  * Perform boolean subtraction on two meshes (A - B)
  */
@@ -232,6 +262,12 @@ export function mesh_boolean_subtraction(vertex_count_a: number, buffer_a: Float
  */
 export function mesh_boolean_union(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array): Float64Array;
 
+export function mesh_boolean_whole_partial_candidate(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): Float64Array;
+
+export function mesh_boolean_whole_partial_candidate_debug(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): Float64Array;
+
+export function mesh_boolean_whole_partial_candidate_debug_full(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, operation: string): Float64Array;
+
 /**
  * Extract boundary (perimeter) edges from a mesh as polylines.
  * Returns polyline buffer: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
@@ -453,6 +489,12 @@ export function mesh_rotate(vertex_count: number, buffer: Float64Array, ax: numb
  */
 export function mesh_scale(vertex_count: number, buffer: Float64Array, sx: number, sy: number, sz: number): Float64Array;
 
+/**
+ * Return welded-edge topology metrics for a triangulated mesh buffer:
+ * `[boundary_edges, non_manifold_edges]`.
+ */
+export function mesh_topology_metrics(vertex_count: number, buffer: Float64Array): Float64Array;
+
 /**
  * Translate a mesh by an offset vector and return new buffers
  */
@@ -616,12 +658,13 @@ export interface InitOutput {
     readonly mesh_apply_matrix: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly mesh_boolean_intersection: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly mesh_boolean_operation: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
-    readonly mesh_boolean_operation_debug: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+    readonly mesh_boolean_operation_debug: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     readonly mesh_boolean_operation_profiled: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
-    readonly mesh_boolean_operation_profiled_with_backend: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
-    readonly mesh_boolean_operation_with_backend: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
     readonly mesh_boolean_subtraction: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly mesh_boolean_union: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly mesh_boolean_whole_partial_candidate: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
+    readonly mesh_boolean_whole_partial_candidate_debug: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
+    readonly mesh_boolean_whole_partial_candidate_debug_full: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     readonly mesh_boundary_polylines: (a: number, b: number, c: number) => [number, number];
     readonly mesh_build_coplanar_connected_face_groups: (a: number, b: number, c: number) => [number, number];
     readonly mesh_chamfer_all_edges: (a: number, b: number, c: number, d: number, e: number) => [number, number];
@@ -659,6 +702,7 @@ export interface InitOutput {
     readonly mesh_raycast_many: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
     readonly mesh_rotate: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly mesh_scale: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly mesh_topology_metrics: (a: number, b: number, c: number) => [number, number];
     readonly mesh_translate: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly nurbs_curve_curve_intersect: (a: number, b: number, c: number, d: number) => [number, number];
     readonly nurbs_curve_plane_intersect: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
@@ -678,6 +722,7 @@ export interface InitOutput {
     readonly tessellate_nurbs_surface: (a: number, b: number) => [number, number];
     readonly test_wasm: () => [number, number];
     readonly version: () => [number, number];
+    readonly mesh_boolean_last_debug_marker: () => number;
     readonly ray_distance_to_point: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
     readonly __wbindgen_externrefs: WebAssembly.Table;
     readonly __wbindgen_free: (a: number, b: number, c: number) => void;

package/wasm/okgeometrycore.js

@@ -471,17 +471,14 @@ export function mesh_boolean_intersection(vertex_count_a, buffer_a, vertex_count
 }
 
 /**
- * Perform boolean operation on two meshes
- *
- * # Parameters
- * * `vertex_count_a` - Number of vertices in mesh A
- * * `buffer_a` - Buffer for mesh A [vertices..., indices...]
- * * `vertex_count_b` - Number of vertices in mesh B
- * * `buffer_b` - Buffer for mesh B [vertices..., indices...]
- * * `operation` - Operation type: "union", "intersection", or "subtraction"
- *
- * # Returns
- * Result mesh buffer [vertices..., indices...]
+ * @returns {number}
+ */
+export function mesh_boolean_last_debug_marker() {
+    const ret = wasm.mesh_boolean_last_debug_marker();
+    return ret >>> 0;
+}
+
+/**
  * @param {number} vertex_count_a
  * @param {Float64Array} buffer_a
  * @param {number} vertex_count_b
@@ -503,19 +500,18 @@ export function mesh_boolean_operation(vertex_count_a, buffer_a, vertex_count_b,
 }
 
 /**
- * Debug helper: perform boolean operation with explicit backend and return a
- * textual status, including kernel error reason on failure.
+ * Debug helper: perform boolean operation and return a textual status,
+ * including kernel error reason on failure.
  * @param {number} vertex_count_a
  * @param {Float64Array} buffer_a
  * @param {number} vertex_count_b
  * @param {Float64Array} buffer_b
  * @param {string} operation
- * @param {string} backend
  * @returns {string}
  */
-export function mesh_boolean_operation_debug(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation, backend) {
-    let deferred5_0;
-    let deferred5_1;
+export function mesh_boolean_operation_debug(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation) {
+    let deferred4_0;
+    let deferred4_1;
     try {
         const ptr0 = passArrayF64ToWasm0(buffer_a, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
@@ -523,14 +519,12 @@ export function mesh_boolean_operation_debug(vertex_count_a, buffer_a, vertex_co
         const len1 = WASM_VECTOR_LEN;
         const ptr2 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len2 = WASM_VECTOR_LEN;
-        const ptr3 = passStringToWasm0(backend, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len3 = WASM_VECTOR_LEN;
-        const ret = wasm.mesh_boolean_operation_debug(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2, ptr3, len3);
-        deferred5_0 = ret[0];
-        deferred5_1 = ret[1];
+        const ret = wasm.mesh_boolean_operation_debug(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2);
+        deferred4_0 = ret[0];
+        deferred4_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
 }
 
@@ -539,10 +533,12 @@ export function mesh_boolean_operation_debug(vertex_count_a, buffer_a, vertex_co
  * the result mesh buffer.
  *
  * Output format:
- * [profile_len(=42), broadphase_ms, segments_ms, split_ms, classify_ms,
- *  classify_seed_ms, classify_strict_ms, classify_open_component_ms,
+ * [profile_len(=95), broadphase_ms, segments_ms, split_ms,
+ *  split_touched_faces_a, split_source_faces_a, split_touched_faces_b, split_source_faces_b,
+ *  classify_ms, classify_seed_ms, classify_strict_ms, classify_open_component_ms,
  *  extract_ms, extract_primary_ms, extract_fallback_ms,
- *  cleanup_ms, finalize_ms, pair_accepted, pair_rejected, pair_degenerate,
+ *  cleanup_ms, finalize_ms, finalize_cap_ms, finalize_recap_ms, finalize_stitch_ms,
+ *  pair_accepted, pair_rejected, pair_degenerate,
  *  core_passes, core_total_ms, conservative_runs, conservative_ms, nudge_runs, nudge_ms,
  *  recompose_runs, recompose_ms, repair_runs, repair_ms,
  *  repair_loops, repair_loops_capped, repair_loop_vertices, repair_loop_max_vertices,
@@ -553,6 +549,59 @@ export function mesh_boolean_operation_debug(vertex_count_a, buffer_a, vertex_co
  *  arrangement_adj_non_manifold_edges_total, arrangement_adj_non_manifold_limit_total,
  *  arrangement_adj_non_manifold_tolerated_attempts,
  *  arrangement_adj_fallback_non_manifold_excess_total,
+ *  subtraction_ultra_cases, subtraction_ultra_component_fallback_runs,
+ *  subtraction_ultra_open_bounds_total, subtraction_ultra_open_bounds_max,
+ *  subtraction_ultra_best_boundary_total, subtraction_ultra_best_non_manifold_total,
+ *  subtraction_ultra_scoped_faces_total, subtraction_ultra_scoped_faces_max,
+ *  subtraction_ultra_scoped_strict_evals_total, subtraction_ultra_scoped_strict_evals_max,
+ *  finalize_stitch_rebuild_ms, finalize_stitch_recap_ms,
+ *  finalize_stitch_attempts, finalize_stitch_kept,
+ *  finalize_stitch_rebuild_collect_ms, finalize_stitch_rebuild_weld_ms,
+ *  finalize_stitch_rebuild_commit_ms, finalize_stitch_rebuild_faces_in,
+ *  finalize_stitch_rebuild_faces_out,
+ *  whole_partial_attempts, whole_partial_accepts,
+ *  whole_partial_total_ms, whole_partial_split_ms,
+ *  whole_partial_boundary_build_ms,
+ *  whole_partial_split_triangle_fast_faces,
+ *  whole_partial_split_cdt_faces,
+ *  whole_partial_split_cdt_points_total,
+ *  whole_partial_split_cdt_constraints_total,
+ *  whole_partial_split_cdt_segment_constraints_total,
+ *  whole_partial_split_cdt_triangles_total,
+ *  whole_partial_triangle_cdt_single_segment_faces,
+ *  whole_partial_triangle_cdt_two_segment_faces,
+ *  whole_partial_triangle_cdt_three_plus_segment_faces,
+ *  whole_partial_triangle_cdt_all_boundary_segment_faces,
+ *  whole_partial_triangle_cdt_mixed_boundary_segment_faces,
+ *  whole_partial_triangle_cdt_any_interior_segment_faces,
+ *  whole_partial_classify_source_ms, whole_partial_classify_touched_ms,
+ *  whole_partial_extract_ms, whole_partial_extract_untouched_ms,
+ *  whole_partial_extract_interface_ms, whole_partial_extract_touched_ms,
+ *  whole_partial_finalize_ms,
+ *  whole_partial_interface_faces_total,
+ *  whole_partial_interface_faces_emitted,
+ *  whole_partial_interface_boundary_edge_hits,
+ *  whole_partial_interface_raw_edge_fallbacks,
+ *  whole_partial_touched_faces_total,
+ *  whole_partial_touched_faces_emitted,
+ *  whole_partial_touched_patch_attempts,
+ *  whole_partial_touched_patch_direct_regions,
+ *  whole_partial_touched_patch_triangulated_faces,
+ *  whole_partial_touched_fallback_faces,
+ *  whole_partial_touched_lineage_vertices,
+ *  whole_partial_touched_welded_vertices,
+ *  whole_partial_raw_boundary_untouched_edges,
+ *  whole_partial_raw_boundary_interface_edges,
+ *  whole_partial_raw_boundary_touched_edges,
+ *  whole_partial_raw_boundary_mixed_edges,
+ *  whole_partial_raw_non_manifold_untouched_edges,
+ *  whole_partial_raw_non_manifold_interface_edges,
+ *  whole_partial_raw_non_manifold_touched_edges,
+ *  whole_partial_raw_non_manifold_mixed_edges,
+ *  whole_partial_boundary_edges_total,
+ *  whole_partial_non_manifold_edges_total,
+ *  whole_partial_face_ratio_vs_a_total,
+ *  whole_partial_loop_plausible_total,
  *  mesh_buffer...]
  * @param {number} vertex_count_a
  * @param {Float64Array} buffer_a
@@ -575,95 +624,104 @@ export function mesh_boolean_operation_profiled(vertex_count_a, buffer_a, vertex
 }
 
 /**
- * Perform boolean operation with explicit backend and return stage-level
- * profiling data followed by the result mesh buffer.
+ * Perform boolean subtraction on two meshes (A - B)
  * @param {number} vertex_count_a
  * @param {Float64Array} buffer_a
  * @param {number} vertex_count_b
  * @param {Float64Array} buffer_b
- * @param {string} operation
- * @param {string} backend
  * @returns {Float64Array}
  */
-export function mesh_boolean_operation_profiled_with_backend(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation, backend) {
+export function mesh_boolean_subtraction(vertex_count_a, buffer_a, vertex_count_b, buffer_b) {
     const ptr0 = passArrayF64ToWasm0(buffer_a, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArrayF64ToWasm0(buffer_b, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len2 = WASM_VECTOR_LEN;
-    const ptr3 = passStringToWasm0(backend, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len3 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_boolean_operation_profiled_with_backend(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2, ptr3, len3);
-    var v5 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    const ret = wasm.mesh_boolean_subtraction(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v5;
+    return v3;
+}
+
+/**
+ * Perform boolean union on two meshes
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @returns {Float64Array}
+ */
+export function mesh_boolean_union(vertex_count_a, buffer_a, vertex_count_b, buffer_b) {
+    const ptr0 = passArrayF64ToWasm0(buffer_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(buffer_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_boolean_union(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
 }
 
 /**
- * Perform boolean operation on two meshes with explicit backend selection.
- *
- * # Parameters
- * * `backend` - "nextgen".
  * @param {number} vertex_count_a
  * @param {Float64Array} buffer_a
  * @param {number} vertex_count_b
  * @param {Float64Array} buffer_b
  * @param {string} operation
- * @param {string} backend
  * @returns {Float64Array}
  */
-export function mesh_boolean_operation_with_backend(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation, backend) {
+export function mesh_boolean_whole_partial_candidate(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation) {
     const ptr0 = passArrayF64ToWasm0(buffer_a, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArrayF64ToWasm0(buffer_b, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
     const ptr2 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len2 = WASM_VECTOR_LEN;
-    const ptr3 = passStringToWasm0(backend, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len3 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_boolean_operation_with_backend(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2, ptr3, len3);
-    var v5 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    const ret = wasm.mesh_boolean_whole_partial_candidate(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2);
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v5;
+    return v4;
 }
 
 /**
- * Perform boolean subtraction on two meshes (A - B)
  * @param {number} vertex_count_a
  * @param {Float64Array} buffer_a
  * @param {number} vertex_count_b
  * @param {Float64Array} buffer_b
+ * @param {string} operation
  * @returns {Float64Array}
  */
-export function mesh_boolean_subtraction(vertex_count_a, buffer_a, vertex_count_b, buffer_b) {
+export function mesh_boolean_whole_partial_candidate_debug(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation) {
     const ptr0 = passArrayF64ToWasm0(buffer_a, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArrayF64ToWasm0(buffer_b, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_boolean_subtraction(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1);
-    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    const ptr2 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_boolean_whole_partial_candidate_debug(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2);
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v3;
+    return v4;
 }
 
 /**
- * Perform boolean union on two meshes
  * @param {number} vertex_count_a
  * @param {Float64Array} buffer_a
  * @param {number} vertex_count_b
  * @param {Float64Array} buffer_b
+ * @param {string} operation
  * @returns {Float64Array}
  */
-export function mesh_boolean_union(vertex_count_a, buffer_a, vertex_count_b, buffer_b) {
+export function mesh_boolean_whole_partial_candidate_debug_full(vertex_count_a, buffer_a, vertex_count_b, buffer_b, operation) {
     const ptr0 = passArrayF64ToWasm0(buffer_a, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArrayF64ToWasm0(buffer_b, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.mesh_boolean_union(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1);
-    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    const ptr2 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_boolean_whole_partial_candidate_debug_full(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2);
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v3;
+    return v4;
 }
 
 /**
@@ -1327,6 +1385,22 @@ export function mesh_scale(vertex_count, buffer, sx, sy, sz) {
     return v2;
 }
 
+/**
+ * Return welded-edge topology metrics for a triangulated mesh buffer:
+ * `[boundary_edges, non_manifold_edges]`.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_topology_metrics(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_topology_metrics(vertex_count, ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Translate a mesh by an offset vector and return new buffers
  * @param {number} vertex_count
@@ -1703,17 +1777,28 @@ export function version() {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg___okgeometry_boolean_should_cancel_3e76652b5286d323: function() {
+        __wbg___okgeometry_boolean_should_cancel_3e7948069660dc47: function() {
             const ret = globalThis.__okgeometry_boolean_should_cancel();
             return ret;
         },
         __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
+        __wbg_error_9a7fe3f932034cde: function(arg0) {
+            console.error(arg0);
+        },
+        __wbg_log_6b5ca2e6124b2808: function(arg0) {
+            console.log(arg0);
+        },
         __wbg_now_a3af9a2f4bbaa4d1: function() {
             const ret = Date.now();
             return ret;
         },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
             const offset = table.grow(4);

package/wasm/okgeometrycore_bg.wasm.d.ts

@@ -27,12 +27,13 @@ export const make_nurbs_curves_compatible: (a: number, b: number) => [number, nu
 export const mesh_apply_matrix: (a: number, b: number, c: number, d: number, e: number) => [number, number];
 export const mesh_boolean_intersection: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
 export const mesh_boolean_operation: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
-export const mesh_boolean_operation_debug: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+export const mesh_boolean_operation_debug: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
 export const mesh_boolean_operation_profiled: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
-export const mesh_boolean_operation_profiled_with_backend: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
-export const mesh_boolean_operation_with_backend: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
 export const mesh_boolean_subtraction: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
 export const mesh_boolean_union: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+export const mesh_boolean_whole_partial_candidate: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
+export const mesh_boolean_whole_partial_candidate_debug: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
+export const mesh_boolean_whole_partial_candidate_debug_full: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
 export const mesh_boundary_polylines: (a: number, b: number, c: number) => [number, number];
 export const mesh_build_coplanar_connected_face_groups: (a: number, b: number, c: number) => [number, number];
 export const mesh_chamfer_all_edges: (a: number, b: number, c: number, d: number, e: number) => [number, number];
@@ -70,6 +71,7 @@ export const mesh_raycast_all: (a: number, b: number, c: number, d: number, e: n
 export const mesh_raycast_many: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
 export const mesh_rotate: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
 export const mesh_scale: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+export const mesh_topology_metrics: (a: number, b: number, c: number) => [number, number];
 export const mesh_translate: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
 export const nurbs_curve_curve_intersect: (a: number, b: number, c: number, d: number) => [number, number];
 export const nurbs_curve_plane_intersect: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
@@ -89,6 +91,7 @@ export const sweep_polylines: (a: number, b: number, c: number, d: number, e: nu
 export const tessellate_nurbs_surface: (a: number, b: number) => [number, number];
 export const test_wasm: () => [number, number];
 export const version: () => [number, number];
+export const mesh_boolean_last_debug_marker: () => number;
 export const ray_distance_to_point: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
 export const __wbindgen_externrefs: WebAssembly.Table;
 export const __wbindgen_free: (a: number, b: number, c: number) => void;

package/wasm/package.json

@@ -5,7 +5,7 @@
     "Mostafa El Ayoubi <m.elayoubi@orkestra.online>"
   ],
   "description": "Production-grade geometry engine in Rust compiled to WASM for OkNodes",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "files": [
     "okgeometrycore_bg.wasm",
     "okgeometrycore.js",